diff options
| author | vvvv <vvvv@yandex-team.ru> | 2022-03-02 21:58:12 +0300 |
|---|---|---|
| committer | vvvv <vvvv@yandex-team.ru> | 2022-03-02 21:58:12 +0300 |
| commit | b3e58e6a1f6b37f788fce4205f7a9484ca355607 (patch) | |
| tree | a894e40a9a8446f9436af7909ced1ab865edd6ea | |
| parent | 5311be47588ef1c5cb5b5debb5dce86a633d1187 (diff) | |
| download | ydb-b3e58e6a1f6b37f788fce4205f7a9484ca355607.tar.gz | |
YQL-13710 use .dat from contrib
ref:9c6092ec75933d1325acf5ecf1217d408ea5dcad
200 files changed, 23555 insertions, 16 deletions
diff --git a/contrib/libs/postgresql/COPYRIGHT b/contrib/libs/postgresql/COPYRIGHT new file mode 100644 index 0000000000..655a3c59d6 --- /dev/null +++ b/contrib/libs/postgresql/COPYRIGHT @@ -0,0 +1,23 @@ +PostgreSQL Database Management System +(formerly known as Postgres, then as Postgres95) + +Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group + +Portions Copyright (c) 1994, The Regents of the University of California + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose, without fee, and without a written agreement +is hereby granted, provided that the above copyright notice and this +paragraph and the following two paragraphs appear in all copies. + +IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR +DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING +LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS +DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + +THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, +INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS +ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATIONS TO +PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. diff --git a/contrib/libs/postgresql/HISTORY b/contrib/libs/postgresql/HISTORY new file mode 100644 index 0000000000..b87be55abf --- /dev/null +++ b/contrib/libs/postgresql/HISTORY @@ -0,0 +1,5 @@ +Release notes for all versions of PostgreSQL can be found on-line at +https://www.postgresql.org/docs/current/release.html + +Distribution file sets include release notes for their version and preceding +versions. Visit the file doc/src/sgml/html/release.html in an HTML browser. diff --git a/contrib/libs/postgresql/INSTALL b/contrib/libs/postgresql/INSTALL new file mode 100644 index 0000000000..15c36afbda --- /dev/null +++ b/contrib/libs/postgresql/INSTALL @@ -0,0 +1,1566 @@ + +PostgreSQL Installation from Source Code + +------------------------------------------------------------------------ + +This document describes the installation of PostgreSQL using this source +code distribution. + +If you are building PostgreSQL for Microsoft Windows, read this document +if you intend to build with MinGW or Cygwin; but if you intend to build +with Microsoft's Visual C++, see the main documentation instead. + +------------------------------------------------------------------------ + + +Short Version + + ./configure + make + su + make install + adduser postgres + mkdir /usr/local/pgsql/data + chown postgres /usr/local/pgsql/data + su - postgres + /usr/local/pgsql/bin/initdb -D /usr/local/pgsql/data + /usr/local/pgsql/bin/pg_ctl -D /usr/local/pgsql/data -l logfile start + /usr/local/pgsql/bin/createdb test + /usr/local/pgsql/bin/psql test + +The long version is the rest of this document. + +------------------------------------------------------------------------ + + +Requirements + +In general, a modern Unix-compatible platform should be able to run +PostgreSQL. The platforms that had received specific testing at the time +of release are described in the section called "Supported Platforms" +below. + +The following software packages are required for building PostgreSQL: + +- GNU make version 3.80 or newer is required; other make programs or + older GNU make versions will *not* work. (GNU make is sometimes + installed under the name "gmake".) To test for GNU make enter: + + make --version + +- You need an ISO/ANSI C compiler (at least C99-compliant). Recent + versions of GCC are recommended, but PostgreSQL is known to build + using a wide variety of compilers from different vendors. + +- tar is required to unpack the source distribution, in addition to + either gzip or bzip2. + +- The GNU Readline library is used by default. It allows psql (the + PostgreSQL command line SQL interpreter) to remember each command + you type, and allows you to use arrow keys to recall and edit + previous commands. This is very helpful and is strongly recommended. + If you don't want to use it then you must specify the + "--without-readline" option to "configure". As an alternative, you + can often use the BSD-licensed "libedit" library, originally + developed on NetBSD. The "libedit" library is GNU + Readline-compatible and is used if "libreadline" is not found, or if + "--with-libedit-preferred" is used as an option to "configure". If + you are using a package-based Linux distribution, be aware that you + need both the readline and readline-devel packages, if those are + separate in your distribution. + +- The zlib compression library is used by default. If you don't want + to use it then you must specify the "--without-zlib" option to + "configure". Using this option disables support for compressed + archives in pg_dump and pg_restore. + +The following packages are optional. They are not required in the +default configuration, but they are needed when certain build options +are enabled, as explained below: + +- To build the server programming language PL/Perl you need a full + Perl installation, including the "libperl" library and the header + files. The minimum required version is Perl 5.8.3. Since PL/Perl + will be a shared library, the "libperl" library must be a shared + library also on most platforms. This appears to be the default in + recent Perl versions, but it was not in earlier versions, and in any + case it is the choice of whomever installed Perl at your site. + "configure" will fail if building PL/Perl is selected but it cannot + find a shared "libperl". In that case, you will have to rebuild and + install Perl manually to be able to build PL/Perl. During the + configuration process for Perl, request a shared library. + + If you intend to make more than incidental use of PL/Perl, you + should ensure that the Perl installation was built with the + usemultiplicity option enabled (perl -V will show whether this is + the case). + +- To build the PL/Python server programming language, you need a + Python installation with the header files and the distutils module. + The minimum required version is Python 2.6. Python 3 is supported if + it's version 3.1 or later; but see the PL/Python documentation when + using Python 3. + + Since PL/Python will be a shared library, the "libpython" library + must be a shared library also on most platforms. This is not the + case in a default Python installation built from source, but a + shared library is available in many operating system distributions. + "configure" will fail if building PL/Python is selected but it + cannot find a shared "libpython". That might mean that you either + have to install additional packages or rebuild (part of) your Python + installation to provide this shared library. When building from + source, run Python's configure with the --enable-shared flag. + +- To build the PL/Tcl procedural language, you of course need a Tcl + installation. The minimum required version is Tcl 8.4. + +- To enable Native Language Support (NLS), that is, the ability to + display a program's messages in a language other than English, you + need an implementation of the Gettext API. Some operating systems + have this built-in (e.g., Linux, NetBSD, Solaris), for other systems + you can download an add-on package from + http://www.gnu.org/software/gettext/. If you are using the Gettext + implementation in the GNU C library then you will additionally need + the GNU Gettext package for some utility programs. For any of the + other implementations you will not need it. + +- You need OpenSSL, if you want to support encrypted client + connections. OpenSSL is also required for random number generation + on platforms that do not have "/dev/urandom" (except Windows). The + minimum version required is 1.0.1. + +- You need Kerberos, OpenLDAP, and/or PAM, if you want to support + authentication using those services. + +- To build the PostgreSQL documentation, there is a separate set of + requirements; see the main documentation's appendix on + documentation. + +If you are building from a Git tree instead of using a released source +package, or if you want to do server development, you also need the +following packages: + +- Flex and Bison are needed to build from a Git checkout, or if you + changed the actual scanner and parser definition files. If you need + them, be sure to get Flex 2.5.31 or later and Bison 1.875 or later. + Other lex and yacc programs cannot be used. + +- Perl 5.8.3 or later is needed to build from a Git checkout, or if + you changed the input files for any of the build steps that use Perl + scripts. If building on Windows you will need Perl in any case. Perl + is also required to run some test suites. + +If you need to get a GNU package, you can find it at your local GNU +mirror site (see https://www.gnu.org/prep/ftp for a list) or at +ftp://ftp.gnu.org/gnu/. + +Also check that you have sufficient disk space. You will need about 350 +MB for the source tree during compilation and about 60 MB for the +installation directory. An empty database cluster takes about 40 MB; +databases take about five times the amount of space that a flat text +file with the same data would take. If you are going to run the +regression tests you will temporarily need up to an extra 300 MB. Use +the "df" command to check free disk space. + +------------------------------------------------------------------------ + + +Installation Procedure + +1. CONFIGURATION + + The first step of the installation procedure is to configure the + source tree for your system and choose the options you would like. + This is done by running the "configure" script. For a default + installation simply enter: + + ./configure + + This script will run a number of tests to determine values for + various system dependent variables and detect any quirks of your + operating system, and finally will create several files in the build + tree to record what it found. + + You can also run "configure" in a directory outside the source tree, + and then build there, if you want to keep the build directory + separate from the original source files. This procedure is called a + VPATH build. Here's how: + + mkdir build_dir + cd build_dir + /path/to/source/tree/configure [options go here] + make + + The default configuration will build the server and utilities, as + well as all client applications and interfaces that require only a C + compiler. All files will be installed under "/usr/local/pgsql" by + default. + + You can customize the build and installation process by supplying + one or more command line options to "configure". Typically you would + customize the install location, or the set of optional features that + are built. "configure" has a large number of options, which are + described in the section called "configure Options". + + Also, "configure" responds to certain environment variables, as + described in the section called "configure Environment Variables". + These provide additional ways to customize the configuration. + +2. BUILD + + To start the build, type either of: + + make + make all + + (Remember to use GNU make.) The build will take a few minutes + depending on your hardware. + + If you want to build everything that can be built, including the + documentation (HTML and man pages), and the additional modules + ("contrib"), type instead: + + make world + + If you want to build everything that can be built, including the + additional modules ("contrib"), but without the documentation, type + instead: + + make world-bin + + If you want to invoke the build from another makefile rather than + manually, you must unset MAKELEVEL or set it to zero, for instance + like this: + + build-postgresql: + $(MAKE) -C postgresql MAKELEVEL=0 all + + Failure to do that can lead to strange error messages, typically + about missing header files. + +3. REGRESSION TESTS + + If you want to test the newly built server before you install it, + you can run the regression tests at this point. The regression tests + are a test suite to verify that PostgreSQL runs on your machine in + the way the developers expected it to. Type: + + make check + + (This won't work as root; do it as an unprivileged user.) See the + file "src/test/regress/README" and the documentation for detailed + information about interpreting the test results. You can repeat this + test at any later time by issuing the same command. + +4. INSTALLING THE FILES + + NOTE: + + If you are upgrading an existing system be sure to read the + documentation, which has instructions about upgrading a cluster. + + To install PostgreSQL enter: + + make install + + This will install files into the directories that were specified in + Step 1. Make sure that you have appropriate permissions to write + into that area. Normally you need to do this step as root. + Alternatively, you can create the target directories in advance and + arrange for appropriate permissions to be granted. + + To install the documentation (HTML and man pages), enter: + + make install-docs + + If you built the world above, type instead: + + make install-world + + This also installs the documentation. + + If you built the world without the documentation above, type + instead: + + make install-world-bin + + You can use make install-strip instead of make install to strip the + executable files and libraries as they are installed. This will save + some space. If you built with debugging support, stripping will + effectively remove the debugging support, so it should only be done + if debugging is no longer needed. install-strip tries to do a + reasonable job saving space, but it does not have perfect knowledge + of how to strip every unneeded byte from an executable file, so if + you want to save all the disk space you possibly can, you will have + to do manual work. + + The standard installation provides all the header files needed for + client application development as well as for server-side program + development, such as custom functions or data types written in C. + (Prior to PostgreSQL 8.0, a separate make install-all-headers + command was needed for the latter, but this step has been folded + into the standard install.) + + CLIENT-ONLY INSTALLATION: If you want to install only the client + applications and interface libraries, then you can use these + commands: + + make -C src/bin install + make -C src/include install + make -C src/interfaces install + make -C doc install + + "src/bin" has a few binaries for server-only use, but they are + small. + +UNINSTALLATION: To undo the installation use the command "make +uninstall". However, this will not remove any created directories. + +CLEANING: After the installation you can free disk space by removing +the built files from the source tree with the command "make clean". This +will preserve the files made by the "configure" program, so that you can +rebuild everything with "make" later on. To reset the source tree to the +state in which it was distributed, use "make distclean". If you are +going to build for several platforms within the same source tree you +must do this and re-configure for each platform. (Alternatively, use a +separate build tree for each platform, so that the source tree remains +unmodified.) + +If you perform a build and then discover that your "configure" options +were wrong, or if you change anything that "configure" investigates (for +example, software upgrades), then it's a good idea to do "make +distclean" before reconfiguring and rebuilding. Without this, your +changes in configuration choices might not propagate everywhere they +need to. + +------------------------------------------------------------------------ + +configure Options + +"configure"'s command line options are explained below. This list is not +exhaustive (use ./configure --help to get one that is). The options not +covered here are meant for advanced use-cases such as cross-compilation, +and are documented in the standard Autoconf documentation. + +------------------------------------------------------------------------ + +Installation Locations + +These options control where make install will put the files. The +"--prefix" option is sufficient for most cases. If you have special +needs, you can customize the installation subdirectories with the other +options described in this section. Beware however that changing the +relative locations of the different subdirectories may render the +installation non-relocatable, meaning you won't be able to move it after +installation. (The man and doc locations are not affected by this +restriction.) For relocatable installs, you might want to use the +--disable-rpath option described later. + +--prefix=PREFIX + + Install all files under the directory "PREFIX" instead of + "/usr/local/pgsql". The actual files will be installed into various + subdirectories; no files will ever be installed directly into the + "PREFIX" directory. + +--exec-prefix=EXEC-PREFIX + + You can install architecture-dependent files under a different + prefix, "EXEC-PREFIX", than what "PREFIX" was set to. This can be + useful to share architecture-independent files between hosts. If you + omit this, then "EXEC-PREFIX" is set equal to "PREFIX" and both + architecture-dependent and independent files will be installed under + the same tree, which is probably what you want. + +--bindir=DIRECTORY + + Specifies the directory for executable programs. The default is + "EXEC-PREFIX/bin", which normally means "/usr/local/pgsql/bin". + +--sysconfdir=DIRECTORY + + Sets the directory for various configuration files, "PREFIX/etc" by + default. + +--libdir=DIRECTORY + + Sets the location to install libraries and dynamically loadable + modules. The default is "EXEC-PREFIX/lib". + +--includedir=DIRECTORY + + Sets the directory for installing C and C++ header files. The + default is "PREFIX/include". + +--datarootdir=DIRECTORY + + Sets the root directory for various types of read-only data files. + This only sets the default for some of the following options. The + default is "PREFIX/share". + +--datadir=DIRECTORY + + Sets the directory for read-only data files used by the installed + programs. The default is "DATAROOTDIR". Note that this has nothing + to do with where your database files will be placed. + +--localedir=DIRECTORY + + Sets the directory for installing locale data, in particular message + translation catalog files. The default is "DATAROOTDIR/locale". + +--mandir=DIRECTORY + + The man pages that come with PostgreSQL will be installed under this + directory, in their respective "manx" subdirectories. The default is + "DATAROOTDIR/man". + +--docdir=DIRECTORY + + Sets the root directory for installing documentation files, except + "man" pages. This only sets the default for the following options. + The default value for this option is "DATAROOTDIR/doc/postgresql". + +--htmldir=DIRECTORY + + The HTML-formatted documentation for PostgreSQL will be installed + under this directory. The default is "DATAROOTDIR". + +NOTE: + +Care has been taken to make it possible to install PostgreSQL into +shared installation locations (such as "/usr/local/include") without +interfering with the namespace of the rest of the system. First, the +string "/postgresql" is automatically appended to datadir, sysconfdir, +and docdir, unless the fully expanded directory name already contains +the string "postgres" or "pgsql". For example, if you choose +"/usr/local" as prefix, the documentation will be installed in +"/usr/local/doc/postgresql", but if the prefix is "/opt/postgres", then +it will be in "/opt/postgres/doc". The public C header files of the +client interfaces are installed into includedir and are namespace-clean. +The internal header files and the server header files are installed into +private directories under includedir. See the documentation of each +interface for information about how to access its header files. Finally, +a private subdirectory will also be created, if appropriate, under +libdir for dynamically loadable modules. + +------------------------------------------------------------------------ + +PostgreSQL Features + +The options described in this section enable building of various +PostgreSQL features that are not built by default. Most of these are +non-default only because they require additional software, as described +in the section called "Requirements". + +--enable-nls[=LANGUAGES] + + Enables Native Language Support (NLS), that is, the ability to + display a program's messages in a language other than English. + "LANGUAGES" is an optional space-separated list of codes of the + languages that you want supported, for example --enable-nls='de fr'. + (The intersection between your list and the set of actually provided + translations will be computed automatically.) If you do not specify + a list, then all available translations are installed. + + To use this option, you will need an implementation of the Gettext + API. + +--with-perl + + Build the PL/Perl server-side language. + +--with-python + + Build the PL/Python server-side language. + +--with-tcl + + Build the PL/Tcl server-side language. + +--with-tclconfig=DIRECTORY + + Tcl installs the file "tclConfig.sh", which contains configuration + information needed to build modules interfacing to Tcl. This file is + normally found automatically at a well-known location, but if you + want to use a different version of Tcl you can specify the directory + in which to look for "tclConfig.sh". + +--with-icu + + Build with support for the ICU library, enabling use of ICU + collation features. This requires the ICU4C package to be installed. + The minimum required version of ICU4C is currently 4.2. + + By default, pkg-config will be used to find the required compilation + options. This is supported for ICU4C version 4.6 and later. For + older versions, or if pkg-config is not available, the variables + ICU_CFLAGS and ICU_LIBS can be specified to "configure", like in + this example: + + ./configure ... --with-icu ICU_CFLAGS='-I/some/where/include' ICU_LIBS='-L/some/where/lib -licui18n -licuuc -licudata' + + (If ICU4C is in the default search path for the compiler, then you + still need to specify nonempty strings in order to avoid use of + pkg-config, for example, ICU_CFLAGS=' '.) + +--with-llvm + + Build with support for LLVM based JIT compilation. This requires the + LLVM library to be installed. The minimum required version of LLVM + is currently 3.9. + + "llvm-config" will be used to find the required compilation options. + "llvm-config", and then "llvm-config-$major-$minor" for all + supported versions, will be searched for in your PATH. If that would + not yield the desired program, use LLVM_CONFIG to specify a path to + the correct "llvm-config". For example + + ./configure ... --with-llvm LLVM_CONFIG='/path/to/llvm/bin/llvm-config' + + LLVM support requires a compatible "clang" compiler (specified, if + necessary, using the CLANG environment variable), and a working C++ + compiler (specified, if necessary, using the CXX environment + variable). + +--with-openssl + + Build with support for SSL (encrypted) connections. This requires + the OpenSSL package to be installed. "configure" will check for the + required header files and libraries to make sure that your OpenSSL + installation is sufficient before proceeding. + +--with-gssapi + + Build with support for GSSAPI authentication. On many systems, the + GSSAPI system (usually a part of the Kerberos installation) is not + installed in a location that is searched by default (e.g., + "/usr/include", "/usr/lib"), so you must use the options + "--with-includes" and "--with-libraries" in addition to this option. + "configure" will check for the required header files and libraries + to make sure that your GSSAPI installation is sufficient before + proceeding. + +--with-ldap + + Build with LDAP support for authentication and connection parameter + lookup (see the documentation about client authentication and libpq + for more information). On Unix, this requires the OpenLDAP package + to be installed. On Windows, the default WinLDAP library is used. + "configure" will check for the required header files and libraries + to make sure that your OpenLDAP installation is sufficient before + proceeding. + +--with-pam + + Build with PAM (Pluggable Authentication Modules) support. + +--with-bsd-auth + + Build with BSD Authentication support. (The BSD Authentication + framework is currently only available on OpenBSD.) + +--with-systemd + + Build with support for systemd service notifications. This improves + integration if the server is started under systemd but has no impact + otherwise. libsystemd and the associated header files need to be + installed to use this option. + +--with-bonjour + + Build with support for Bonjour automatic service discovery. This + requires Bonjour support in your operating system. Recommended on + macOS. + +--with-uuid=LIBRARY + + Build the uuid-ossp module (which provides functions to generate + UUIDs), using the specified UUID library. "LIBRARY" must be one of: + + - "bsd" to use the UUID functions found in FreeBSD, NetBSD, and + some other BSD-derived systems + + - "e2fs" to use the UUID library created by the e2fsprogs project; + this library is present in most Linux systems and in macOS, and + can be obtained for other platforms as well + + - "ossp" to use the OSSP UUID library + +--with-ossp-uuid + + Obsolete equivalent of --with-uuid=ossp. + +--with-libxml + + Build with libxml2, enabling SQL/XML support. Libxml2 version 2.6.23 + or later is required for this feature. + + To detect the required compiler and linker options, PostgreSQL will + query "pkg-config", if that is installed and knows about libxml2. + Otherwise the program "xml2-config", which is installed by libxml2, + will be used if it is found. Use of "pkg-config" is preferred, + because it can deal with multi-architecture installations better. + + To use a libxml2 installation that is in an unusual location, you + can set "pkg-config"-related environment variables (see its + documentation), or set the environment variable XML2_CONFIG to point + to the "xml2-config" program belonging to the libxml2 installation, + or set the variables XML2_CFLAGS and XML2_LIBS. (If "pkg-config" is + installed, then to override its idea of where libxml2 is you must + either set XML2_CONFIG or set both XML2_CFLAGS and XML2_LIBS to + nonempty strings.) + +--with-libxslt + + Build with libxslt, enabling the xml2 module to perform XSL + transformations of XML. "--with-libxml" must be specified as well. + +------------------------------------------------------------------------ + +Anti-Features + +The options described in this section allow disabling certain PostgreSQL +features that are built by default, but which might need to be turned +off if the required software or system features are not available. Using +these options is not recommended unless really necessary. + +--without-readline + + Prevents use of the Readline library (and libedit as well). This + option disables command-line editing and history in psql. + +--with-libedit-preferred + + Favors the use of the BSD-licensed libedit library rather than + GPL-licensed Readline. This option is significant only if you have + both libraries installed; the default in that case is to use + Readline. + +--without-zlib + + Prevents use of the Zlib library. This disables support for + compressed archives in pg_dump and pg_restore. + +--disable-spinlocks + + Allow the build to succeed even if PostgreSQL has no CPU spinlock + support for the platform. The lack of spinlock support will result + in very poor performance; therefore, this option should only be used + if the build aborts and informs you that the platform lacks spinlock + support. If this option is required to build PostgreSQL on your + platform, please report the problem to the PostgreSQL developers. + +--disable-atomics + + Disable use of CPU atomic operations. This option does nothing on + platforms that lack such operations. On platforms that do have them, + this will result in poor performance. This option is only useful for + debugging or making performance comparisons. + +--disable-thread-safety + + Disable the thread-safety of client libraries. This prevents + concurrent threads in libpq and ECPG programs from safely + controlling their private connection handles. Use this only on + platforms with deficient threading support. + +------------------------------------------------------------------------ + +Build Process Details + +--with-includes=DIRECTORIES + + "DIRECTORIES" is a colon-separated list of directories that will be + added to the list the compiler searches for header files. If you + have optional packages (such as GNU Readline) installed in a + non-standard location, you have to use this option and probably also + the corresponding "--with-libraries" option. + + Example: --with-includes=/opt/gnu/include:/usr/sup/include. + +--with-libraries=DIRECTORIES + + "DIRECTORIES" is a colon-separated list of directories to search for + libraries. You will probably have to use this option (and the + corresponding "--with-includes" option) if you have packages + installed in non-standard locations. + + Example: --with-libraries=/opt/gnu/lib:/usr/sup/lib. + +--with-system-tzdata=DIRECTORY + + PostgreSQL includes its own time zone database, which it requires + for date and time operations. This time zone database is in fact + compatible with the IANA time zone database provided by many + operating systems such as FreeBSD, Linux, and Solaris, so it would + be redundant to install it again. When this option is used, the + system-supplied time zone database in "DIRECTORY" is used instead of + the one included in the PostgreSQL source distribution. "DIRECTORY" + must be specified as an absolute path. "/usr/share/zoneinfo" is a + likely directory on some operating systems. Note that the + installation routine will not detect mismatching or erroneous time + zone data. If you use this option, you are advised to run the + regression tests to verify that the time zone data you have pointed + to works correctly with PostgreSQL. + + This option is mainly aimed at binary package distributors who know + their target operating system well. The main advantage of using this + option is that the PostgreSQL package won't need to be upgraded + whenever any of the many local daylight-saving time rules change. + Another advantage is that PostgreSQL can be cross-compiled more + straightforwardly if the time zone database files do not need to be + built during the installation. + +--with-extra-version=STRING + + Append "STRING" to the PostgreSQL version number. You can use this, + for example, to mark binaries built from unreleased Git snapshots or + containing custom patches with an extra version string, such as a + "git describe" identifier or a distribution package release number. + +--disable-rpath + + Do not mark PostgreSQL's executables to indicate that they should + search for shared libraries in the installation's library directory + (see "--libdir"). On most platforms, this marking uses an absolute + path to the library directory, so that it will be unhelpful if you + relocate the installation later. However, you will then need to + provide some other way for the executables to find the shared + libraries. Typically this requires configuring the operating + system's dynamic linker to search the library directory; see the + section called "Shared Libraries" for more detail. + +------------------------------------------------------------------------ + +Miscellaneous + +It's fairly common, particularly for test builds, to adjust the default +port number with "--with-pgport". The other options in this section are +recommended only for advanced users. + +--with-pgport=NUMBER + + Set "NUMBER" as the default port number for server and clients. The + default is 5432. The port can always be changed later on, but if you + specify it here then both server and clients will have the same + default compiled in, which can be very convenient. Usually the only + good reason to select a non-default value is if you intend to run + multiple PostgreSQL servers on the same machine. + +--with-krb-srvnam=NAME + + The default name of the Kerberos service principal used by GSSAPI. + postgres is the default. There's usually no reason to change this + unless you are building for a Windows environment, in which case it + must be set to upper case POSTGRES. + +--with-segsize=SEGSIZE + + Set the segment size, in gigabytes. Large tables are divided into + multiple operating-system files, each of size equal to the segment + size. This avoids problems with file size limits that exist on many + platforms. The default segment size, 1 gigabyte, is safe on all + supported platforms. If your operating system has "largefile" + support (which most do, nowadays), you can use a larger segment + size. This can be helpful to reduce the number of file descriptors + consumed when working with very large tables. But be careful not to + select a value larger than is supported by your platform and the + file systems you intend to use. Other tools you might wish to use, + such as tar, could also set limits on the usable file size. It is + recommended, though not absolutely required, that this value be a + power of 2. Note that changing this value breaks on-disk database + compatibility, meaning you cannot use "pg_upgrade" to upgrade to a + build with a different segment size. + +--with-blocksize=BLOCKSIZE + + Set the block size, in kilobytes. This is the unit of storage and + I/O within tables. The default, 8 kilobytes, is suitable for most + situations; but other values may be useful in special cases. The + value must be a power of 2 between 1 and 32 (kilobytes). Note that + changing this value breaks on-disk database compatibility, meaning + you cannot use "pg_upgrade" to upgrade to a build with a different + block size. + +--with-wal-blocksize=BLOCKSIZE + + Set the WAL block size, in kilobytes. This is the unit of storage + and I/O within the WAL log. The default, 8 kilobytes, is suitable + for most situations; but other values may be useful in special + cases. The value must be a power of 2 between 1 and 64 (kilobytes). + Note that changing this value breaks on-disk database compatibility, + meaning you cannot use "pg_upgrade" to upgrade to a build with a + different WAL block size. + +------------------------------------------------------------------------ + +Developer Options + +Most of the options in this section are only of interest for developing +or debugging PostgreSQL. They are not recommended for production builds, +except for "--enable-debug", which can be useful to enable detailed bug +reports in the unlucky event that you encounter a bug. On platforms +supporting DTrace, "--enable-dtrace" may also be reasonable to use in +production. + +When building an installation that will be used to develop code inside +the server, it is recommended to use at least the options +"--enable-debug" and "--enable-cassert". + +--enable-debug + + Compiles all programs and libraries with debugging symbols. This + means that you can run the programs in a debugger to analyze + problems. This enlarges the size of the installed executables + considerably, and on non-GCC compilers it usually also disables + compiler optimization, causing slowdowns. However, having the + symbols available is extremely helpful for dealing with any problems + that might arise. Currently, this option is recommended for + production installations only if you use GCC. But you should always + have it on if you are doing development work or running a beta + version. + +--enable-cassert + + Enables assertion checks in the server, which test for many "cannot + happen" conditions. This is invaluable for code development + purposes, but the tests can slow down the server significantly. + Also, having the tests turned on won't necessarily enhance the + stability of your server! The assertion checks are not categorized + for severity, and so what might be a relatively harmless bug will + still lead to server restarts if it triggers an assertion failure. + This option is not recommended for production use, but you should + have it on for development work or when running a beta version. + +--enable-tap-tests + + Enable tests using the Perl TAP tools. This requires a Perl + installation and the Perl module IPC::Run. + +--enable-depend + + Enables automatic dependency tracking. With this option, the + makefiles are set up so that all affected object files will be + rebuilt when any header file is changed. This is useful if you are + doing development work, but is just wasted overhead if you intend + only to compile once and install. At present, this option only works + with GCC. + +--enable-coverage + + If using GCC, all programs and libraries are compiled with code + coverage testing instrumentation. When run, they generate files in + the build directory with code coverage metrics. This option is for + use only with GCC and when doing development work. + +--enable-profiling + + If using GCC, all programs and libraries are compiled so they can be + profiled. On backend exit, a subdirectory will be created that + contains the "gmon.out" file containing profile data. This option is + for use only with GCC and when doing development work. + +--enable-dtrace + + Compiles PostgreSQL with support for the dynamic tracing tool + DTrace. + + To point to the "dtrace" program, the environment variable DTRACE + can be set. This will often be necessary because "dtrace" is + typically installed under "/usr/sbin", which might not be in your + PATH. + + Extra command-line options for the "dtrace" program can be specified + in the environment variable DTRACEFLAGS. On Solaris, to include + DTrace support in a 64-bit binary, you must specify + DTRACEFLAGS="-64". For example, using the GCC compiler: + + ./configure CC='gcc -m64' --enable-dtrace DTRACEFLAGS='-64' ... + + Using Sun's compiler: + + ./configure CC='/opt/SUNWspro/bin/cc -xtarget=native64' --enable-dtrace DTRACEFLAGS='-64' ... + +------------------------------------------------------------------------ + +configure Environment Variables + +In addition to the ordinary command-line options described above, +"configure" responds to a number of environment variables. You can +specify environment variables on the "configure" command line, for +example: + + ./configure CC=/opt/bin/gcc CFLAGS='-O2 -pipe' + +In this usage an environment variable is little different from a +command-line option. You can also set such variables beforehand: + + export CC=/opt/bin/gcc + export CFLAGS='-O2 -pipe' + ./configure + +This usage can be convenient because many programs' configuration +scripts respond to these variables in similar ways. + +The most commonly used of these environment variables are CC and CFLAGS. +If you prefer a C compiler different from the one "configure" picks, you +can set the variable CC to the program of your choice. By default, +"configure" will pick "gcc" if available, else the platform's default +(usually "cc"). Similarly, you can override the default compiler flags +if needed with the CFLAGS variable. + +Here is a list of the significant variables that can be set in this +manner: + +BISON + + Bison program + +CC + + C compiler + +CFLAGS + + options to pass to the C compiler + +CLANG + + path to "clang" program used to process source code for inlining + when compiling with --with-llvm + +CPP + + C preprocessor + +CPPFLAGS + + options to pass to the C preprocessor + +CXX + + C++ compiler + +CXXFLAGS + + options to pass to the C++ compiler + +DTRACE + + location of the "dtrace" program + +DTRACEFLAGS + + options to pass to the "dtrace" program + +FLEX + + Flex program + +LDFLAGS + + options to use when linking either executables or shared libraries + +LDFLAGS_EX + + additional options for linking executables only + +LDFLAGS_SL + + additional options for linking shared libraries only + +LLVM_CONFIG + + "llvm-config" program used to locate the LLVM installation + +MSGFMT + + "msgfmt" program for native language support + +PERL + + Perl interpreter program. This will be used to determine the + dependencies for building PL/Perl. The default is "perl". + +PYTHON + + Python interpreter program. This will be used to determine the + dependencies for building PL/Python. Also, whether Python 2 or 3 is + specified here (or otherwise implicitly chosen) determines which + variant of the PL/Python language becomes available. See the + PL/Python documentation for more information. If this is not set, + the following are probed in this order: python python3 python2. + +TCLSH + + Tcl interpreter program. This will be used to determine the + dependencies for building PL/Tcl. If this is not set, the following + are probed in this order: + tclsh tcl tclsh8.6 tclsh86 tclsh8.5 tclsh85 tclsh8.4 tclsh84. + +XML2_CONFIG + + "xml2-config" program used to locate the libxml2 installation + +Sometimes it is useful to add compiler flags after-the-fact to the set +that were chosen by "configure". An important example is that gcc's +"-Werror" option cannot be included in the CFLAGS passed to "configure", +because it will break many of "configure"'s built-in tests. To add such +flags, include them in the COPT environment variable while running +"make". The contents of COPT are added to both the CFLAGS and LDFLAGS +options set up by "configure". For example, you could do + + make COPT='-Werror' + +or + + export COPT='-Werror' + make + +NOTE: + +If using GCC, it is best to build with an optimization level of at least +"-O1", because using no optimization ("-O0") disables some important +compiler warnings (such as the use of uninitialized variables). However, +non-zero optimization levels can complicate debugging because stepping +through compiled code will usually not match up one-to-one with source +code lines. If you get confused while trying to debug optimized code, +recompile the specific files of interest with "-O0". An easy way to do +this is by passing an option to make: "make PROFILE=-O0 file.o". + +The COPT and PROFILE environment variables are actually handled +identically by the PostgreSQL makefiles. Which to use is a matter of +preference, but a common habit among developers is to use PROFILE for +one-time flag adjustments, while COPT might be kept set all the time. + +------------------------------------------------------------------------ + + +Post-Installation Setup + +------------------------------------------------------------------------ + +Shared Libraries + +On some systems with shared libraries you need to tell the system how to +find the newly installed shared libraries. The systems on which this is +*not* necessary include FreeBSD, HP-UX, Linux, NetBSD, OpenBSD, and +Solaris. + +The method to set the shared library search path varies between +platforms, but the most widely-used method is to set the environment +variable LD_LIBRARY_PATH like so: In Bourne shells ("sh", "ksh", "bash", +"zsh"): + + LD_LIBRARY_PATH=/usr/local/pgsql/lib + export LD_LIBRARY_PATH + +or in "csh" or "tcsh": + + setenv LD_LIBRARY_PATH /usr/local/pgsql/lib + +Replace /usr/local/pgsql/lib with whatever you set "--libdir" to in Step +1. You should put these commands into a shell start-up file such as +"/etc/profile" or "~/.bash_profile". Some good information about the +caveats associated with this method can be found at +http://xahlee.info/UnixResource_dir/_/ldpath.html. + +On some systems it might be preferable to set the environment variable +LD_RUN_PATH *before* building. + +On Cygwin, put the library directory in the PATH or move the ".dll" +files into the "bin" directory. + +If in doubt, refer to the manual pages of your system (perhaps "ld.so" +or "rld"). If you later get a message like: + + psql: error in loading shared libraries + libpq.so.2.1: cannot open shared object file: No such file or directory + +then this step was necessary. Simply take care of it then. + +If you are on Linux and you have root access, you can run: + + /sbin/ldconfig /usr/local/pgsql/lib + +(or equivalent directory) after installation to enable the run-time +linker to find the shared libraries faster. Refer to the manual page of +"ldconfig" for more information. On FreeBSD, NetBSD, and OpenBSD the +command is: + + /sbin/ldconfig -m /usr/local/pgsql/lib + +instead. Other systems are not known to have an equivalent command. + +------------------------------------------------------------------------ + +Environment Variables + +If you installed into "/usr/local/pgsql" or some other location that is +not searched for programs by default, you should add +"/usr/local/pgsql/bin" (or whatever you set "--bindir" to in Step 1) +into your PATH. Strictly speaking, this is not necessary, but it will +make the use of PostgreSQL much more convenient. + +To do this, add the following to your shell start-up file, such as +"~/.bash_profile" (or "/etc/profile", if you want it to affect all +users): + + PATH=/usr/local/pgsql/bin:$PATH + export PATH + +If you are using "csh" or "tcsh", then use this command: + + set path = ( /usr/local/pgsql/bin $path ) + +To enable your system to find the man documentation, you need to add +lines like the following to a shell start-up file unless you installed +into a location that is searched by default: + + MANPATH=/usr/local/pgsql/share/man:$MANPATH + export MANPATH + +The environment variables PGHOST and PGPORT specify to client +applications the host and port of the database server, overriding the +compiled-in defaults. If you are going to run client applications +remotely then it is convenient if every user that plans to use the +database sets PGHOST. This is not required, however; the settings can be +communicated via command line options to most client programs. + +------------------------------------------------------------------------ + + +Getting Started + +The following is a quick summary of how to get PostgreSQL up and running +once installed. The main documentation contains more information. + +1. Create a user account for the PostgreSQL server. This is the user + the server will run as. For production use you should create a + separate, unprivileged account ("postgres" is commonly used). If you + do not have root access or just want to play around, your own user + account is enough, but running the server as root is a security risk + and will not work. + + adduser postgres + +2. Create a database installation with the "initdb" command. To run + "initdb" you must be logged in to your PostgreSQL server account. It + will not work as root. + + root# mkdir /usr/local/pgsql/data + root# chown postgres /usr/local/pgsql/data + root# su - postgres + postgres$ /usr/local/pgsql/bin/initdb -D /usr/local/pgsql/data + + The "-D" option specifies the location where the data will be + stored. You can use any path you want, it does not have to be under + the installation directory. Just make sure that the server account + can write to the directory (or create it, if it doesn't already + exist) before starting "initdb", as illustrated here. + +3. At this point, if you did not use the "initdb" -A option, you might + want to modify "pg_hba.conf" to control local access to the server + before you start it. The default is to trust all local users. + +4. The previous "initdb" step should have told you how to start up the + database server. Do so now. The command should look something like: + + /usr/local/pgsql/bin/pg_ctl -D /usr/local/pgsql/data start + + To stop a server running in the background you can type: + + /usr/local/pgsql/bin/pg_ctl -D /usr/local/pgsql/data stop + +5. Create a database: + + /usr/local/pgsql/bin/createdb testdb + + Then enter: + + /usr/local/pgsql/bin/psql testdb + + to connect to that database. At the prompt you can enter SQL + commands and start experimenting. + +------------------------------------------------------------------------ + + +What Now? + +- The PostgreSQL distribution contains a comprehensive documentation + set, which you should read sometime. After installation, the + documentation can be accessed by pointing your browser to + "/usr/local/pgsql/doc/html/index.html", unless you changed the + installation directories. + + The first few chapters of the main documentation are the Tutorial, + which should be your first reading if you are completely new to SQL + databases. If you are familiar with database concepts then you want + to proceed with part on server administration, which contains + information about how to set up the database server, database users, + and authentication. + +- Usually, you will want to modify your computer so that it will + automatically start the database server whenever it boots. Some + suggestions for this are in the documentation. + +- Run the regression tests against the installed server (using "make + installcheck"). If you didn't run the tests before installation, you + should definitely do it now. This is also explained in the + documentation. + +- By default, PostgreSQL is configured to run on minimal hardware. + This allows it to start up with almost any hardware configuration. + The default configuration is, however, not designed for optimum + performance. To achieve optimum performance, several server + parameters must be adjusted, the two most common being + shared_buffers and work_mem. Other parameters mentioned in the + documentation also affect performance. + +------------------------------------------------------------------------ + + +Supported Platforms + +A platform (that is, a CPU architecture and operating system +combination) is considered supported by the PostgreSQL development +community if the code contains provisions to work on that platform and +it has recently been verified to build and pass its regression tests on +that platform. Currently, most testing of platform compatibility is done +automatically by test machines in the PostgreSQL Build Farm. If you are +interested in using PostgreSQL on a platform that is not represented in +the build farm, but on which the code works or can be made to work, you +are strongly encouraged to set up a build farm member machine so that +continued compatibility can be assured. + +In general, PostgreSQL can be expected to work on these CPU +architectures: x86, x86_64, IA64, PowerPC, PowerPC 64, S/390, S/390x, +Sparc, Sparc 64, ARM, MIPS, MIPSEL, and PA-RISC. Code support exists for +M68K, M32R, and VAX, but these architectures are not known to have been +tested recently. It is often possible to build on an unsupported CPU +type by configuring with "--disable-spinlocks", but performance will be +poor. + +PostgreSQL can be expected to work on these operating systems: Linux +(all recent distributions), Windows (XP and later), FreeBSD, OpenBSD, +NetBSD, macOS, AIX, HP/UX, and Solaris. Other Unix-like systems may also +work but are not currently being tested. In most cases, all CPU +architectures supported by a given operating system will work. Look in +the section called "Platform-Specific Notes" below to see if there is +information specific to your operating system, particularly if using an +older system. + +If you have installation problems on a platform that is known to be +supported according to recent build farm results, please report it to +<pgsql-bugs@lists.postgresql.org>. If you are interested in porting +PostgreSQL to a new platform, <pgsql-hackers@lists.postgresql.org> is +the appropriate place to discuss that. + +------------------------------------------------------------------------ + + +Platform-Specific Notes + +This section documents additional platform-specific issues regarding the +installation and setup of PostgreSQL. Be sure to read the installation +instructions, and in particular the section called "Requirements" as +well. Also, check the file "src/test/regress/README" and the +documentation regarding the interpretation of regression test results. + +Platforms that are not covered here have no known platform-specific +installation issues. + +------------------------------------------------------------------------ + +AIX + +PostgreSQL works on AIX, but AIX versions before about 6.1 have various +issues and are not recommended. You can use GCC or the native IBM +compiler "xlc". + +------------------------------------------------------------------------ + +Memory Management + +AIX can be somewhat peculiar with regards to the way it does memory +management. You can have a server with many multiples of gigabytes of +RAM free, but still get out of memory or address space errors when +running applications. One example is loading of extensions failing with +unusual errors. For example, running as the owner of the PostgreSQL +installation: + + =# CREATE EXTENSION plperl; + ERROR: could not load library "/opt/dbs/pgsql/lib/plperl.so": A memory address is not in the address space for the process. + +Running as a non-owner in the group possessing the PostgreSQL +installation: + + =# CREATE EXTENSION plperl; + ERROR: could not load library "/opt/dbs/pgsql/lib/plperl.so": Bad address + +Another example is out of memory errors in the PostgreSQL server logs, +with every memory allocation near or greater than 256 MB failing. + +The overall cause of all these problems is the default bittedness and +memory model used by the server process. By default, all binaries built +on AIX are 32-bit. This does not depend upon hardware type or kernel in +use. These 32-bit processes are limited to 4 GB of memory laid out in +256 MB segments using one of a few models. The default allows for less +than 256 MB in the heap as it shares a single segment with the stack. + +In the case of the plperl example, above, check your umask and the +permissions of the binaries in your PostgreSQL installation. The +binaries involved in that example were 32-bit and installed as mode 750 +instead of 755. Due to the permissions being set in this fashion, only +the owner or a member of the possessing group can load the library. +Since it isn't world-readable, the loader places the object into the +process' heap instead of the shared library segments where it would +otherwise be placed. + +The "ideal" solution for this is to use a 64-bit build of PostgreSQL, +but that is not always practical, because systems with 32-bit processors +can build, but not run, 64-bit binaries. + +If a 32-bit binary is desired, set LDR_CNTRL to MAXDATA=0xn0000000, +where 1 <= n <= 8, before starting the PostgreSQL server, and try +different values and "postgresql.conf" settings to find a configuration +that works satisfactorily. This use of LDR_CNTRL tells AIX that you want +the server to have MAXDATA bytes set aside for the heap, allocated in +256 MB segments. When you find a workable configuration, "ldedit" can be +used to modify the binaries so that they default to using the desired +heap size. PostgreSQL can also be rebuilt, passing +configure LDFLAGS="-Wl,-bmaxdata:0xn0000000" to achieve the same +effect. + +For a 64-bit build, set OBJECT_MODE to 64 and pass CC="gcc -maix64" and +LDFLAGS="-Wl,-bbigtoc" to "configure". (Options for "xlc" might differ.) +If you omit the export of OBJECT_MODE, your build may fail with linker +errors. When OBJECT_MODE is set, it tells AIX's build utilities such as +"ar", "as", and "ld" what type of objects to default to handling. + +By default, overcommit of paging space can happen. While we have not +seen this occur, AIX will kill processes when it runs out of memory and +the overcommit is accessed. The closest to this that we have seen is +fork failing because the system decided that there was not enough memory +for another process. Like many other parts of AIX, the paging space +allocation method and out-of-memory kill is configurable on a system- or +process-wide basis if this becomes a problem. + +------------------------------------------------------------------------ + +Cygwin + +PostgreSQL can be built using Cygwin, a Linux-like environment for +Windows, but that method is inferior to the native Windows build and +running a server under Cygwin is no longer recommended. + +When building from source, proceed according to the Unix-style +installation procedure (i.e., ./configure; make; etc.), noting the +following Cygwin-specific differences: + +- Set your path to use the Cygwin bin directory before the Windows + utilities. This will help prevent problems with compilation. + +- The "adduser" command is not supported; use the appropriate user + management application on Windows NT, 2000, or XP. Otherwise, skip + this step. + +- The "su" command is not supported; use ssh to simulate su on Windows + NT, 2000, or XP. Otherwise, skip this step. + +- OpenSSL is not supported. + +- Start "cygserver" for shared memory support. To do this, enter the + command /usr/sbin/cygserver &. This program needs to be + running anytime you start the PostgreSQL server or initialize a + database cluster ("initdb"). The default "cygserver" configuration + may need to be changed (e.g., increase SEMMNS) to prevent PostgreSQL + from failing due to a lack of system resources. + +- Building might fail on some systems where a locale other than C is + in use. To fix this, set the locale to C by doing "export + LANG=C.utf8" before building, and then setting it back to the + previous setting after you have installed PostgreSQL. + +- The parallel regression tests (make check) can generate spurious + regression test failures due to overflowing the listen() backlog + queue which causes connection refused errors or hangs. You can limit + the number of connections using the make variable MAX_CONNECTIONS + thus: + + make MAX_CONNECTIONS=5 check + + (On some systems you can have up to about 10 simultaneous + connections.) + +It is possible to install "cygserver" and the PostgreSQL server as +Windows NT services. For information on how to do this, please refer to +the "README" document included with the PostgreSQL binary package on +Cygwin. It is installed in the directory "/usr/share/doc/Cygwin". + +------------------------------------------------------------------------ + +macOS + +To build PostgreSQL from source on macOS, you will need to install +Apple's command line developer tools, which can be done by issuing + + xcode-select --install + +(note that this will pop up a GUI dialog window for confirmation). You +may or may not wish to also install Xcode. + +On recent macOS releases, it's necessary to embed the "sysroot" path in +the include switches used to find some system header files. This results +in the outputs of the configure script varying depending on which SDK +version was used during configure. That shouldn't pose any problem in +simple scenarios, but if you are trying to do something like building an +extension on a different machine than the server code was built on, you +may need to force use of a different sysroot path. To do that, set +PG_SYSROOT, for example + + make PG_SYSROOT=/desired/path all + +To find out the appropriate path on your machine, run + + xcrun --show-sdk-path + +Note that building an extension using a different sysroot version than +was used to build the core server is not really recommended; in the +worst case it could result in hard-to-debug ABI inconsistencies. + +You can also select a non-default sysroot path when configuring, by +specifying PG_SYSROOT to configure: + + ./configure ... PG_SYSROOT=/desired/path + +This would primarily be useful to cross-compile for some other macOS +version. There is no guarantee that the resulting executables will run +on the current host. + +To suppress the "-isysroot" options altogether, use + + ./configure ... PG_SYSROOT=none + +(any nonexistent pathname will work). This might be useful if you wish +to build with a non-Apple compiler, but beware that that case is not +tested or supported by the PostgreSQL developers. + +macOS's "System Integrity Protection" (SIP) feature breaks make check, +because it prevents passing the needed setting of DYLD_LIBRARY_PATH down +to the executables being tested. You can work around that by doing +make install before make check. Most PostgreSQL developers just turn +off SIP, though. + +------------------------------------------------------------------------ + +MinGW/Native Windows + +PostgreSQL for Windows can be built using MinGW, a Unix-like build +environment for Microsoft operating systems, or using Microsoft's Visual +C++ compiler suite. The MinGW build procedure uses the normal build +system described in this chapter; the Visual C++ build works completely +differently and is described in the documentation. + +The native Windows port requires a 32 or 64-bit version of Windows 2000 +or later. Earlier operating systems do not have sufficient +infrastructure (but Cygwin may be used on those). MinGW, the Unix-like +build tools, and MSYS, a collection of Unix tools required to run shell +scripts like "configure", can be downloaded from http://www.mingw.org/. +Neither is required to run the resulting binaries; they are needed only +for creating the binaries. + +To build 64 bit binaries using MinGW, install the 64 bit tool set from +https://mingw-w64.org/, put its bin directory in the PATH, and run +"configure" with the "--host=x86_64-w64-mingw32" option. + +After you have everything installed, it is suggested that you run psql +under "CMD.EXE", as the MSYS console has buffering issues. + +------------------------------------------------------------------------ + +Collecting Crash Dumps on Windows + +If PostgreSQL on Windows crashes, it has the ability to generate +minidumps that can be used to track down the cause for the crash, +similar to core dumps on Unix. These dumps can be read using the Windows +Debugger Tools or using Visual Studio. To enable the generation of dumps +on Windows, create a subdirectory named "crashdumps" inside the cluster +data directory. The dumps will then be written into this directory with +a unique name based on the identifier of the crashing process and the +current time of the crash. + +------------------------------------------------------------------------ + +Solaris + +PostgreSQL is well-supported on Solaris. The more up to date your +operating system, the fewer issues you will experience. + +------------------------------------------------------------------------ + +Required Tools + +You can build with either GCC or Sun's compiler suite. For better code +optimization, Sun's compiler is strongly recommended on the SPARC +architecture. If you are using Sun's compiler, be careful not to select +"/usr/ucb/cc"; use "/opt/SUNWspro/bin/cc". + +You can download Sun Studio from +https://www.oracle.com/technetwork/server-storage/solarisstudio/downloads/. +Many GNU tools are integrated into Solaris 10, or they are present on +the Solaris companion CD. If you need packages for older versions of +Solaris, you can find these tools at http://www.sunfreeware.com. If you +prefer sources, look at https://www.gnu.org/prep/ftp. + +------------------------------------------------------------------------ + +configure Complains About a Failed Test Program + +If "configure" complains about a failed test program, this is probably a +case of the run-time linker being unable to find some library, probably +libz, libreadline or some other non-standard library such as libssl. To +point it to the right location, set the LDFLAGS environment variable on +the "configure" command line, e.g., + + configure ... LDFLAGS="-R /usr/sfw/lib:/opt/sfw/lib:/usr/local/lib" + +See the ld man page for more information. + +------------------------------------------------------------------------ + +Compiling for Optimal Performance + +On the SPARC architecture, Sun Studio is strongly recommended for +compilation. Try using the "-xO5" optimization flag to generate +significantly faster binaries. Do not use any flags that modify behavior +of floating-point operations and errno processing (e.g., "-fast"). + +If you do not have a reason to use 64-bit binaries on SPARC, prefer the +32-bit version. The 64-bit operations are slower and 64-bit binaries are +slower than the 32-bit variants. On the other hand, 32-bit code on the +AMD64 CPU family is not native, so 32-bit code is significantly slower +on that CPU family. + +------------------------------------------------------------------------ + +Using DTrace for Tracing PostgreSQL + +Yes, using DTrace is possible. See the documentation for further +information. + +If you see the linking of the "postgres" executable abort with an error +message like: + + Undefined first referenced + symbol in file + AbortTransaction utils/probes.o + CommitTransaction utils/probes.o + ld: fatal: Symbol referencing errors. No output written to postgres + collect2: ld returned 1 exit status + make: *** [postgres] Error 1 + +your DTrace installation is too old to handle probes in static +functions. You need Solaris 10u4 or newer to use DTrace. diff --git a/contrib/libs/postgresql/README b/contrib/libs/postgresql/README new file mode 100644 index 0000000000..6416a8cf3b --- /dev/null +++ b/contrib/libs/postgresql/README @@ -0,0 +1,27 @@ +PostgreSQL Database Management System +===================================== + +This directory contains the source code distribution of the PostgreSQL +database management system. + +PostgreSQL is an advanced object-relational database management system +that supports an extended subset of the SQL standard, including +transactions, foreign keys, subqueries, triggers, user-defined types +and functions. This distribution also contains C language bindings. + +PostgreSQL has many language interfaces, many of which are listed here: + + https://www.postgresql.org/download/ + +See the file INSTALL for instructions on how to build and install +PostgreSQL. That file also lists supported operating systems and +hardware platforms and contains information regarding any other +software packages that are required to build or run the PostgreSQL +system. Copyright and license information can be found in the +file COPYRIGHT. A comprehensive documentation set is included in this +distribution; it can be read as described in the installation +instructions. + +The latest version of this software may be obtained at +https://www.postgresql.org/download/. For more information look at our +web site located at https://www.postgresql.org/. diff --git a/contrib/libs/postgresql/src/DEVELOPERS b/contrib/libs/postgresql/src/DEVELOPERS new file mode 100644 index 0000000000..103c94cd39 --- /dev/null +++ b/contrib/libs/postgresql/src/DEVELOPERS @@ -0,0 +1,3 @@ +Read the development information in the wiki at +<http://wiki.postgresql.org/wiki/Development_information>. All the +developer tools are located in the src/tools/ directory. diff --git a/contrib/libs/postgresql/src/include/c.h b/contrib/libs/postgresql/src/include/c.h new file mode 100644 index 0000000000..9cd5e233ac --- /dev/null +++ b/contrib/libs/postgresql/src/include/c.h @@ -0,0 +1,1327 @@ +/*------------------------------------------------------------------------- + * + * c.h + * Fundamental C definitions. This is included by every .c file in + * PostgreSQL (via either postgres.h or postgres_fe.h, as appropriate). + * + * Note that the definitions here are not intended to be exposed to clients + * of the frontend interface libraries --- so we don't worry much about + * polluting the namespace with lots of stuff... + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/c.h + * + *------------------------------------------------------------------------- + */ +/* + *---------------------------------------------------------------- + * TABLE OF CONTENTS + * + * When adding stuff to this file, please try to put stuff + * into the relevant section, or add new sections as appropriate. + * + * section description + * ------- ------------------------------------------------ + * 0) pg_config.h and standard system headers + * 1) compiler characteristics + * 2) bool, true, false + * 3) standard system types + * 4) IsValid macros for system types + * 5) offsetof, lengthof, alignment + * 6) assertions + * 7) widely useful macros + * 8) random stuff + * 9) system-specific hacks + * + * NOTE: since this file is included by both frontend and backend modules, + * it's usually wrong to put an "extern" declaration here, unless it's + * ifdef'd so that it's seen in only one case or the other. + * typedefs and macros are the kind of thing that might go here. + * + *---------------------------------------------------------------- + */ +#ifndef C_H +#define C_H + +#include "postgres_ext.h" + +/* Must undef pg_config_ext.h symbols before including pg_config.h */ +#undef PG_INT64_TYPE + +#include "pg_config.h" +#include "pg_config_manual.h" /* must be after pg_config.h */ +#include "pg_config_os.h" /* must be before any system header files */ + +/* System header files that should be available everywhere in Postgres */ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stddef.h> +#include <stdarg.h> +#ifdef HAVE_STRINGS_H +#include <strings.h> +#endif +#include <stdint.h> +#include <sys/types.h> +#include <errno.h> +#if defined(WIN32) || defined(__CYGWIN__) +#include <fcntl.h> /* ensure O_BINARY is available */ +#endif +#include <locale.h> +#ifdef ENABLE_NLS +#include <libintl.h> +#endif + + +/* ---------------------------------------------------------------- + * Section 1: compiler characteristics + * + * type prefixes (const, signed, volatile, inline) are handled in pg_config.h. + * ---------------------------------------------------------------- + */ + +/* + * Disable "inline" if PG_FORCE_DISABLE_INLINE is defined. + * This is used to work around compiler bugs and might also be useful for + * investigatory purposes. + */ +#ifdef PG_FORCE_DISABLE_INLINE +#undef inline +#define inline +#endif + +/* + * Attribute macros + * + * GCC: https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html + * GCC: https://gcc.gnu.org/onlinedocs/gcc/Type-Attributes.html + * Sunpro: https://docs.oracle.com/cd/E18659_01/html/821-1384/gjzke.html + * XLC: https://www.ibm.com/support/knowledgecenter/SSGH2K_13.1.2/com.ibm.xlc131.aix.doc/language_ref/function_attributes.html + * XLC: https://www.ibm.com/support/knowledgecenter/SSGH2K_13.1.2/com.ibm.xlc131.aix.doc/language_ref/type_attrib.html + */ + +/* only GCC supports the unused attribute */ +#ifdef __GNUC__ +#define pg_attribute_unused() __attribute__((unused)) +#else +#define pg_attribute_unused() +#endif + +/* + * Place this macro before functions that should be allowed to make misaligned + * accesses. Think twice before using it on non-x86-specific code! + * Testing can be done with "-fsanitize=alignment -fsanitize-trap=alignment" + * on clang, or "-fsanitize=alignment -fno-sanitize-recover=alignment" on gcc. + */ +#if __clang_major__ >= 7 || __GNUC__ >= 8 +#define pg_attribute_no_sanitize_alignment() __attribute__((no_sanitize("alignment"))) +#else +#define pg_attribute_no_sanitize_alignment() +#endif + +/* + * Append PG_USED_FOR_ASSERTS_ONLY to definitions of variables that are only + * used in assert-enabled builds, to avoid compiler warnings about unused + * variables in assert-disabled builds. + */ +#ifdef USE_ASSERT_CHECKING +#define PG_USED_FOR_ASSERTS_ONLY +#else +#define PG_USED_FOR_ASSERTS_ONLY pg_attribute_unused() +#endif + +/* GCC and XLC support format attributes */ +#if defined(__GNUC__) || defined(__IBMC__) +#define pg_attribute_format_arg(a) __attribute__((format_arg(a))) +#define pg_attribute_printf(f,a) __attribute__((format(PG_PRINTF_ATTRIBUTE, f, a))) +#else +#define pg_attribute_format_arg(a) +#define pg_attribute_printf(f,a) +#endif + +/* GCC, Sunpro and XLC support aligned, packed and noreturn */ +#if defined(__GNUC__) || defined(__SUNPRO_C) || defined(__IBMC__) +#define pg_attribute_aligned(a) __attribute__((aligned(a))) +#define pg_attribute_noreturn() __attribute__((noreturn)) +#define pg_attribute_packed() __attribute__((packed)) +#define HAVE_PG_ATTRIBUTE_NORETURN 1 +#else +/* + * NB: aligned and packed are not given default definitions because they + * affect code functionality; they *must* be implemented by the compiler + * if they are to be used. + */ +#define pg_attribute_noreturn() +#endif + +/* + * Use "pg_attribute_always_inline" in place of "inline" for functions that + * we wish to force inlining of, even when the compiler's heuristics would + * choose not to. But, if possible, don't force inlining in unoptimized + * debug builds. + */ +#if (defined(__GNUC__) && __GNUC__ > 3 && defined(__OPTIMIZE__)) || defined(__SUNPRO_C) || defined(__IBMC__) +/* GCC > 3, Sunpro and XLC support always_inline via __attribute__ */ +#define pg_attribute_always_inline __attribute__((always_inline)) inline +#elif defined(_MSC_VER) +/* MSVC has a special keyword for this */ +#define pg_attribute_always_inline __forceinline +#else +/* Otherwise, the best we can do is to say "inline" */ +#define pg_attribute_always_inline inline +#endif + +/* + * Forcing a function not to be inlined can be useful if it's the slow path of + * a performance-critical function, or should be visible in profiles to allow + * for proper cost attribution. Note that unlike the pg_attribute_XXX macros + * above, this should be placed before the function's return type and name. + */ +/* GCC, Sunpro and XLC support noinline via __attribute__ */ +#if (defined(__GNUC__) && __GNUC__ > 2) || defined(__SUNPRO_C) || defined(__IBMC__) +#define pg_noinline __attribute__((noinline)) +/* msvc via declspec */ +#elif defined(_MSC_VER) +#define pg_noinline __declspec(noinline) +#else +#define pg_noinline +#endif + +/* + * Mark a point as unreachable in a portable fashion. This should preferably + * be something that the compiler understands, to aid code generation. + * In assert-enabled builds, we prefer abort() for debugging reasons. + */ +#if defined(HAVE__BUILTIN_UNREACHABLE) && !defined(USE_ASSERT_CHECKING) +#define pg_unreachable() __builtin_unreachable() +#elif defined(_MSC_VER) && !defined(USE_ASSERT_CHECKING) +#define pg_unreachable() __assume(0) +#else +#define pg_unreachable() abort() +#endif + +/* + * Hints to the compiler about the likelihood of a branch. Both likely() and + * unlikely() return the boolean value of the contained expression. + * + * These should only be used sparingly, in very hot code paths. It's very easy + * to mis-estimate likelihoods. + */ +#if __GNUC__ >= 3 +#define likely(x) __builtin_expect((x) != 0, 1) +#define unlikely(x) __builtin_expect((x) != 0, 0) +#else +#define likely(x) ((x) != 0) +#define unlikely(x) ((x) != 0) +#endif + +/* + * CppAsString + * Convert the argument to a string, using the C preprocessor. + * CppAsString2 + * Convert the argument to a string, after one round of macro expansion. + * CppConcat + * Concatenate two arguments together, using the C preprocessor. + * + * Note: There used to be support here for pre-ANSI C compilers that didn't + * support # and ##. Nowadays, these macros are just for clarity and/or + * backward compatibility with existing PostgreSQL code. + */ +#define CppAsString(identifier) #identifier +#define CppAsString2(x) CppAsString(x) +#define CppConcat(x, y) x##y + +/* + * VA_ARGS_NARGS + * Returns the number of macro arguments it is passed. + * + * An empty argument still counts as an argument, so effectively, this is + * "one more than the number of commas in the argument list". + * + * This works for up to 63 arguments. Internally, VA_ARGS_NARGS_() is passed + * 64+N arguments, and the C99 standard only requires macros to allow up to + * 127 arguments, so we can't portably go higher. The implementation is + * pretty trivial: VA_ARGS_NARGS_() returns its 64th argument, and we set up + * the call so that that is the appropriate one of the list of constants. + * This idea is due to Laurent Deniau. + */ +#define VA_ARGS_NARGS(...) \ + VA_ARGS_NARGS_(__VA_ARGS__, \ + 63,62,61,60, \ + 59,58,57,56,55,54,53,52,51,50, \ + 49,48,47,46,45,44,43,42,41,40, \ + 39,38,37,36,35,34,33,32,31,30, \ + 29,28,27,26,25,24,23,22,21,20, \ + 19,18,17,16,15,14,13,12,11,10, \ + 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) +#define VA_ARGS_NARGS_( \ + _01,_02,_03,_04,_05,_06,_07,_08,_09,_10, \ + _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \ + _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \ + _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \ + _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \ + _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \ + _61,_62,_63, N, ...) \ + (N) + +/* + * dummyret is used to set return values in macros that use ?: to make + * assignments. gcc wants these to be void, other compilers like char + */ +#ifdef __GNUC__ /* GNU cc */ +#define dummyret void +#else +#define dummyret char +#endif + +/* + * We require C99, hence the compiler should understand flexible array + * members. However, for documentation purposes we still consider it to be + * project style to write "field[FLEXIBLE_ARRAY_MEMBER]" not just "field[]". + * When computing the size of such an object, use "offsetof(struct s, f)" + * for portability. Don't use "offsetof(struct s, f[0])", as this doesn't + * work with MSVC and with C++ compilers. + */ +#define FLEXIBLE_ARRAY_MEMBER /* empty */ + +/* Which __func__ symbol do we have, if any? */ +#ifdef HAVE_FUNCNAME__FUNC +#define PG_FUNCNAME_MACRO __func__ +#else +#ifdef HAVE_FUNCNAME__FUNCTION +#define PG_FUNCNAME_MACRO __FUNCTION__ +#else +#define PG_FUNCNAME_MACRO NULL +#endif +#endif + + +/* ---------------------------------------------------------------- + * Section 2: bool, true, false + * ---------------------------------------------------------------- + */ + +/* + * bool + * Boolean value, either true or false. + * + * We use stdbool.h if available and its bool has size 1. That's useful for + * better compiler and debugger output and for compatibility with third-party + * libraries. But PostgreSQL currently cannot deal with bool of other sizes; + * there are static assertions around the code to prevent that. + * + * For C++ compilers, we assume the compiler has a compatible built-in + * definition of bool. + * + * See also the version of this code in src/interfaces/ecpg/include/ecpglib.h. + */ + +#ifndef __cplusplus + +#ifdef PG_USE_STDBOOL +#include <stdbool.h> +#else + +#ifndef bool +typedef unsigned char bool; +#endif + +#ifndef true +#define true ((bool) 1) +#endif + +#ifndef false +#define false ((bool) 0) +#endif + +#endif /* not PG_USE_STDBOOL */ +#endif /* not C++ */ + + +/* ---------------------------------------------------------------- + * Section 3: standard system types + * ---------------------------------------------------------------- + */ + +/* + * Pointer + * Variable holding address of any memory resident object. + * + * XXX Pointer arithmetic is done with this, so it can't be void * + * under "true" ANSI compilers. + */ +typedef char *Pointer; + +/* + * intN + * Signed integer, EXACTLY N BITS IN SIZE, + * used for numerical computations and the + * frontend/backend protocol. + */ +#ifndef HAVE_INT8 +typedef signed char int8; /* == 8 bits */ +typedef signed short int16; /* == 16 bits */ +typedef signed int int32; /* == 32 bits */ +#endif /* not HAVE_INT8 */ + +/* + * uintN + * Unsigned integer, EXACTLY N BITS IN SIZE, + * used for numerical computations and the + * frontend/backend protocol. + */ +#ifndef HAVE_UINT8 +typedef unsigned char uint8; /* == 8 bits */ +typedef unsigned short uint16; /* == 16 bits */ +typedef unsigned int uint32; /* == 32 bits */ +#endif /* not HAVE_UINT8 */ + +/* + * bitsN + * Unit of bitwise operation, AT LEAST N BITS IN SIZE. + */ +typedef uint8 bits8; /* >= 8 bits */ +typedef uint16 bits16; /* >= 16 bits */ +typedef uint32 bits32; /* >= 32 bits */ + +/* + * 64-bit integers + */ +#ifdef HAVE_LONG_INT_64 +/* Plain "long int" fits, use it */ + +#ifndef HAVE_INT64 +typedef long int int64; +#endif +#ifndef HAVE_UINT64 +typedef unsigned long int uint64; +#endif +#define INT64CONST(x) (x##L) +#define UINT64CONST(x) (x##UL) +#elif defined(HAVE_LONG_LONG_INT_64) +/* We have working support for "long long int", use that */ + +#ifndef HAVE_INT64 +typedef long long int int64; +#endif +#ifndef HAVE_UINT64 +typedef unsigned long long int uint64; +#endif +#define INT64CONST(x) (x##LL) +#define UINT64CONST(x) (x##ULL) +#else +/* neither HAVE_LONG_INT_64 nor HAVE_LONG_LONG_INT_64 */ +#error must have a working 64-bit integer datatype +#endif + +/* snprintf format strings to use for 64-bit integers */ +#define INT64_FORMAT "%" INT64_MODIFIER "d" +#define UINT64_FORMAT "%" INT64_MODIFIER "u" + +/* + * 128-bit signed and unsigned integers + * There currently is only limited support for such types. + * E.g. 128bit literals and snprintf are not supported; but math is. + * Also, because we exclude such types when choosing MAXIMUM_ALIGNOF, + * it must be possible to coerce the compiler to allocate them on no + * more than MAXALIGN boundaries. + */ +#if defined(PG_INT128_TYPE) +#if defined(pg_attribute_aligned) || ALIGNOF_PG_INT128_TYPE <= MAXIMUM_ALIGNOF +#define HAVE_INT128 1 + +typedef PG_INT128_TYPE int128 +#if defined(pg_attribute_aligned) + pg_attribute_aligned(MAXIMUM_ALIGNOF) +#endif + ; + +typedef unsigned PG_INT128_TYPE uint128 +#if defined(pg_attribute_aligned) + pg_attribute_aligned(MAXIMUM_ALIGNOF) +#endif + ; + +#endif +#endif + +/* + * stdint.h limits aren't guaranteed to have compatible types with our fixed + * width types. So just define our own. + */ +#define PG_INT8_MIN (-0x7F-1) +#define PG_INT8_MAX (0x7F) +#define PG_UINT8_MAX (0xFF) +#define PG_INT16_MIN (-0x7FFF-1) +#define PG_INT16_MAX (0x7FFF) +#define PG_UINT16_MAX (0xFFFF) +#define PG_INT32_MIN (-0x7FFFFFFF-1) +#define PG_INT32_MAX (0x7FFFFFFF) +#define PG_UINT32_MAX (0xFFFFFFFFU) +#define PG_INT64_MIN (-INT64CONST(0x7FFFFFFFFFFFFFFF) - 1) +#define PG_INT64_MAX INT64CONST(0x7FFFFFFFFFFFFFFF) +#define PG_UINT64_MAX UINT64CONST(0xFFFFFFFFFFFFFFFF) + +/* + * We now always use int64 timestamps, but keep this symbol defined for the + * benefit of external code that might test it. + */ +#define HAVE_INT64_TIMESTAMP + +/* + * Size + * Size of any memory resident object, as returned by sizeof. + */ +typedef size_t Size; + +/* + * Index + * Index into any memory resident array. + * + * Note: + * Indices are non negative. + */ +typedef unsigned int Index; + +/* + * Offset + * Offset into any memory resident array. + * + * Note: + * This differs from an Index in that an Index is always + * non negative, whereas Offset may be negative. + */ +typedef signed int Offset; + +/* + * Common Postgres datatype names (as used in the catalogs) + */ +typedef float float4; +typedef double float8; + +#ifdef USE_FLOAT8_BYVAL +#define FLOAT8PASSBYVAL true +#else +#define FLOAT8PASSBYVAL false +#endif + +/* + * Oid, RegProcedure, TransactionId, SubTransactionId, MultiXactId, + * CommandId + */ + +/* typedef Oid is in postgres_ext.h */ + +/* + * regproc is the type name used in the include/catalog headers, but + * RegProcedure is the preferred name in C code. + */ +typedef Oid regproc; +typedef regproc RegProcedure; + +typedef uint32 TransactionId; + +typedef uint32 LocalTransactionId; + +typedef uint32 SubTransactionId; + +#define InvalidSubTransactionId ((SubTransactionId) 0) +#define TopSubTransactionId ((SubTransactionId) 1) + +/* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */ +typedef TransactionId MultiXactId; + +typedef uint32 MultiXactOffset; + +typedef uint32 CommandId; + +#define FirstCommandId ((CommandId) 0) +#define InvalidCommandId (~(CommandId)0) + +/* + * Array indexing support + */ +#define MAXDIM 6 +typedef struct +{ + int indx[MAXDIM]; +} IntArray; + +/* ---------------- + * Variable-length datatypes all share the 'struct varlena' header. + * + * NOTE: for TOASTable types, this is an oversimplification, since the value + * may be compressed or moved out-of-line. However datatype-specific routines + * are mostly content to deal with de-TOASTed values only, and of course + * client-side routines should never see a TOASTed value. But even in a + * de-TOASTed value, beware of touching vl_len_ directly, as its + * representation is no longer convenient. It's recommended that code always + * use macros VARDATA_ANY, VARSIZE_ANY, VARSIZE_ANY_EXHDR, VARDATA, VARSIZE, + * and SET_VARSIZE instead of relying on direct mentions of the struct fields. + * See postgres.h for details of the TOASTed form. + * ---------------- + */ +struct varlena +{ + char vl_len_[4]; /* Do not touch this field directly! */ + char vl_dat[FLEXIBLE_ARRAY_MEMBER]; /* Data content is here */ +}; + +#define VARHDRSZ ((int32) sizeof(int32)) + +/* + * These widely-used datatypes are just a varlena header and the data bytes. + * There is no terminating null or anything like that --- the data length is + * always VARSIZE_ANY_EXHDR(ptr). + */ +typedef struct varlena bytea; +typedef struct varlena text; +typedef struct varlena BpChar; /* blank-padded char, ie SQL char(n) */ +typedef struct varlena VarChar; /* var-length char, ie SQL varchar(n) */ + +/* + * Specialized array types. These are physically laid out just the same + * as regular arrays (so that the regular array subscripting code works + * with them). They exist as distinct types mostly for historical reasons: + * they have nonstandard I/O behavior which we don't want to change for fear + * of breaking applications that look at the system catalogs. There is also + * an implementation issue for oidvector: it's part of the primary key for + * pg_proc, and we can't use the normal btree array support routines for that + * without circularity. + */ +typedef struct +{ + int32 vl_len_; /* these fields must match ArrayType! */ + int ndim; /* always 1 for int2vector */ + int32 dataoffset; /* always 0 for int2vector */ + Oid elemtype; + int dim1; + int lbound1; + int16 values[FLEXIBLE_ARRAY_MEMBER]; +} int2vector; + +typedef struct +{ + int32 vl_len_; /* these fields must match ArrayType! */ + int ndim; /* always 1 for oidvector */ + int32 dataoffset; /* always 0 for oidvector */ + Oid elemtype; + int dim1; + int lbound1; + Oid values[FLEXIBLE_ARRAY_MEMBER]; +} oidvector; + +/* + * Representation of a Name: effectively just a C string, but null-padded to + * exactly NAMEDATALEN bytes. The use of a struct is historical. + */ +typedef struct nameData +{ + char data[NAMEDATALEN]; +} NameData; +typedef NameData *Name; + +#define NameStr(name) ((name).data) + + +/* ---------------------------------------------------------------- + * Section 4: IsValid macros for system types + * ---------------------------------------------------------------- + */ +/* + * BoolIsValid + * True iff bool is valid. + */ +#define BoolIsValid(boolean) ((boolean) == false || (boolean) == true) + +/* + * PointerIsValid + * True iff pointer is valid. + */ +#define PointerIsValid(pointer) ((const void*)(pointer) != NULL) + +/* + * PointerIsAligned + * True iff pointer is properly aligned to point to the given type. + */ +#define PointerIsAligned(pointer, type) \ + (((uintptr_t)(pointer) % (sizeof (type))) == 0) + +#define OffsetToPointer(base, offset) \ + ((void *)((char *) base + offset)) + +#define OidIsValid(objectId) ((bool) ((objectId) != InvalidOid)) + +#define RegProcedureIsValid(p) OidIsValid(p) + + +/* ---------------------------------------------------------------- + * Section 5: offsetof, lengthof, alignment + * ---------------------------------------------------------------- + */ +/* + * offsetof + * Offset of a structure/union field within that structure/union. + * + * XXX This is supposed to be part of stddef.h, but isn't on + * some systems (like SunOS 4). + */ +#ifndef offsetof +#define offsetof(type, field) ((long) &((type *)0)->field) +#endif /* offsetof */ + +/* + * lengthof + * Number of elements in an array. + */ +#define lengthof(array) (sizeof (array) / sizeof ((array)[0])) + +/* ---------------- + * Alignment macros: align a length or address appropriately for a given type. + * The fooALIGN() macros round up to a multiple of the required alignment, + * while the fooALIGN_DOWN() macros round down. The latter are more useful + * for problems like "how many X-sized structures will fit in a page?". + * + * NOTE: TYPEALIGN[_DOWN] will not work if ALIGNVAL is not a power of 2. + * That case seems extremely unlikely to be needed in practice, however. + * + * NOTE: MAXIMUM_ALIGNOF, and hence MAXALIGN(), intentionally exclude any + * larger-than-8-byte types the compiler might have. + * ---------------- + */ + +#define TYPEALIGN(ALIGNVAL,LEN) \ + (((uintptr_t) (LEN) + ((ALIGNVAL) - 1)) & ~((uintptr_t) ((ALIGNVAL) - 1))) + +#define SHORTALIGN(LEN) TYPEALIGN(ALIGNOF_SHORT, (LEN)) +#define INTALIGN(LEN) TYPEALIGN(ALIGNOF_INT, (LEN)) +#define LONGALIGN(LEN) TYPEALIGN(ALIGNOF_LONG, (LEN)) +#define DOUBLEALIGN(LEN) TYPEALIGN(ALIGNOF_DOUBLE, (LEN)) +#define MAXALIGN(LEN) TYPEALIGN(MAXIMUM_ALIGNOF, (LEN)) +/* MAXALIGN covers only built-in types, not buffers */ +#define BUFFERALIGN(LEN) TYPEALIGN(ALIGNOF_BUFFER, (LEN)) +#define CACHELINEALIGN(LEN) TYPEALIGN(PG_CACHE_LINE_SIZE, (LEN)) + +#define TYPEALIGN_DOWN(ALIGNVAL,LEN) \ + (((uintptr_t) (LEN)) & ~((uintptr_t) ((ALIGNVAL) - 1))) + +#define SHORTALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_SHORT, (LEN)) +#define INTALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_INT, (LEN)) +#define LONGALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_LONG, (LEN)) +#define DOUBLEALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_DOUBLE, (LEN)) +#define MAXALIGN_DOWN(LEN) TYPEALIGN_DOWN(MAXIMUM_ALIGNOF, (LEN)) +#define BUFFERALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_BUFFER, (LEN)) + +/* + * The above macros will not work with types wider than uintptr_t, like with + * uint64 on 32-bit platforms. That's not problem for the usual use where a + * pointer or a length is aligned, but for the odd case that you need to + * align something (potentially) wider, use TYPEALIGN64. + */ +#define TYPEALIGN64(ALIGNVAL,LEN) \ + (((uint64) (LEN) + ((ALIGNVAL) - 1)) & ~((uint64) ((ALIGNVAL) - 1))) + +/* we don't currently need wider versions of the other ALIGN macros */ +#define MAXALIGN64(LEN) TYPEALIGN64(MAXIMUM_ALIGNOF, (LEN)) + + +/* ---------------------------------------------------------------- + * Section 6: assertions + * ---------------------------------------------------------------- + */ + +/* + * USE_ASSERT_CHECKING, if defined, turns on all the assertions. + * - plai 9/5/90 + * + * It should _NOT_ be defined in releases or in benchmark copies + */ + +/* + * Assert() can be used in both frontend and backend code. In frontend code it + * just calls the standard assert, if it's available. If use of assertions is + * not configured, it does nothing. + */ +#ifndef USE_ASSERT_CHECKING + +#define Assert(condition) ((void)true) +#define AssertMacro(condition) ((void)true) +#define AssertArg(condition) ((void)true) +#define AssertState(condition) ((void)true) +#define AssertPointerAlignment(ptr, bndr) ((void)true) +#define Trap(condition, errorType) ((void)true) +#define TrapMacro(condition, errorType) (true) + +#elif defined(FRONTEND) + +#include <assert.h> +#define Assert(p) assert(p) +#define AssertMacro(p) ((void) assert(p)) +#define AssertArg(condition) assert(condition) +#define AssertState(condition) assert(condition) +#define AssertPointerAlignment(ptr, bndr) ((void)true) + +#else /* USE_ASSERT_CHECKING && !FRONTEND */ + +/* + * Trap + * Generates an exception if the given condition is true. + */ +#define Trap(condition, errorType) \ + do { \ + if (condition) \ + ExceptionalCondition(#condition, (errorType), \ + __FILE__, __LINE__); \ + } while (0) + +/* + * TrapMacro is the same as Trap but it's intended for use in macros: + * + * #define foo(x) (AssertMacro(x != 0), bar(x)) + * + * Isn't CPP fun? + */ +#define TrapMacro(condition, errorType) \ + ((bool) (! (condition) || \ + (ExceptionalCondition(#condition, (errorType), \ + __FILE__, __LINE__), 0))) + +#define Assert(condition) \ + do { \ + if (!(condition)) \ + ExceptionalCondition(#condition, "FailedAssertion", \ + __FILE__, __LINE__); \ + } while (0) + +#define AssertMacro(condition) \ + ((void) ((condition) || \ + (ExceptionalCondition(#condition, "FailedAssertion", \ + __FILE__, __LINE__), 0))) + +#define AssertArg(condition) \ + do { \ + if (!(condition)) \ + ExceptionalCondition(#condition, "BadArgument", \ + __FILE__, __LINE__); \ + } while (0) + +#define AssertState(condition) \ + do { \ + if (!(condition)) \ + ExceptionalCondition(#condition, "BadState", \ + __FILE__, __LINE__); \ + } while (0) + +/* + * Check that `ptr' is `bndr' aligned. + */ +#define AssertPointerAlignment(ptr, bndr) \ + Trap(TYPEALIGN(bndr, (uintptr_t)(ptr)) != (uintptr_t)(ptr), \ + "UnalignedPointer") + +#endif /* USE_ASSERT_CHECKING && !FRONTEND */ + +/* + * ExceptionalCondition is compiled into the backend whether or not + * USE_ASSERT_CHECKING is defined, so as to support use of extensions + * that are built with that #define with a backend that isn't. Hence, + * we should declare it as long as !FRONTEND. + */ +#ifndef FRONTEND +extern void ExceptionalCondition(const char *conditionName, + const char *errorType, + const char *fileName, int lineNumber) pg_attribute_noreturn(); +#endif + +/* + * Macros to support compile-time assertion checks. + * + * If the "condition" (a compile-time-constant expression) evaluates to false, + * throw a compile error using the "errmessage" (a string literal). + * + * gcc 4.6 and up supports _Static_assert(), but there are bizarre syntactic + * placement restrictions. Macros StaticAssertStmt() and StaticAssertExpr() + * make it safe to use as a statement or in an expression, respectively. + * The macro StaticAssertDecl() is suitable for use at file scope (outside of + * any function). + * + * Otherwise we fall back on a kluge that assumes the compiler will complain + * about a negative width for a struct bit-field. This will not include a + * helpful error message, but it beats not getting an error at all. + */ +#ifndef __cplusplus +#ifdef HAVE__STATIC_ASSERT +#define StaticAssertStmt(condition, errmessage) \ + do { _Static_assert(condition, errmessage); } while(0) +#define StaticAssertExpr(condition, errmessage) \ + ((void) ({ StaticAssertStmt(condition, errmessage); true; })) +#define StaticAssertDecl(condition, errmessage) \ + _Static_assert(condition, errmessage) +#else /* !HAVE__STATIC_ASSERT */ +#define StaticAssertStmt(condition, errmessage) \ + ((void) sizeof(struct { int static_assert_failure : (condition) ? 1 : -1; })) +#define StaticAssertExpr(condition, errmessage) \ + StaticAssertStmt(condition, errmessage) +#define StaticAssertDecl(condition, errmessage) \ + extern void static_assert_func(int static_assert_failure[(condition) ? 1 : -1]) +#endif /* HAVE__STATIC_ASSERT */ +#else /* C++ */ +#if defined(__cpp_static_assert) && __cpp_static_assert >= 200410 +#define StaticAssertStmt(condition, errmessage) \ + static_assert(condition, errmessage) +#define StaticAssertExpr(condition, errmessage) \ + ({ static_assert(condition, errmessage); }) +#define StaticAssertDecl(condition, errmessage) \ + static_assert(condition, errmessage) +#else /* !__cpp_static_assert */ +#define StaticAssertStmt(condition, errmessage) \ + do { struct static_assert_struct { int static_assert_failure : (condition) ? 1 : -1; }; } while(0) +#define StaticAssertExpr(condition, errmessage) \ + ((void) ({ StaticAssertStmt(condition, errmessage); })) +#define StaticAssertDecl(condition, errmessage) \ + extern void static_assert_func(int static_assert_failure[(condition) ? 1 : -1]) +#endif /* __cpp_static_assert */ +#endif /* C++ */ + + +/* + * Compile-time checks that a variable (or expression) has the specified type. + * + * AssertVariableIsOfType() can be used as a statement. + * AssertVariableIsOfTypeMacro() is intended for use in macros, eg + * #define foo(x) (AssertVariableIsOfTypeMacro(x, int), bar(x)) + * + * If we don't have __builtin_types_compatible_p, we can still assert that + * the types have the same size. This is far from ideal (especially on 32-bit + * platforms) but it provides at least some coverage. + */ +#ifdef HAVE__BUILTIN_TYPES_COMPATIBLE_P +#define AssertVariableIsOfType(varname, typename) \ + StaticAssertStmt(__builtin_types_compatible_p(__typeof__(varname), typename), \ + CppAsString(varname) " does not have type " CppAsString(typename)) +#define AssertVariableIsOfTypeMacro(varname, typename) \ + (StaticAssertExpr(__builtin_types_compatible_p(__typeof__(varname), typename), \ + CppAsString(varname) " does not have type " CppAsString(typename))) +#else /* !HAVE__BUILTIN_TYPES_COMPATIBLE_P */ +#define AssertVariableIsOfType(varname, typename) \ + StaticAssertStmt(sizeof(varname) == sizeof(typename), \ + CppAsString(varname) " does not have type " CppAsString(typename)) +#define AssertVariableIsOfTypeMacro(varname, typename) \ + (StaticAssertExpr(sizeof(varname) == sizeof(typename), \ + CppAsString(varname) " does not have type " CppAsString(typename))) +#endif /* HAVE__BUILTIN_TYPES_COMPATIBLE_P */ + + +/* ---------------------------------------------------------------- + * Section 7: widely useful macros + * ---------------------------------------------------------------- + */ +/* + * Max + * Return the maximum of two numbers. + */ +#define Max(x, y) ((x) > (y) ? (x) : (y)) + +/* + * Min + * Return the minimum of two numbers. + */ +#define Min(x, y) ((x) < (y) ? (x) : (y)) + +/* + * Abs + * Return the absolute value of the argument. + */ +#define Abs(x) ((x) >= 0 ? (x) : -(x)) + +/* + * StrNCpy + * Like standard library function strncpy(), except that result string + * is guaranteed to be null-terminated --- that is, at most N-1 bytes + * of the source string will be kept. + * Also, the macro returns no result (too hard to do that without + * evaluating the arguments multiple times, which seems worse). + * + * BTW: when you need to copy a non-null-terminated string (like a text + * datum) and add a null, do not do it with StrNCpy(..., len+1). That + * might seem to work, but it fetches one byte more than there is in the + * text object. One fine day you'll have a SIGSEGV because there isn't + * another byte before the end of memory. Don't laugh, we've had real + * live bug reports from real live users over exactly this mistake. + * Do it honestly with "memcpy(dst,src,len); dst[len] = '\0';", instead. + */ +#define StrNCpy(dst,src,len) \ + do \ + { \ + char * _dst = (dst); \ + Size _len = (len); \ +\ + if (_len > 0) \ + { \ + strncpy(_dst, (src), _len); \ + _dst[_len-1] = '\0'; \ + } \ + } while (0) + + +/* Get a bit mask of the bits set in non-long aligned addresses */ +#define LONG_ALIGN_MASK (sizeof(long) - 1) + +/* + * MemSet + * Exactly the same as standard library function memset(), but considerably + * faster for zeroing small word-aligned structures (such as parsetree nodes). + * This has to be a macro because the main point is to avoid function-call + * overhead. However, we have also found that the loop is faster than + * native libc memset() on some platforms, even those with assembler + * memset() functions. More research needs to be done, perhaps with + * MEMSET_LOOP_LIMIT tests in configure. + */ +#define MemSet(start, val, len) \ + do \ + { \ + /* must be void* because we don't know if it is integer aligned yet */ \ + void *_vstart = (void *) (start); \ + int _val = (val); \ + Size _len = (len); \ +\ + if ((((uintptr_t) _vstart) & LONG_ALIGN_MASK) == 0 && \ + (_len & LONG_ALIGN_MASK) == 0 && \ + _val == 0 && \ + _len <= MEMSET_LOOP_LIMIT && \ + /* \ + * If MEMSET_LOOP_LIMIT == 0, optimizer should find \ + * the whole "if" false at compile time. \ + */ \ + MEMSET_LOOP_LIMIT != 0) \ + { \ + long *_start = (long *) _vstart; \ + long *_stop = (long *) ((char *) _start + _len); \ + while (_start < _stop) \ + *_start++ = 0; \ + } \ + else \ + memset(_vstart, _val, _len); \ + } while (0) + +/* + * MemSetAligned is the same as MemSet except it omits the test to see if + * "start" is word-aligned. This is okay to use if the caller knows a-priori + * that the pointer is suitably aligned (typically, because he just got it + * from palloc(), which always delivers a max-aligned pointer). + */ +#define MemSetAligned(start, val, len) \ + do \ + { \ + long *_start = (long *) (start); \ + int _val = (val); \ + Size _len = (len); \ +\ + if ((_len & LONG_ALIGN_MASK) == 0 && \ + _val == 0 && \ + _len <= MEMSET_LOOP_LIMIT && \ + MEMSET_LOOP_LIMIT != 0) \ + { \ + long *_stop = (long *) ((char *) _start + _len); \ + while (_start < _stop) \ + *_start++ = 0; \ + } \ + else \ + memset(_start, _val, _len); \ + } while (0) + + +/* + * MemSetTest/MemSetLoop are a variant version that allow all the tests in + * MemSet to be done at compile time in cases where "val" and "len" are + * constants *and* we know the "start" pointer must be word-aligned. + * If MemSetTest succeeds, then it is okay to use MemSetLoop, otherwise use + * MemSetAligned. Beware of multiple evaluations of the arguments when using + * this approach. + */ +#define MemSetTest(val, len) \ + ( ((len) & LONG_ALIGN_MASK) == 0 && \ + (len) <= MEMSET_LOOP_LIMIT && \ + MEMSET_LOOP_LIMIT != 0 && \ + (val) == 0 ) + +#define MemSetLoop(start, val, len) \ + do \ + { \ + long * _start = (long *) (start); \ + long * _stop = (long *) ((char *) _start + (Size) (len)); \ + \ + while (_start < _stop) \ + *_start++ = 0; \ + } while (0) + +/* + * Macros for range-checking float values before converting to integer. + * We must be careful here that the boundary values are expressed exactly + * in the float domain. PG_INTnn_MIN is an exact power of 2, so it will + * be represented exactly; but PG_INTnn_MAX isn't, and might get rounded + * off, so avoid using that. + * The input must be rounded to an integer beforehand, typically with rint(), + * else we might draw the wrong conclusion about close-to-the-limit values. + * These macros will do the right thing for Inf, but not necessarily for NaN, + * so check isnan(num) first if that's a possibility. + */ +#define FLOAT4_FITS_IN_INT16(num) \ + ((num) >= (float4) PG_INT16_MIN && (num) < -((float4) PG_INT16_MIN)) +#define FLOAT4_FITS_IN_INT32(num) \ + ((num) >= (float4) PG_INT32_MIN && (num) < -((float4) PG_INT32_MIN)) +#define FLOAT4_FITS_IN_INT64(num) \ + ((num) >= (float4) PG_INT64_MIN && (num) < -((float4) PG_INT64_MIN)) +#define FLOAT8_FITS_IN_INT16(num) \ + ((num) >= (float8) PG_INT16_MIN && (num) < -((float8) PG_INT16_MIN)) +#define FLOAT8_FITS_IN_INT32(num) \ + ((num) >= (float8) PG_INT32_MIN && (num) < -((float8) PG_INT32_MIN)) +#define FLOAT8_FITS_IN_INT64(num) \ + ((num) >= (float8) PG_INT64_MIN && (num) < -((float8) PG_INT64_MIN)) + + +/* ---------------------------------------------------------------- + * Section 8: random stuff + * ---------------------------------------------------------------- + */ + +#ifdef HAVE_STRUCT_SOCKADDR_UN +#define HAVE_UNIX_SOCKETS 1 +#endif + +/* + * Invert the sign of a qsort-style comparison result, ie, exchange negative + * and positive integer values, being careful not to get the wrong answer + * for INT_MIN. The argument should be an integral variable. + */ +#define INVERT_COMPARE_RESULT(var) \ + ((var) = ((var) < 0) ? 1 : -(var)) + +/* + * Use this, not "char buf[BLCKSZ]", to declare a field or local variable + * holding a page buffer, if that page might be accessed as a page and not + * just a string of bytes. Otherwise the variable might be under-aligned, + * causing problems on alignment-picky hardware. (In some places, we use + * this to declare buffers even though we only pass them to read() and + * write(), because copying to/from aligned buffers is usually faster than + * using unaligned buffers.) We include both "double" and "int64" in the + * union to ensure that the compiler knows the value must be MAXALIGN'ed + * (cf. configure's computation of MAXIMUM_ALIGNOF). + */ +typedef union PGAlignedBlock +{ + char data[BLCKSZ]; + double force_align_d; + int64 force_align_i64; +} PGAlignedBlock; + +/* Same, but for an XLOG_BLCKSZ-sized buffer */ +typedef union PGAlignedXLogBlock +{ + char data[XLOG_BLCKSZ]; + double force_align_d; + int64 force_align_i64; +} PGAlignedXLogBlock; + +/* msb for char */ +#define HIGHBIT (0x80) +#define IS_HIGHBIT_SET(ch) ((unsigned char)(ch) & HIGHBIT) + +/* + * Support macros for escaping strings. escape_backslash should be true + * if generating a non-standard-conforming string. Prefixing a string + * with ESCAPE_STRING_SYNTAX guarantees it is non-standard-conforming. + * Beware of multiple evaluation of the "ch" argument! + */ +#define SQL_STR_DOUBLE(ch, escape_backslash) \ + ((ch) == '\'' || ((ch) == '\\' && (escape_backslash))) + +#define ESCAPE_STRING_SYNTAX 'E' + + +#define STATUS_OK (0) +#define STATUS_ERROR (-1) +#define STATUS_EOF (-2) +#define STATUS_WAITING (2) + +/* + * gettext support + */ + +#ifndef ENABLE_NLS +/* stuff we'd otherwise get from <libintl.h> */ +#define gettext(x) (x) +#define dgettext(d,x) (x) +#define ngettext(s,p,n) ((n) == 1 ? (s) : (p)) +#define dngettext(d,s,p,n) ((n) == 1 ? (s) : (p)) +#endif + +#define _(x) gettext(x) + +/* + * Use this to mark string constants as needing translation at some later + * time, rather than immediately. This is useful for cases where you need + * access to the original string and translated string, and for cases where + * immediate translation is not possible, like when initializing global + * variables. + * http://www.gnu.org/software/autoconf/manual/gettext/Special-cases.html + */ +#define gettext_noop(x) (x) + +/* + * To better support parallel installations of major PostgreSQL + * versions as well as parallel installations of major library soname + * versions, we mangle the gettext domain name by appending those + * version numbers. The coding rule ought to be that wherever the + * domain name is mentioned as a literal, it must be wrapped into + * PG_TEXTDOMAIN(). The macros below do not work on non-literals; but + * that is somewhat intentional because it avoids having to worry + * about multiple states of premangling and postmangling as the values + * are being passed around. + * + * Make sure this matches the installation rules in nls-global.mk. + */ +#ifdef SO_MAJOR_VERSION +#define PG_TEXTDOMAIN(domain) (domain CppAsString2(SO_MAJOR_VERSION) "-" PG_MAJORVERSION) +#else +#define PG_TEXTDOMAIN(domain) (domain "-" PG_MAJORVERSION) +#endif + +/* + * Macro that allows to cast constness and volatile away from an expression, but doesn't + * allow changing the underlying type. Enforcement of the latter + * currently only works for gcc like compilers. + * + * Please note IT IS NOT SAFE to cast constness away if the result will ever + * be modified (it would be undefined behaviour). Doing so anyway can cause + * compiler misoptimizations or runtime crashes (modifying readonly memory). + * It is only safe to use when the result will not be modified, but API + * design or language restrictions prevent you from declaring that + * (e.g. because a function returns both const and non-const variables). + * + * Note that this only works in function scope, not for global variables (it'd + * be nice, but not trivial, to improve that). + */ +#if defined(HAVE__BUILTIN_TYPES_COMPATIBLE_P) +#define unconstify(underlying_type, expr) \ + (StaticAssertExpr(__builtin_types_compatible_p(__typeof(expr), const underlying_type), \ + "wrong cast"), \ + (underlying_type) (expr)) +#define unvolatize(underlying_type, expr) \ + (StaticAssertExpr(__builtin_types_compatible_p(__typeof(expr), volatile underlying_type), \ + "wrong cast"), \ + (underlying_type) (expr)) +#else +#define unconstify(underlying_type, expr) \ + ((underlying_type) (expr)) +#define unvolatize(underlying_type, expr) \ + ((underlying_type) (expr)) +#endif + +/* ---------------------------------------------------------------- + * Section 9: system-specific hacks + * + * This should be limited to things that absolutely have to be + * included in every source file. The port-specific header file + * is usually a better place for this sort of thing. + * ---------------------------------------------------------------- + */ + +/* + * NOTE: this is also used for opening text files. + * WIN32 treats Control-Z as EOF in files opened in text mode. + * Therefore, we open files in binary mode on Win32 so we can read + * literal control-Z. The other affect is that we see CRLF, but + * that is OK because we can already handle those cleanly. + */ +#if defined(WIN32) || defined(__CYGWIN__) +#define PG_BINARY O_BINARY +#define PG_BINARY_A "ab" +#define PG_BINARY_R "rb" +#define PG_BINARY_W "wb" +#else +#define PG_BINARY 0 +#define PG_BINARY_A "a" +#define PG_BINARY_R "r" +#define PG_BINARY_W "w" +#endif + +/* + * Provide prototypes for routines not present in a particular machine's + * standard C library. + */ + +#if defined(HAVE_FDATASYNC) && !HAVE_DECL_FDATASYNC +extern int fdatasync(int fildes); +#endif + +/* Older platforms may provide strto[u]ll functionality under other names */ +#if !defined(HAVE_STRTOLL) && defined(HAVE___STRTOLL) +#define strtoll __strtoll +#define HAVE_STRTOLL 1 +#endif + +#if !defined(HAVE_STRTOLL) && defined(HAVE_STRTOQ) +#define strtoll strtoq +#define HAVE_STRTOLL 1 +#endif + +#if !defined(HAVE_STRTOULL) && defined(HAVE___STRTOULL) +#define strtoull __strtoull +#define HAVE_STRTOULL 1 +#endif + +#if !defined(HAVE_STRTOULL) && defined(HAVE_STRTOUQ) +#define strtoull strtouq +#define HAVE_STRTOULL 1 +#endif + +#if defined(HAVE_STRTOLL) && !HAVE_DECL_STRTOLL +extern long long strtoll(const char *str, char **endptr, int base); +#endif + +#if defined(HAVE_STRTOULL) && !HAVE_DECL_STRTOULL +extern unsigned long long strtoull(const char *str, char **endptr, int base); +#endif + +#define PGDLLIMPORT +#define PGDLLEXPORT + +/* + * The following is used as the arg list for signal handlers. Any ports + * that take something other than an int argument should override this in + * their pg_config_os.h file. Note that variable names are required + * because it is used in both the prototypes as well as the definitions. + * Note also the long name. We expect that this won't collide with + * other names causing compiler warnings. + */ + +#ifndef SIGNAL_ARGS +#define SIGNAL_ARGS int postgres_signal_arg +#endif + +/* + * When there is no sigsetjmp, its functionality is provided by plain + * setjmp. Incidentally, nothing provides setjmp's functionality in + * that case. We now support the case only on Windows. + */ +#ifdef WIN32 +#define sigjmp_buf jmp_buf +#define sigsetjmp(x,y) setjmp(x) +#define siglongjmp longjmp +#endif + +/* EXEC_BACKEND defines */ +#ifdef EXEC_BACKEND +#define NON_EXEC_STATIC +#else +#define NON_EXEC_STATIC static +#endif + +/* /port compatibility functions */ +#include "port.h" + +#endif /* C_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/binary_upgrade.h b/contrib/libs/postgresql/src/include/catalog/binary_upgrade.h new file mode 100644 index 0000000000..12d94fe1b3 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/binary_upgrade.h @@ -0,0 +1,30 @@ +/*------------------------------------------------------------------------- + * + * binary_upgrade.h + * variables used for binary upgrades + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/binary_upgrade.h + * + *------------------------------------------------------------------------- + */ +#ifndef BINARY_UPGRADE_H +#define BINARY_UPGRADE_H + +extern PGDLLIMPORT Oid binary_upgrade_next_pg_type_oid; +extern PGDLLIMPORT Oid binary_upgrade_next_array_pg_type_oid; +extern PGDLLIMPORT Oid binary_upgrade_next_toast_pg_type_oid; + +extern PGDLLIMPORT Oid binary_upgrade_next_heap_pg_class_oid; +extern PGDLLIMPORT Oid binary_upgrade_next_index_pg_class_oid; +extern PGDLLIMPORT Oid binary_upgrade_next_toast_pg_class_oid; + +extern PGDLLIMPORT Oid binary_upgrade_next_pg_enum_oid; +extern PGDLLIMPORT Oid binary_upgrade_next_pg_authid_oid; + +extern PGDLLIMPORT bool binary_upgrade_record_init_privs; + +#endif /* BINARY_UPGRADE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/catalog.h b/contrib/libs/postgresql/src/include/catalog/catalog.h new file mode 100644 index 0000000000..7824a123c2 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/catalog.h @@ -0,0 +1,42 @@ +/*------------------------------------------------------------------------- + * + * catalog.h + * prototypes for functions in backend/catalog/catalog.c + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/catalog.h + * + *------------------------------------------------------------------------- + */ +#ifndef CATALOG_H +#define CATALOG_H + +#include "catalog/pg_class.h" +#include "utils/relcache.h" + + +extern bool IsSystemRelation(Relation relation); +extern bool IsToastRelation(Relation relation); +extern bool IsCatalogRelation(Relation relation); + +extern bool IsSystemClass(Oid relid, Form_pg_class reltuple); +extern bool IsToastClass(Form_pg_class reltuple); + +extern bool IsCatalogRelationOid(Oid relid); + +extern bool IsCatalogNamespace(Oid namespaceId); +extern bool IsToastNamespace(Oid namespaceId); + +extern bool IsReservedName(const char *name); + +extern bool IsSharedRelation(Oid relationId); + +extern Oid GetNewOidWithIndex(Relation relation, Oid indexId, + AttrNumber oidcolumn); +extern Oid GetNewRelFileNode(Oid reltablespace, Relation pg_class, + char relpersistence); + +#endif /* CATALOG_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/catversion.h b/contrib/libs/postgresql/src/include/catalog/catversion.h new file mode 100644 index 0000000000..282019c49d --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/catversion.h @@ -0,0 +1,58 @@ +/*------------------------------------------------------------------------- + * + * catversion.h + * "Catalog version number" for PostgreSQL. + * + * The catalog version number is used to flag incompatible changes in + * the PostgreSQL system catalogs. Whenever anyone changes the format of + * a system catalog relation, or adds, deletes, or modifies standard + * catalog entries in such a way that an updated backend wouldn't work + * with an old database (or vice versa), the catalog version number + * should be changed. The version number stored in pg_control by initdb + * is checked against the version number compiled into the backend at + * startup time, so that a backend can refuse to run in an incompatible + * database. + * + * The point of this feature is to provide a finer grain of compatibility + * checking than is possible from looking at the major version number + * stored in PG_VERSION. It shouldn't matter to end users, but during + * development cycles we usually make quite a few incompatible changes + * to the contents of the system catalogs, and we don't want to bump the + * major version number for each one. What we can do instead is bump + * this internal version number. This should save some grief for + * developers who might otherwise waste time tracking down "bugs" that + * are really just code-vs-database incompatibilities. + * + * The rule for developers is: if you commit a change that requires + * an initdb, you should update the catalog version number (as well as + * notifying the pgsql-hackers mailing list, which has been the + * informal practice for a long time). + * + * The catalog version number is placed here since modifying files in + * include/catalog is the most common kind of initdb-forcing change. + * But it could be used to protect any kind of incompatible change in + * database contents or layout, such as altering tuple headers. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/catversion.h + * + *------------------------------------------------------------------------- + */ +#ifndef CATVERSION_H +#define CATVERSION_H + +/* + * We could use anything we wanted for version numbers, but I recommend + * following the "YYYYMMDDN" style often used for DNS zone serial numbers. + * YYYYMMDD are the date of the change, and N is the number of the change + * on that day. (Hopefully we'll never commit ten independent sets of + * catalog changes on the same day...) + */ + +/* yyyymmddN */ +#define CATALOG_VERSION_NO 202007201 + +#endif diff --git a/contrib/libs/postgresql/src/include/catalog/dependency.h b/contrib/libs/postgresql/src/include/catalog/dependency.h new file mode 100644 index 0000000000..7fe3fb7e7c --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/dependency.h @@ -0,0 +1,275 @@ +/*------------------------------------------------------------------------- + * + * dependency.h + * Routines to support inter-object dependencies. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/dependency.h + * + *------------------------------------------------------------------------- + */ +#ifndef DEPENDENCY_H +#define DEPENDENCY_H + +#include "catalog/objectaddress.h" + + +/* + * Precise semantics of a dependency relationship are specified by the + * DependencyType code (which is stored in a "char" field in pg_depend, + * so we assign ASCII-code values to the enumeration members). + * + * In all cases, a dependency relationship indicates that the referenced + * object may not be dropped without also dropping the dependent object. + * However, there are several subflavors; see the description of pg_depend + * in catalogs.sgml for details. + */ + +typedef enum DependencyType +{ + DEPENDENCY_NORMAL = 'n', + DEPENDENCY_AUTO = 'a', + DEPENDENCY_INTERNAL = 'i', + DEPENDENCY_PARTITION_PRI = 'P', + DEPENDENCY_PARTITION_SEC = 'S', + DEPENDENCY_EXTENSION = 'e', + DEPENDENCY_AUTO_EXTENSION = 'x', + DEPENDENCY_PIN = 'p' +} DependencyType; + +/* + * There is also a SharedDependencyType enum type that determines the exact + * semantics of an entry in pg_shdepend. Just like regular dependency entries, + * any pg_shdepend entry means that the referenced object cannot be dropped + * unless the dependent object is dropped at the same time. There are some + * additional rules however: + * + * (a) For a SHARED_DEPENDENCY_PIN entry, there is no dependent object -- + * rather, the referenced object is an essential part of the system. This + * applies to the initdb-created superuser. Entries of this type are only + * created by initdb; objects in this category don't need further pg_shdepend + * entries if more objects come to depend on them. + * + * (b) a SHARED_DEPENDENCY_OWNER entry means that the referenced object is + * the role owning the dependent object. The referenced object must be + * a pg_authid entry. + * + * (c) a SHARED_DEPENDENCY_ACL entry means that the referenced object is + * a role mentioned in the ACL field of the dependent object. The referenced + * object must be a pg_authid entry. (SHARED_DEPENDENCY_ACL entries are not + * created for the owner of an object; hence two objects may be linked by + * one or the other, but not both, of these dependency types.) + * + * (d) a SHARED_DEPENDENCY_POLICY entry means that the referenced object is + * a role mentioned in a policy object. The referenced object must be a + * pg_authid entry. + * + * (e) a SHARED_DEPENDENCY_TABLESPACE entry means that the referenced + * object is a tablespace mentioned in a relation without storage. The + * referenced object must be a pg_tablespace entry. (Relations that have + * storage don't need this: they are protected by the existence of a physical + * file in the tablespace.) + * + * SHARED_DEPENDENCY_INVALID is a value used as a parameter in internal + * routines, and is not valid in the catalog itself. + */ +typedef enum SharedDependencyType +{ + SHARED_DEPENDENCY_PIN = 'p', + SHARED_DEPENDENCY_OWNER = 'o', + SHARED_DEPENDENCY_ACL = 'a', + SHARED_DEPENDENCY_POLICY = 'r', + SHARED_DEPENDENCY_TABLESPACE = 't', + SHARED_DEPENDENCY_INVALID = 0 +} SharedDependencyType; + +/* expansible list of ObjectAddresses (private in dependency.c) */ +typedef struct ObjectAddresses ObjectAddresses; + +/* + * This enum covers all system catalogs whose OIDs can appear in + * pg_depend.classId or pg_shdepend.classId. Keep object_classes[] in sync. + */ +typedef enum ObjectClass +{ + OCLASS_CLASS, /* pg_class */ + OCLASS_PROC, /* pg_proc */ + OCLASS_TYPE, /* pg_type */ + OCLASS_CAST, /* pg_cast */ + OCLASS_COLLATION, /* pg_collation */ + OCLASS_CONSTRAINT, /* pg_constraint */ + OCLASS_CONVERSION, /* pg_conversion */ + OCLASS_DEFAULT, /* pg_attrdef */ + OCLASS_LANGUAGE, /* pg_language */ + OCLASS_LARGEOBJECT, /* pg_largeobject */ + OCLASS_OPERATOR, /* pg_operator */ + OCLASS_OPCLASS, /* pg_opclass */ + OCLASS_OPFAMILY, /* pg_opfamily */ + OCLASS_AM, /* pg_am */ + OCLASS_AMOP, /* pg_amop */ + OCLASS_AMPROC, /* pg_amproc */ + OCLASS_REWRITE, /* pg_rewrite */ + OCLASS_TRIGGER, /* pg_trigger */ + OCLASS_SCHEMA, /* pg_namespace */ + OCLASS_STATISTIC_EXT, /* pg_statistic_ext */ + OCLASS_TSPARSER, /* pg_ts_parser */ + OCLASS_TSDICT, /* pg_ts_dict */ + OCLASS_TSTEMPLATE, /* pg_ts_template */ + OCLASS_TSCONFIG, /* pg_ts_config */ + OCLASS_ROLE, /* pg_authid */ + OCLASS_DATABASE, /* pg_database */ + OCLASS_TBLSPACE, /* pg_tablespace */ + OCLASS_FDW, /* pg_foreign_data_wrapper */ + OCLASS_FOREIGN_SERVER, /* pg_foreign_server */ + OCLASS_USER_MAPPING, /* pg_user_mapping */ + OCLASS_DEFACL, /* pg_default_acl */ + OCLASS_EXTENSION, /* pg_extension */ + OCLASS_EVENT_TRIGGER, /* pg_event_trigger */ + OCLASS_POLICY, /* pg_policy */ + OCLASS_PUBLICATION, /* pg_publication */ + OCLASS_PUBLICATION_REL, /* pg_publication_rel */ + OCLASS_SUBSCRIPTION, /* pg_subscription */ + OCLASS_TRANSFORM /* pg_transform */ +} ObjectClass; + +#define LAST_OCLASS OCLASS_TRANSFORM + +/* flag bits for performDeletion/performMultipleDeletions: */ +#define PERFORM_DELETION_INTERNAL 0x0001 /* internal action */ +#define PERFORM_DELETION_CONCURRENTLY 0x0002 /* concurrent drop */ +#define PERFORM_DELETION_QUIETLY 0x0004 /* suppress notices */ +#define PERFORM_DELETION_SKIP_ORIGINAL 0x0008 /* keep original obj */ +#define PERFORM_DELETION_SKIP_EXTENSIONS 0x0010 /* keep extensions */ +#define PERFORM_DELETION_CONCURRENT_LOCK 0x0020 /* normal drop with + * concurrent lock mode */ + + +/* in dependency.c */ + +extern void AcquireDeletionLock(const ObjectAddress *object, int flags); + +extern void ReleaseDeletionLock(const ObjectAddress *object); + +extern void performDeletion(const ObjectAddress *object, + DropBehavior behavior, int flags); + +extern void performMultipleDeletions(const ObjectAddresses *objects, + DropBehavior behavior, int flags); + +extern void recordDependencyOnExpr(const ObjectAddress *depender, + Node *expr, List *rtable, + DependencyType behavior); + +extern void recordDependencyOnSingleRelExpr(const ObjectAddress *depender, + Node *expr, Oid relId, + DependencyType behavior, + DependencyType self_behavior, + bool reverse_self); + +extern ObjectClass getObjectClass(const ObjectAddress *object); + +extern ObjectAddresses *new_object_addresses(void); + +extern void add_exact_object_address(const ObjectAddress *object, + ObjectAddresses *addrs); + +extern bool object_address_present(const ObjectAddress *object, + const ObjectAddresses *addrs); + +extern void record_object_address_dependencies(const ObjectAddress *depender, + ObjectAddresses *referenced, + DependencyType behavior); + +extern void sort_object_addresses(ObjectAddresses *addrs); + +extern void free_object_addresses(ObjectAddresses *addrs); + +/* in pg_depend.c */ + +extern void recordDependencyOn(const ObjectAddress *depender, + const ObjectAddress *referenced, + DependencyType behavior); + +extern void recordMultipleDependencies(const ObjectAddress *depender, + const ObjectAddress *referenced, + int nreferenced, + DependencyType behavior); + +extern void recordDependencyOnCurrentExtension(const ObjectAddress *object, + bool isReplace); + +extern long deleteDependencyRecordsFor(Oid classId, Oid objectId, + bool skipExtensionDeps); + +extern long deleteDependencyRecordsForClass(Oid classId, Oid objectId, + Oid refclassId, char deptype); + +extern long deleteDependencyRecordsForSpecific(Oid classId, Oid objectId, + char deptype, + Oid refclassId, Oid refobjectId); + +extern long changeDependencyFor(Oid classId, Oid objectId, + Oid refClassId, Oid oldRefObjectId, + Oid newRefObjectId); + +extern long changeDependenciesOf(Oid classId, Oid oldObjectId, + Oid newObjectId); + +extern long changeDependenciesOn(Oid refClassId, Oid oldRefObjectId, + Oid newRefObjectId); + +extern Oid getExtensionOfObject(Oid classId, Oid objectId); +extern List *getAutoExtensionsOfObject(Oid classId, Oid objectId); + +extern bool sequenceIsOwned(Oid seqId, char deptype, Oid *tableId, int32 *colId); +extern List *getOwnedSequences(Oid relid); +extern Oid getIdentitySequence(Oid relid, AttrNumber attnum, bool missing_ok); + +extern Oid get_constraint_index(Oid constraintId); + +extern Oid get_index_constraint(Oid indexId); + +extern List *get_index_ref_constraints(Oid indexId); + +/* in pg_shdepend.c */ + +extern void recordSharedDependencyOn(ObjectAddress *depender, + ObjectAddress *referenced, + SharedDependencyType deptype); + +extern void deleteSharedDependencyRecordsFor(Oid classId, Oid objectId, + int32 objectSubId); + +extern void recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner); + +extern void changeDependencyOnOwner(Oid classId, Oid objectId, + Oid newOwnerId); + +extern void recordDependencyOnTablespace(Oid classId, Oid objectId, + Oid tablespace); + +extern void changeDependencyOnTablespace(Oid classId, Oid objectId, + Oid newTablespaceId); + +extern void updateAclDependencies(Oid classId, Oid objectId, int32 objectSubId, + Oid ownerId, + int noldmembers, Oid *oldmembers, + int nnewmembers, Oid *newmembers); + +extern bool checkSharedDependencies(Oid classId, Oid objectId, + char **detail_msg, char **detail_log_msg); + +extern void shdepLockAndCheckObject(Oid classId, Oid objectId); + +extern void copyTemplateDependencies(Oid templateDbId, Oid newDbId); + +extern void dropDatabaseDependencies(Oid databaseId); + +extern void shdepDropOwned(List *relids, DropBehavior behavior); + +extern void shdepReassignOwned(List *relids, Oid newrole); + +#endif /* DEPENDENCY_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/genbki.h b/contrib/libs/postgresql/src/include/catalog/genbki.h new file mode 100644 index 0000000000..4a6c8636da --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/genbki.h @@ -0,0 +1,64 @@ +/*------------------------------------------------------------------------- + * + * genbki.h + * Required include file for all POSTGRES catalog header files + * + * genbki.h defines CATALOG(), BKI_BOOTSTRAP and related macros + * so that the catalog header files can be read by the C compiler. + * (These same words are recognized by genbki.pl to build the BKI + * bootstrap file from these header files.) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/genbki.h + * + *------------------------------------------------------------------------- + */ +#ifndef GENBKI_H +#define GENBKI_H + +/* Introduces a catalog's structure definition */ +#define CATALOG(name,oid,oidmacro) typedef struct CppConcat(FormData_,name) + +/* Options that may appear after CATALOG (on the same line) */ +#define BKI_BOOTSTRAP +#define BKI_SHARED_RELATION +#define BKI_ROWTYPE_OID(oid,oidmacro) +#define BKI_SCHEMA_MACRO + +/* Options that may appear after an attribute (on the same line) */ +#define BKI_FORCE_NULL +#define BKI_FORCE_NOT_NULL +/* Specifies a default value for a catalog field */ +#define BKI_DEFAULT(value) +/* Specifies a default value for auto-generated array types */ +#define BKI_ARRAY_DEFAULT(value) +/* + * Indicates how to perform name lookups, typically for an OID or + * OID-array field + */ +#define BKI_LOOKUP(catalog) + +/* The following are never defined; they are here only for documentation. */ + +/* + * Variable-length catalog fields (except possibly the first not nullable one) + * should not be visible in C structures, so they are made invisible by #ifdefs + * of an undefined symbol. See also MARKNOTNULL in bootstrap.c for how this is + * handled. + */ +#undef CATALOG_VARLEN + +/* + * There is code in some catalog headers that needs to be visible to clients, + * but we don't want clients to include the full header because of safety + * issues with other code in the header. To handle that, surround code that + * should be visible to clients with "#ifdef EXPOSE_TO_CLIENT_CODE". That + * instructs genbki.pl to copy the section when generating the corresponding + * "_d" header, which can be included by both client and backend code. + */ +#undef EXPOSE_TO_CLIENT_CODE + +#endif /* GENBKI_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/heap.h b/contrib/libs/postgresql/src/include/catalog/heap.h new file mode 100644 index 0000000000..bec795abac --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/heap.h @@ -0,0 +1,163 @@ +/*------------------------------------------------------------------------- + * + * heap.h + * prototypes for functions in backend/catalog/heap.c + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/heap.h + * + *------------------------------------------------------------------------- + */ +#ifndef HEAP_H +#define HEAP_H + +#include "catalog/indexing.h" +#include "catalog/objectaddress.h" +#include "parser/parse_node.h" + + +/* flag bits for CheckAttributeType/CheckAttributeNamesTypes */ +#define CHKATYPE_ANYARRAY 0x01 /* allow ANYARRAY */ +#define CHKATYPE_ANYRECORD 0x02 /* allow RECORD and RECORD[] */ +#define CHKATYPE_IS_PARTKEY 0x04 /* attname is part key # not column */ + +typedef struct RawColumnDefault +{ + AttrNumber attnum; /* attribute to attach default to */ + Node *raw_default; /* default value (untransformed parse tree) */ + bool missingMode; /* true if part of add column processing */ + char generated; /* attgenerated setting */ +} RawColumnDefault; + +typedef struct CookedConstraint +{ + ConstrType contype; /* CONSTR_DEFAULT or CONSTR_CHECK */ + Oid conoid; /* constr OID if created, otherwise Invalid */ + char *name; /* name, or NULL if none */ + AttrNumber attnum; /* which attr (only for DEFAULT) */ + Node *expr; /* transformed default or check expr */ + bool skip_validation; /* skip validation? (only for CHECK) */ + bool is_local; /* constraint has local (non-inherited) def */ + int inhcount; /* number of times constraint is inherited */ + bool is_no_inherit; /* constraint has local def and cannot be + * inherited */ +} CookedConstraint; + +extern Relation heap_create(const char *relname, + Oid relnamespace, + Oid reltablespace, + Oid relid, + Oid relfilenode, + Oid accessmtd, + TupleDesc tupDesc, + char relkind, + char relpersistence, + bool shared_relation, + bool mapped_relation, + bool allow_system_table_mods, + TransactionId *relfrozenxid, + MultiXactId *relminmxid); + +extern Oid heap_create_with_catalog(const char *relname, + Oid relnamespace, + Oid reltablespace, + Oid relid, + Oid reltypeid, + Oid reloftypeid, + Oid ownerid, + Oid accessmtd, + TupleDesc tupdesc, + List *cooked_constraints, + char relkind, + char relpersistence, + bool shared_relation, + bool mapped_relation, + OnCommitAction oncommit, + Datum reloptions, + bool use_user_acl, + bool allow_system_table_mods, + bool is_internal, + Oid relrewrite, + ObjectAddress *typaddress); + +extern void heap_drop_with_catalog(Oid relid); + +extern void heap_truncate(List *relids); + +extern void heap_truncate_one_rel(Relation rel); + +extern void heap_truncate_check_FKs(List *relations, bool tempTables); + +extern List *heap_truncate_find_FKs(List *relationIds); + +extern void InsertPgAttributeTuple(Relation pg_attribute_rel, + Form_pg_attribute new_attribute, + Datum attoptions, + CatalogIndexState indstate); + +extern void InsertPgClassTuple(Relation pg_class_desc, + Relation new_rel_desc, + Oid new_rel_oid, + Datum relacl, + Datum reloptions); + +extern List *AddRelationNewConstraints(Relation rel, + List *newColDefaults, + List *newConstraints, + bool allow_merge, + bool is_local, + bool is_internal, + const char *queryString); + +extern void RelationClearMissing(Relation rel); +extern void SetAttrMissing(Oid relid, char *attname, char *value); + +extern Oid StoreAttrDefault(Relation rel, AttrNumber attnum, + Node *expr, bool is_internal, + bool add_column_mode); + +extern Node *cookDefault(ParseState *pstate, + Node *raw_default, + Oid atttypid, + int32 atttypmod, + const char *attname, + char attgenerated); + +extern void DeleteRelationTuple(Oid relid); +extern void DeleteAttributeTuples(Oid relid); +extern void DeleteSystemAttributeTuples(Oid relid); +extern void RemoveAttributeById(Oid relid, AttrNumber attnum); +extern void RemoveAttrDefault(Oid relid, AttrNumber attnum, + DropBehavior behavior, bool complain, bool internal); +extern void RemoveAttrDefaultById(Oid attrdefId); +extern void CopyStatistics(Oid fromrelid, Oid torelid); +extern void RemoveStatistics(Oid relid, AttrNumber attnum); + +extern const FormData_pg_attribute *SystemAttributeDefinition(AttrNumber attno); + +extern const FormData_pg_attribute *SystemAttributeByName(const char *attname); + +extern void CheckAttributeNamesTypes(TupleDesc tupdesc, char relkind, + int flags); + +extern void CheckAttributeType(const char *attname, + Oid atttypid, Oid attcollation, + List *containing_rowtypes, + int flags); + +/* pg_partitioned_table catalog manipulation functions */ +extern void StorePartitionKey(Relation rel, + char strategy, + int16 partnatts, + AttrNumber *partattrs, + List *partexprs, + Oid *partopclass, + Oid *partcollation); +extern void RemovePartitionKeyByRelId(Oid relid); +extern void StorePartitionBound(Relation rel, Relation parent, + PartitionBoundSpec *bound); + +#endif /* HEAP_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/index.h b/contrib/libs/postgresql/src/include/catalog/index.h new file mode 100644 index 0000000000..f58e8675f3 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/index.h @@ -0,0 +1,199 @@ +/*------------------------------------------------------------------------- + * + * index.h + * prototypes for catalog/index.c. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/index.h + * + *------------------------------------------------------------------------- + */ +#ifndef INDEX_H +#define INDEX_H + +#include "catalog/objectaddress.h" +#include "nodes/execnodes.h" + + +#define DEFAULT_INDEX_TYPE "btree" + +/* Action code for index_set_state_flags */ +typedef enum +{ + INDEX_CREATE_SET_READY, + INDEX_CREATE_SET_VALID, + INDEX_DROP_CLEAR_VALID, + INDEX_DROP_SET_DEAD +} IndexStateFlagsAction; + +/* state info for validate_index bulkdelete callback */ +typedef struct ValidateIndexState +{ + Tuplesortstate *tuplesort; /* for sorting the index TIDs */ + /* statistics (for debug purposes only): */ + double htups, + itups, + tups_inserted; +} ValidateIndexState; + +extern void index_check_primary_key(Relation heapRel, + IndexInfo *indexInfo, + bool is_alter_table, + IndexStmt *stmt); + +#define INDEX_CREATE_IS_PRIMARY (1 << 0) +#define INDEX_CREATE_ADD_CONSTRAINT (1 << 1) +#define INDEX_CREATE_SKIP_BUILD (1 << 2) +#define INDEX_CREATE_CONCURRENT (1 << 3) +#define INDEX_CREATE_IF_NOT_EXISTS (1 << 4) +#define INDEX_CREATE_PARTITIONED (1 << 5) +#define INDEX_CREATE_INVALID (1 << 6) + +extern Oid index_create(Relation heapRelation, + const char *indexRelationName, + Oid indexRelationId, + Oid parentIndexRelid, + Oid parentConstraintId, + Oid relFileNode, + IndexInfo *indexInfo, + List *indexColNames, + Oid accessMethodObjectId, + Oid tableSpaceId, + Oid *collationObjectId, + Oid *classObjectId, + int16 *coloptions, + Datum reloptions, + bits16 flags, + bits16 constr_flags, + bool allow_system_table_mods, + bool is_internal, + Oid *constraintId); + +#define INDEX_CONSTR_CREATE_MARK_AS_PRIMARY (1 << 0) +#define INDEX_CONSTR_CREATE_DEFERRABLE (1 << 1) +#define INDEX_CONSTR_CREATE_INIT_DEFERRED (1 << 2) +#define INDEX_CONSTR_CREATE_UPDATE_INDEX (1 << 3) +#define INDEX_CONSTR_CREATE_REMOVE_OLD_DEPS (1 << 4) + +extern Oid index_concurrently_create_copy(Relation heapRelation, + Oid oldIndexId, + const char *newName); + +extern void index_concurrently_build(Oid heapRelationId, + Oid indexRelationId); + +extern void index_concurrently_swap(Oid newIndexId, + Oid oldIndexId, + const char *oldName); + +extern void index_concurrently_set_dead(Oid heapId, + Oid indexId); + +extern ObjectAddress index_constraint_create(Relation heapRelation, + Oid indexRelationId, + Oid parentConstraintId, + IndexInfo *indexInfo, + const char *constraintName, + char constraintType, + bits16 constr_flags, + bool allow_system_table_mods, + bool is_internal); + +extern void index_drop(Oid indexId, bool concurrent, bool concurrent_lock_mode); + +extern IndexInfo *BuildIndexInfo(Relation index); + +extern IndexInfo *BuildDummyIndexInfo(Relation index); + +extern bool CompareIndexInfo(IndexInfo *info1, IndexInfo *info2, + Oid *collations1, Oid *collations2, + Oid *opfamilies1, Oid *opfamilies2, + AttrMap *attmap); + +extern void BuildSpeculativeIndexInfo(Relation index, IndexInfo *ii); + +extern void FormIndexDatum(IndexInfo *indexInfo, + TupleTableSlot *slot, + EState *estate, + Datum *values, + bool *isnull); + +extern void index_build(Relation heapRelation, + Relation indexRelation, + IndexInfo *indexInfo, + bool isreindex, + bool parallel); + +extern void validate_index(Oid heapId, Oid indexId, Snapshot snapshot); + +extern void index_set_state_flags(Oid indexId, IndexStateFlagsAction action); + +extern Oid IndexGetRelation(Oid indexId, bool missing_ok); + +extern void reindex_index(Oid indexId, bool skip_constraint_checks, + char relpersistence, int options); + +/* Flag bits for reindex_relation(): */ +#define REINDEX_REL_PROCESS_TOAST 0x01 +#define REINDEX_REL_SUPPRESS_INDEX_USE 0x02 +#define REINDEX_REL_CHECK_CONSTRAINTS 0x04 +#define REINDEX_REL_FORCE_INDEXES_UNLOGGED 0x08 +#define REINDEX_REL_FORCE_INDEXES_PERMANENT 0x10 + +extern bool reindex_relation(Oid relid, int flags, int options); + +extern bool ReindexIsProcessingHeap(Oid heapOid); +extern bool ReindexIsProcessingIndex(Oid indexOid); + +extern void ResetReindexState(int nestLevel); +extern Size EstimateReindexStateSpace(void); +extern void SerializeReindexState(Size maxsize, char *start_address); +extern void RestoreReindexState(void *reindexstate); + +extern void IndexSetParentIndex(Relation idx, Oid parentOid); + + +/* + * itemptr_encode - Encode ItemPointer as int64/int8 + * + * This representation must produce values encoded as int64 that sort in the + * same order as their corresponding original TID values would (using the + * default int8 opclass to produce a result equivalent to the default TID + * opclass). + * + * As noted in validate_index(), this can be significantly faster. + */ +static inline int64 +itemptr_encode(ItemPointer itemptr) +{ + BlockNumber block = ItemPointerGetBlockNumber(itemptr); + OffsetNumber offset = ItemPointerGetOffsetNumber(itemptr); + int64 encoded; + + /* + * Use the 16 least significant bits for the offset. 32 adjacent bits are + * used for the block number. Since remaining bits are unused, there + * cannot be negative encoded values (We assume a two's complement + * representation). + */ + encoded = ((uint64) block << 16) | (uint16) offset; + + return encoded; +} + +/* + * itemptr_decode - Decode int64/int8 representation back to ItemPointer + */ +static inline void +itemptr_decode(ItemPointer itemptr, int64 encoded) +{ + BlockNumber block = (BlockNumber) (encoded >> 16); + OffsetNumber offset = (OffsetNumber) (encoded & 0xFFFF); + + ItemPointerSet(itemptr, block, offset); +} + +#endif /* INDEX_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/indexing.h b/contrib/libs/postgresql/src/include/catalog/indexing.h new file mode 100644 index 0000000000..8be303870f --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/indexing.h @@ -0,0 +1,366 @@ +/*------------------------------------------------------------------------- + * + * indexing.h + * This file provides some definitions to support indexing + * on system catalogs + * + * Caution: all #define's with numeric values in this file had better be + * object OIDs, else renumber_oids.pl might change them inappropriately. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/indexing.h + * + *------------------------------------------------------------------------- + */ +#ifndef INDEXING_H +#define INDEXING_H + +#include "access/htup.h" +#include "utils/relcache.h" + +/* + * The state object used by CatalogOpenIndexes and friends is actually the + * same as the executor's ResultRelInfo, but we give it another type name + * to decouple callers from that fact. + */ +typedef struct ResultRelInfo *CatalogIndexState; + +/* + * indexing.c prototypes + */ +extern CatalogIndexState CatalogOpenIndexes(Relation heapRel); +extern void CatalogCloseIndexes(CatalogIndexState indstate); +extern void CatalogTupleInsert(Relation heapRel, HeapTuple tup); +extern void CatalogTupleInsertWithInfo(Relation heapRel, HeapTuple tup, + CatalogIndexState indstate); +extern void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, + HeapTuple tup); +extern void CatalogTupleUpdateWithInfo(Relation heapRel, + ItemPointer otid, HeapTuple tup, + CatalogIndexState indstate); +extern void CatalogTupleDelete(Relation heapRel, ItemPointer tid); + + +/* + * These macros are just to keep the C compiler from spitting up on the + * upcoming commands for Catalog.pm. + */ +#define DECLARE_INDEX(name,oid,decl) extern int no_such_variable +#define DECLARE_UNIQUE_INDEX(name,oid,decl) extern int no_such_variable + + +/* + * What follows are lines processed by genbki.pl to create the statements + * the bootstrap parser will turn into DefineIndex calls. + * + * The keyword is DECLARE_INDEX or DECLARE_UNIQUE_INDEX. The first two + * arguments are the index name and OID, the rest is much like a standard + * 'create index' SQL command. + * + * For each index, we also provide a #define for its OID. References to + * the index in the C code should always use these #defines, not the actual + * index name (much less the numeric OID). + */ + +DECLARE_UNIQUE_INDEX(pg_aggregate_fnoid_index, 2650, on pg_aggregate using btree(aggfnoid oid_ops)); +#define AggregateFnoidIndexId 2650 + +DECLARE_UNIQUE_INDEX(pg_am_name_index, 2651, on pg_am using btree(amname name_ops)); +#define AmNameIndexId 2651 +DECLARE_UNIQUE_INDEX(pg_am_oid_index, 2652, on pg_am using btree(oid oid_ops)); +#define AmOidIndexId 2652 + +DECLARE_UNIQUE_INDEX(pg_amop_fam_strat_index, 2653, on pg_amop using btree(amopfamily oid_ops, amoplefttype oid_ops, amoprighttype oid_ops, amopstrategy int2_ops)); +#define AccessMethodStrategyIndexId 2653 +DECLARE_UNIQUE_INDEX(pg_amop_opr_fam_index, 2654, on pg_amop using btree(amopopr oid_ops, amoppurpose char_ops, amopfamily oid_ops)); +#define AccessMethodOperatorIndexId 2654 +DECLARE_UNIQUE_INDEX(pg_amop_oid_index, 2756, on pg_amop using btree(oid oid_ops)); +#define AccessMethodOperatorOidIndexId 2756 + +DECLARE_UNIQUE_INDEX(pg_amproc_fam_proc_index, 2655, on pg_amproc using btree(amprocfamily oid_ops, amproclefttype oid_ops, amprocrighttype oid_ops, amprocnum int2_ops)); +#define AccessMethodProcedureIndexId 2655 +DECLARE_UNIQUE_INDEX(pg_amproc_oid_index, 2757, on pg_amproc using btree(oid oid_ops)); +#define AccessMethodProcedureOidIndexId 2757 + +DECLARE_UNIQUE_INDEX(pg_attrdef_adrelid_adnum_index, 2656, on pg_attrdef using btree(adrelid oid_ops, adnum int2_ops)); +#define AttrDefaultIndexId 2656 +DECLARE_UNIQUE_INDEX(pg_attrdef_oid_index, 2657, on pg_attrdef using btree(oid oid_ops)); +#define AttrDefaultOidIndexId 2657 + +DECLARE_UNIQUE_INDEX(pg_attribute_relid_attnam_index, 2658, on pg_attribute using btree(attrelid oid_ops, attname name_ops)); +#define AttributeRelidNameIndexId 2658 +DECLARE_UNIQUE_INDEX(pg_attribute_relid_attnum_index, 2659, on pg_attribute using btree(attrelid oid_ops, attnum int2_ops)); +#define AttributeRelidNumIndexId 2659 + +DECLARE_UNIQUE_INDEX(pg_authid_rolname_index, 2676, on pg_authid using btree(rolname name_ops)); +#define AuthIdRolnameIndexId 2676 +DECLARE_UNIQUE_INDEX(pg_authid_oid_index, 2677, on pg_authid using btree(oid oid_ops)); +#define AuthIdOidIndexId 2677 + +DECLARE_UNIQUE_INDEX(pg_auth_members_role_member_index, 2694, on pg_auth_members using btree(roleid oid_ops, member oid_ops)); +#define AuthMemRoleMemIndexId 2694 +DECLARE_UNIQUE_INDEX(pg_auth_members_member_role_index, 2695, on pg_auth_members using btree(member oid_ops, roleid oid_ops)); +#define AuthMemMemRoleIndexId 2695 + +DECLARE_UNIQUE_INDEX(pg_cast_oid_index, 2660, on pg_cast using btree(oid oid_ops)); +#define CastOidIndexId 2660 +DECLARE_UNIQUE_INDEX(pg_cast_source_target_index, 2661, on pg_cast using btree(castsource oid_ops, casttarget oid_ops)); +#define CastSourceTargetIndexId 2661 + +DECLARE_UNIQUE_INDEX(pg_class_oid_index, 2662, on pg_class using btree(oid oid_ops)); +#define ClassOidIndexId 2662 +DECLARE_UNIQUE_INDEX(pg_class_relname_nsp_index, 2663, on pg_class using btree(relname name_ops, relnamespace oid_ops)); +#define ClassNameNspIndexId 2663 +DECLARE_INDEX(pg_class_tblspc_relfilenode_index, 3455, on pg_class using btree(reltablespace oid_ops, relfilenode oid_ops)); +#define ClassTblspcRelfilenodeIndexId 3455 + +DECLARE_UNIQUE_INDEX(pg_collation_name_enc_nsp_index, 3164, on pg_collation using btree(collname name_ops, collencoding int4_ops, collnamespace oid_ops)); +#define CollationNameEncNspIndexId 3164 +DECLARE_UNIQUE_INDEX(pg_collation_oid_index, 3085, on pg_collation using btree(oid oid_ops)); +#define CollationOidIndexId 3085 + +DECLARE_INDEX(pg_constraint_conname_nsp_index, 2664, on pg_constraint using btree(conname name_ops, connamespace oid_ops)); +#define ConstraintNameNspIndexId 2664 +DECLARE_UNIQUE_INDEX(pg_constraint_conrelid_contypid_conname_index, 2665, on pg_constraint using btree(conrelid oid_ops, contypid oid_ops, conname name_ops)); +#define ConstraintRelidTypidNameIndexId 2665 +DECLARE_INDEX(pg_constraint_contypid_index, 2666, on pg_constraint using btree(contypid oid_ops)); +#define ConstraintTypidIndexId 2666 +DECLARE_UNIQUE_INDEX(pg_constraint_oid_index, 2667, on pg_constraint using btree(oid oid_ops)); +#define ConstraintOidIndexId 2667 +DECLARE_INDEX(pg_constraint_conparentid_index, 2579, on pg_constraint using btree(conparentid oid_ops)); +#define ConstraintParentIndexId 2579 + +DECLARE_UNIQUE_INDEX(pg_conversion_default_index, 2668, on pg_conversion using btree(connamespace oid_ops, conforencoding int4_ops, contoencoding int4_ops, oid oid_ops)); +#define ConversionDefaultIndexId 2668 +DECLARE_UNIQUE_INDEX(pg_conversion_name_nsp_index, 2669, on pg_conversion using btree(conname name_ops, connamespace oid_ops)); +#define ConversionNameNspIndexId 2669 +DECLARE_UNIQUE_INDEX(pg_conversion_oid_index, 2670, on pg_conversion using btree(oid oid_ops)); +#define ConversionOidIndexId 2670 + +DECLARE_UNIQUE_INDEX(pg_database_datname_index, 2671, on pg_database using btree(datname name_ops)); +#define DatabaseNameIndexId 2671 +DECLARE_UNIQUE_INDEX(pg_database_oid_index, 2672, on pg_database using btree(oid oid_ops)); +#define DatabaseOidIndexId 2672 + +DECLARE_INDEX(pg_depend_depender_index, 2673, on pg_depend using btree(classid oid_ops, objid oid_ops, objsubid int4_ops)); +#define DependDependerIndexId 2673 +DECLARE_INDEX(pg_depend_reference_index, 2674, on pg_depend using btree(refclassid oid_ops, refobjid oid_ops, refobjsubid int4_ops)); +#define DependReferenceIndexId 2674 + +DECLARE_UNIQUE_INDEX(pg_description_o_c_o_index, 2675, on pg_description using btree(objoid oid_ops, classoid oid_ops, objsubid int4_ops)); +#define DescriptionObjIndexId 2675 +DECLARE_UNIQUE_INDEX(pg_shdescription_o_c_index, 2397, on pg_shdescription using btree(objoid oid_ops, classoid oid_ops)); +#define SharedDescriptionObjIndexId 2397 + +DECLARE_UNIQUE_INDEX(pg_enum_oid_index, 3502, on pg_enum using btree(oid oid_ops)); +#define EnumOidIndexId 3502 +DECLARE_UNIQUE_INDEX(pg_enum_typid_label_index, 3503, on pg_enum using btree(enumtypid oid_ops, enumlabel name_ops)); +#define EnumTypIdLabelIndexId 3503 +DECLARE_UNIQUE_INDEX(pg_enum_typid_sortorder_index, 3534, on pg_enum using btree(enumtypid oid_ops, enumsortorder float4_ops)); +#define EnumTypIdSortOrderIndexId 3534 + +DECLARE_INDEX(pg_index_indrelid_index, 2678, on pg_index using btree(indrelid oid_ops)); +#define IndexIndrelidIndexId 2678 +DECLARE_UNIQUE_INDEX(pg_index_indexrelid_index, 2679, on pg_index using btree(indexrelid oid_ops)); +#define IndexRelidIndexId 2679 + +DECLARE_UNIQUE_INDEX(pg_inherits_relid_seqno_index, 2680, on pg_inherits using btree(inhrelid oid_ops, inhseqno int4_ops)); +#define InheritsRelidSeqnoIndexId 2680 +DECLARE_INDEX(pg_inherits_parent_index, 2187, on pg_inherits using btree(inhparent oid_ops)); +#define InheritsParentIndexId 2187 + +DECLARE_UNIQUE_INDEX(pg_init_privs_o_c_o_index, 3395, on pg_init_privs using btree(objoid oid_ops, classoid oid_ops, objsubid int4_ops)); +#define InitPrivsObjIndexId 3395 + +DECLARE_UNIQUE_INDEX(pg_language_name_index, 2681, on pg_language using btree(lanname name_ops)); +#define LanguageNameIndexId 2681 +DECLARE_UNIQUE_INDEX(pg_language_oid_index, 2682, on pg_language using btree(oid oid_ops)); +#define LanguageOidIndexId 2682 + +DECLARE_UNIQUE_INDEX(pg_largeobject_loid_pn_index, 2683, on pg_largeobject using btree(loid oid_ops, pageno int4_ops)); +#define LargeObjectLOidPNIndexId 2683 + +DECLARE_UNIQUE_INDEX(pg_largeobject_metadata_oid_index, 2996, on pg_largeobject_metadata using btree(oid oid_ops)); +#define LargeObjectMetadataOidIndexId 2996 + +DECLARE_UNIQUE_INDEX(pg_namespace_nspname_index, 2684, on pg_namespace using btree(nspname name_ops)); +#define NamespaceNameIndexId 2684 +DECLARE_UNIQUE_INDEX(pg_namespace_oid_index, 2685, on pg_namespace using btree(oid oid_ops)); +#define NamespaceOidIndexId 2685 + +DECLARE_UNIQUE_INDEX(pg_opclass_am_name_nsp_index, 2686, on pg_opclass using btree(opcmethod oid_ops, opcname name_ops, opcnamespace oid_ops)); +#define OpclassAmNameNspIndexId 2686 +DECLARE_UNIQUE_INDEX(pg_opclass_oid_index, 2687, on pg_opclass using btree(oid oid_ops)); +#define OpclassOidIndexId 2687 + +DECLARE_UNIQUE_INDEX(pg_operator_oid_index, 2688, on pg_operator using btree(oid oid_ops)); +#define OperatorOidIndexId 2688 +DECLARE_UNIQUE_INDEX(pg_operator_oprname_l_r_n_index, 2689, on pg_operator using btree(oprname name_ops, oprleft oid_ops, oprright oid_ops, oprnamespace oid_ops)); +#define OperatorNameNspIndexId 2689 + +DECLARE_UNIQUE_INDEX(pg_opfamily_am_name_nsp_index, 2754, on pg_opfamily using btree(opfmethod oid_ops, opfname name_ops, opfnamespace oid_ops)); +#define OpfamilyAmNameNspIndexId 2754 +DECLARE_UNIQUE_INDEX(pg_opfamily_oid_index, 2755, on pg_opfamily using btree(oid oid_ops)); +#define OpfamilyOidIndexId 2755 + +DECLARE_UNIQUE_INDEX(pg_proc_oid_index, 2690, on pg_proc using btree(oid oid_ops)); +#define ProcedureOidIndexId 2690 +DECLARE_UNIQUE_INDEX(pg_proc_proname_args_nsp_index, 2691, on pg_proc using btree(proname name_ops, proargtypes oidvector_ops, pronamespace oid_ops)); +#define ProcedureNameArgsNspIndexId 2691 + +DECLARE_UNIQUE_INDEX(pg_rewrite_oid_index, 2692, on pg_rewrite using btree(oid oid_ops)); +#define RewriteOidIndexId 2692 +DECLARE_UNIQUE_INDEX(pg_rewrite_rel_rulename_index, 2693, on pg_rewrite using btree(ev_class oid_ops, rulename name_ops)); +#define RewriteRelRulenameIndexId 2693 + +DECLARE_UNIQUE_INDEX(pg_sequence_seqrelid_index, 5002, on pg_sequence using btree(seqrelid oid_ops)); +#define SequenceRelidIndexId 5002 + +DECLARE_INDEX(pg_shdepend_depender_index, 1232, on pg_shdepend using btree(dbid oid_ops, classid oid_ops, objid oid_ops, objsubid int4_ops)); +#define SharedDependDependerIndexId 1232 +DECLARE_INDEX(pg_shdepend_reference_index, 1233, on pg_shdepend using btree(refclassid oid_ops, refobjid oid_ops)); +#define SharedDependReferenceIndexId 1233 + +DECLARE_UNIQUE_INDEX(pg_statistic_relid_att_inh_index, 2696, on pg_statistic using btree(starelid oid_ops, staattnum int2_ops, stainherit bool_ops)); +#define StatisticRelidAttnumInhIndexId 2696 + +DECLARE_UNIQUE_INDEX(pg_statistic_ext_oid_index, 3380, on pg_statistic_ext using btree(oid oid_ops)); +#define StatisticExtOidIndexId 3380 +DECLARE_UNIQUE_INDEX(pg_statistic_ext_name_index, 3997, on pg_statistic_ext using btree(stxname name_ops, stxnamespace oid_ops)); +#define StatisticExtNameIndexId 3997 +DECLARE_INDEX(pg_statistic_ext_relid_index, 3379, on pg_statistic_ext using btree(stxrelid oid_ops)); +#define StatisticExtRelidIndexId 3379 + +DECLARE_UNIQUE_INDEX(pg_statistic_ext_data_stxoid_index, 3433, on pg_statistic_ext_data using btree(stxoid oid_ops)); +#define StatisticExtDataStxoidIndexId 3433 + +DECLARE_UNIQUE_INDEX(pg_tablespace_oid_index, 2697, on pg_tablespace using btree(oid oid_ops)); +#define TablespaceOidIndexId 2697 +DECLARE_UNIQUE_INDEX(pg_tablespace_spcname_index, 2698, on pg_tablespace using btree(spcname name_ops)); +#define TablespaceNameIndexId 2698 + +DECLARE_UNIQUE_INDEX(pg_transform_oid_index, 3574, on pg_transform using btree(oid oid_ops)); +#define TransformOidIndexId 3574 +DECLARE_UNIQUE_INDEX(pg_transform_type_lang_index, 3575, on pg_transform using btree(trftype oid_ops, trflang oid_ops)); +#define TransformTypeLangIndexId 3575 + +DECLARE_INDEX(pg_trigger_tgconstraint_index, 2699, on pg_trigger using btree(tgconstraint oid_ops)); +#define TriggerConstraintIndexId 2699 +DECLARE_UNIQUE_INDEX(pg_trigger_tgrelid_tgname_index, 2701, on pg_trigger using btree(tgrelid oid_ops, tgname name_ops)); +#define TriggerRelidNameIndexId 2701 +DECLARE_UNIQUE_INDEX(pg_trigger_oid_index, 2702, on pg_trigger using btree(oid oid_ops)); +#define TriggerOidIndexId 2702 + +DECLARE_UNIQUE_INDEX(pg_event_trigger_evtname_index, 3467, on pg_event_trigger using btree(evtname name_ops)); +#define EventTriggerNameIndexId 3467 +DECLARE_UNIQUE_INDEX(pg_event_trigger_oid_index, 3468, on pg_event_trigger using btree(oid oid_ops)); +#define EventTriggerOidIndexId 3468 + +DECLARE_UNIQUE_INDEX(pg_ts_config_cfgname_index, 3608, on pg_ts_config using btree(cfgname name_ops, cfgnamespace oid_ops)); +#define TSConfigNameNspIndexId 3608 +DECLARE_UNIQUE_INDEX(pg_ts_config_oid_index, 3712, on pg_ts_config using btree(oid oid_ops)); +#define TSConfigOidIndexId 3712 + +DECLARE_UNIQUE_INDEX(pg_ts_config_map_index, 3609, on pg_ts_config_map using btree(mapcfg oid_ops, maptokentype int4_ops, mapseqno int4_ops)); +#define TSConfigMapIndexId 3609 + +DECLARE_UNIQUE_INDEX(pg_ts_dict_dictname_index, 3604, on pg_ts_dict using btree(dictname name_ops, dictnamespace oid_ops)); +#define TSDictionaryNameNspIndexId 3604 +DECLARE_UNIQUE_INDEX(pg_ts_dict_oid_index, 3605, on pg_ts_dict using btree(oid oid_ops)); +#define TSDictionaryOidIndexId 3605 + +DECLARE_UNIQUE_INDEX(pg_ts_parser_prsname_index, 3606, on pg_ts_parser using btree(prsname name_ops, prsnamespace oid_ops)); +#define TSParserNameNspIndexId 3606 +DECLARE_UNIQUE_INDEX(pg_ts_parser_oid_index, 3607, on pg_ts_parser using btree(oid oid_ops)); +#define TSParserOidIndexId 3607 + +DECLARE_UNIQUE_INDEX(pg_ts_template_tmplname_index, 3766, on pg_ts_template using btree(tmplname name_ops, tmplnamespace oid_ops)); +#define TSTemplateNameNspIndexId 3766 +DECLARE_UNIQUE_INDEX(pg_ts_template_oid_index, 3767, on pg_ts_template using btree(oid oid_ops)); +#define TSTemplateOidIndexId 3767 + +DECLARE_UNIQUE_INDEX(pg_type_oid_index, 2703, on pg_type using btree(oid oid_ops)); +#define TypeOidIndexId 2703 +DECLARE_UNIQUE_INDEX(pg_type_typname_nsp_index, 2704, on pg_type using btree(typname name_ops, typnamespace oid_ops)); +#define TypeNameNspIndexId 2704 + +DECLARE_UNIQUE_INDEX(pg_foreign_data_wrapper_oid_index, 112, on pg_foreign_data_wrapper using btree(oid oid_ops)); +#define ForeignDataWrapperOidIndexId 112 +DECLARE_UNIQUE_INDEX(pg_foreign_data_wrapper_name_index, 548, on pg_foreign_data_wrapper using btree(fdwname name_ops)); +#define ForeignDataWrapperNameIndexId 548 + +DECLARE_UNIQUE_INDEX(pg_foreign_server_oid_index, 113, on pg_foreign_server using btree(oid oid_ops)); +#define ForeignServerOidIndexId 113 +DECLARE_UNIQUE_INDEX(pg_foreign_server_name_index, 549, on pg_foreign_server using btree(srvname name_ops)); +#define ForeignServerNameIndexId 549 + +DECLARE_UNIQUE_INDEX(pg_user_mapping_oid_index, 174, on pg_user_mapping using btree(oid oid_ops)); +#define UserMappingOidIndexId 174 +DECLARE_UNIQUE_INDEX(pg_user_mapping_user_server_index, 175, on pg_user_mapping using btree(umuser oid_ops, umserver oid_ops)); +#define UserMappingUserServerIndexId 175 + +DECLARE_UNIQUE_INDEX(pg_foreign_table_relid_index, 3119, on pg_foreign_table using btree(ftrelid oid_ops)); +#define ForeignTableRelidIndexId 3119 + +DECLARE_UNIQUE_INDEX(pg_default_acl_role_nsp_obj_index, 827, on pg_default_acl using btree(defaclrole oid_ops, defaclnamespace oid_ops, defaclobjtype char_ops)); +#define DefaultAclRoleNspObjIndexId 827 +DECLARE_UNIQUE_INDEX(pg_default_acl_oid_index, 828, on pg_default_acl using btree(oid oid_ops)); +#define DefaultAclOidIndexId 828 + +DECLARE_UNIQUE_INDEX(pg_db_role_setting_databaseid_rol_index, 2965, on pg_db_role_setting using btree(setdatabase oid_ops, setrole oid_ops)); +#define DbRoleSettingDatidRolidIndexId 2965 + +DECLARE_UNIQUE_INDEX(pg_seclabel_object_index, 3597, on pg_seclabel using btree(objoid oid_ops, classoid oid_ops, objsubid int4_ops, provider text_ops)); +#define SecLabelObjectIndexId 3597 + +DECLARE_UNIQUE_INDEX(pg_shseclabel_object_index, 3593, on pg_shseclabel using btree(objoid oid_ops, classoid oid_ops, provider text_ops)); +#define SharedSecLabelObjectIndexId 3593 + +DECLARE_UNIQUE_INDEX(pg_extension_oid_index, 3080, on pg_extension using btree(oid oid_ops)); +#define ExtensionOidIndexId 3080 +DECLARE_UNIQUE_INDEX(pg_extension_name_index, 3081, on pg_extension using btree(extname name_ops)); +#define ExtensionNameIndexId 3081 + +DECLARE_UNIQUE_INDEX(pg_range_rngtypid_index, 3542, on pg_range using btree(rngtypid oid_ops)); +#define RangeTypidIndexId 3542 + +DECLARE_UNIQUE_INDEX(pg_policy_oid_index, 3257, on pg_policy using btree(oid oid_ops)); +#define PolicyOidIndexId 3257 + +DECLARE_UNIQUE_INDEX(pg_policy_polrelid_polname_index, 3258, on pg_policy using btree(polrelid oid_ops, polname name_ops)); +#define PolicyPolrelidPolnameIndexId 3258 + +DECLARE_UNIQUE_INDEX(pg_replication_origin_roiident_index, 6001, on pg_replication_origin using btree(roident oid_ops)); +#define ReplicationOriginIdentIndex 6001 + +DECLARE_UNIQUE_INDEX(pg_replication_origin_roname_index, 6002, on pg_replication_origin using btree(roname text_ops)); +#define ReplicationOriginNameIndex 6002 + +DECLARE_UNIQUE_INDEX(pg_partitioned_table_partrelid_index, 3351, on pg_partitioned_table using btree(partrelid oid_ops)); +#define PartitionedRelidIndexId 3351 + +DECLARE_UNIQUE_INDEX(pg_publication_oid_index, 6110, on pg_publication using btree(oid oid_ops)); +#define PublicationObjectIndexId 6110 + +DECLARE_UNIQUE_INDEX(pg_publication_pubname_index, 6111, on pg_publication using btree(pubname name_ops)); +#define PublicationNameIndexId 6111 + +DECLARE_UNIQUE_INDEX(pg_publication_rel_oid_index, 6112, on pg_publication_rel using btree(oid oid_ops)); +#define PublicationRelObjectIndexId 6112 + +DECLARE_UNIQUE_INDEX(pg_publication_rel_prrelid_prpubid_index, 6113, on pg_publication_rel using btree(prrelid oid_ops, prpubid oid_ops)); +#define PublicationRelPrrelidPrpubidIndexId 6113 + +DECLARE_UNIQUE_INDEX(pg_subscription_oid_index, 6114, on pg_subscription using btree(oid oid_ops)); +#define SubscriptionObjectIndexId 6114 + +DECLARE_UNIQUE_INDEX(pg_subscription_subname_index, 6115, on pg_subscription using btree(subdbid oid_ops, subname name_ops)); +#define SubscriptionNameIndexId 6115 + +DECLARE_UNIQUE_INDEX(pg_subscription_rel_srrelid_srsubid_index, 6117, on pg_subscription_rel using btree(srrelid oid_ops, srsubid oid_ops)); +#define SubscriptionRelSrrelidSrsubidIndexId 6117 + +#endif /* INDEXING_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/namespace.h b/contrib/libs/postgresql/src/include/catalog/namespace.h new file mode 100644 index 0000000000..2456c08bf7 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/namespace.h @@ -0,0 +1,188 @@ +/*------------------------------------------------------------------------- + * + * namespace.h + * prototypes for functions in backend/catalog/namespace.c + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/namespace.h + * + *------------------------------------------------------------------------- + */ +#ifndef NAMESPACE_H +#define NAMESPACE_H + +#include "nodes/primnodes.h" +#include "storage/lock.h" + + +/* + * This structure holds a list of possible functions or operators + * found by namespace lookup. Each function/operator is identified + * by OID and by argument types; the list must be pruned by type + * resolution rules that are embodied in the parser, not here. + * See FuncnameGetCandidates's comments for more info. + */ +typedef struct _FuncCandidateList +{ + struct _FuncCandidateList *next; + int pathpos; /* for internal use of namespace lookup */ + Oid oid; /* the function or operator's OID */ + int nargs; /* number of arg types returned */ + int nvargs; /* number of args to become variadic array */ + int ndargs; /* number of defaulted args */ + int *argnumbers; /* args' positional indexes, if named call */ + Oid args[FLEXIBLE_ARRAY_MEMBER]; /* arg types */ +} *FuncCandidateList; + +/* + * Result of checkTempNamespaceStatus + */ +typedef enum TempNamespaceStatus +{ + TEMP_NAMESPACE_NOT_TEMP, /* nonexistent, or non-temp namespace */ + TEMP_NAMESPACE_IDLE, /* exists, belongs to no active session */ + TEMP_NAMESPACE_IN_USE /* belongs to some active session */ +} TempNamespaceStatus; + +/* + * Structure for xxxOverrideSearchPath functions + * + * The generation counter is private to namespace.c and shouldn't be touched + * by other code. It can be initialized to zero if necessary (that means + * "not known equal to the current active path"). + */ +typedef struct OverrideSearchPath +{ + List *schemas; /* OIDs of explicitly named schemas */ + bool addCatalog; /* implicitly prepend pg_catalog? */ + bool addTemp; /* implicitly prepend temp schema? */ + uint64 generation; /* for quick detection of equality to active */ +} OverrideSearchPath; + +/* + * Option flag bits for RangeVarGetRelidExtended(). + */ +typedef enum RVROption +{ + RVR_MISSING_OK = 1 << 0, /* don't error if relation doesn't exist */ + RVR_NOWAIT = 1 << 1, /* error if relation cannot be locked */ + RVR_SKIP_LOCKED = 1 << 2 /* skip if relation cannot be locked */ +} RVROption; + +typedef void (*RangeVarGetRelidCallback) (const RangeVar *relation, Oid relId, + Oid oldRelId, void *callback_arg); + +#define RangeVarGetRelid(relation, lockmode, missing_ok) \ + RangeVarGetRelidExtended(relation, lockmode, \ + (missing_ok) ? RVR_MISSING_OK : 0, NULL, NULL) + +extern Oid RangeVarGetRelidExtended(const RangeVar *relation, + LOCKMODE lockmode, uint32 flags, + RangeVarGetRelidCallback callback, + void *callback_arg); +extern Oid RangeVarGetCreationNamespace(const RangeVar *newRelation); +extern Oid RangeVarGetAndCheckCreationNamespace(RangeVar *newRelation, + LOCKMODE lockmode, + Oid *existing_relation_id); +extern void RangeVarAdjustRelationPersistence(RangeVar *newRelation, Oid nspid); +extern Oid RelnameGetRelid(const char *relname); +extern bool RelationIsVisible(Oid relid); + +extern Oid TypenameGetTypid(const char *typname); +extern Oid TypenameGetTypidExtended(const char *typname, bool temp_ok); +extern bool TypeIsVisible(Oid typid); + +extern FuncCandidateList FuncnameGetCandidates(List *names, + int nargs, List *argnames, + bool expand_variadic, + bool expand_defaults, + bool missing_ok); +extern bool FunctionIsVisible(Oid funcid); + +extern Oid OpernameGetOprid(List *names, Oid oprleft, Oid oprright); +extern FuncCandidateList OpernameGetCandidates(List *names, char oprkind, + bool missing_schema_ok); +extern bool OperatorIsVisible(Oid oprid); + +extern Oid OpclassnameGetOpcid(Oid amid, const char *opcname); +extern bool OpclassIsVisible(Oid opcid); + +extern Oid OpfamilynameGetOpfid(Oid amid, const char *opfname); +extern bool OpfamilyIsVisible(Oid opfid); + +extern Oid CollationGetCollid(const char *collname); +extern bool CollationIsVisible(Oid collid); + +extern Oid ConversionGetConid(const char *conname); +extern bool ConversionIsVisible(Oid conid); + +extern Oid get_statistics_object_oid(List *names, bool missing_ok); +extern bool StatisticsObjIsVisible(Oid relid); + +extern Oid get_ts_parser_oid(List *names, bool missing_ok); +extern bool TSParserIsVisible(Oid prsId); + +extern Oid get_ts_dict_oid(List *names, bool missing_ok); +extern bool TSDictionaryIsVisible(Oid dictId); + +extern Oid get_ts_template_oid(List *names, bool missing_ok); +extern bool TSTemplateIsVisible(Oid tmplId); + +extern Oid get_ts_config_oid(List *names, bool missing_ok); +extern bool TSConfigIsVisible(Oid cfgid); + +extern void DeconstructQualifiedName(List *names, + char **nspname_p, + char **objname_p); +extern Oid LookupNamespaceNoError(const char *nspname); +extern Oid LookupExplicitNamespace(const char *nspname, bool missing_ok); +extern Oid get_namespace_oid(const char *nspname, bool missing_ok); + +extern Oid LookupCreationNamespace(const char *nspname); +extern void CheckSetNamespace(Oid oldNspOid, Oid nspOid); +extern Oid QualifiedNameGetCreationNamespace(List *names, char **objname_p); +extern RangeVar *makeRangeVarFromNameList(List *names); +extern char *NameListToString(List *names); +extern char *NameListToQuotedString(List *names); + +extern bool isTempNamespace(Oid namespaceId); +extern bool isTempToastNamespace(Oid namespaceId); +extern bool isTempOrTempToastNamespace(Oid namespaceId); +extern bool isAnyTempNamespace(Oid namespaceId); +extern bool isOtherTempNamespace(Oid namespaceId); +extern TempNamespaceStatus checkTempNamespaceStatus(Oid namespaceId); +extern int GetTempNamespaceBackendId(Oid namespaceId); +extern Oid GetTempToastNamespace(void); +extern void GetTempNamespaceState(Oid *tempNamespaceId, + Oid *tempToastNamespaceId); +extern void SetTempNamespaceState(Oid tempNamespaceId, + Oid tempToastNamespaceId); +extern void ResetTempTableNamespace(void); + +extern OverrideSearchPath *GetOverrideSearchPath(MemoryContext context); +extern OverrideSearchPath *CopyOverrideSearchPath(OverrideSearchPath *path); +extern bool OverrideSearchPathMatchesCurrent(OverrideSearchPath *path); +extern void PushOverrideSearchPath(OverrideSearchPath *newpath); +extern void PopOverrideSearchPath(void); + +extern Oid get_collation_oid(List *collname, bool missing_ok); +extern Oid get_conversion_oid(List *conname, bool missing_ok); +extern Oid FindDefaultConversionProc(int32 for_encoding, int32 to_encoding); + + +/* initialization & transaction cleanup code */ +extern void InitializeSearchPath(void); +extern void AtEOXact_Namespace(bool isCommit, bool parallel); +extern void AtEOSubXact_Namespace(bool isCommit, SubTransactionId mySubid, + SubTransactionId parentSubid); + +/* stuff for search_path GUC variable */ +extern char *namespace_search_path; + +extern List *fetch_search_path(bool includeImplicit); +extern int fetch_search_path_array(Oid *sarray, int sarray_len); + +#endif /* NAMESPACE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/objectaccess.h b/contrib/libs/postgresql/src/include/catalog/objectaccess.h new file mode 100644 index 0000000000..fef383692f --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/objectaccess.h @@ -0,0 +1,197 @@ +/* + * objectaccess.h + * + * Object access hooks. + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + */ + +#ifndef OBJECTACCESS_H +#define OBJECTACCESS_H + +/* + * Object access hooks are intended to be called just before or just after + * performing certain actions on a SQL object. This is intended as + * infrastructure for security or logging plugins. + * + * OAT_POST_CREATE should be invoked just after the object is created. + * Typically, this is done after inserting the primary catalog records and + * associated dependencies. + * + * OAT_DROP should be invoked just before deletion of objects; typically + * deleteOneObject(). Its arguments are packed within ObjectAccessDrop. + * + * OAT_POST_ALTER should be invoked just after the object is altered, + * but before the command counter is incremented. An extension using the + * hook can use a current MVCC snapshot to get the old version of the tuple, + * and can use SnapshotSelf to get the new version of the tuple. + * + * OAT_NAMESPACE_SEARCH should be invoked prior to object name lookup under + * a particular namespace. This event is equivalent to usage permission + * on a schema under the default access control mechanism. + * + * OAT_FUNCTION_EXECUTE should be invoked prior to function execution. + * This event is almost equivalent to execute permission on functions, + * except for the case when execute permission is checked during object + * creation or altering, because OAT_POST_CREATE or OAT_POST_ALTER are + * sufficient for extensions to track these kind of checks. + * + * OAT_TRUNCATE should be invoked just before truncation of objects. This + * event is equivalent to truncate permission on a relation under the + * default access control mechanism. + * + * Other types may be added in the future. + */ +typedef enum ObjectAccessType +{ + OAT_POST_CREATE, + OAT_DROP, + OAT_POST_ALTER, + OAT_NAMESPACE_SEARCH, + OAT_FUNCTION_EXECUTE, + OAT_TRUNCATE +} ObjectAccessType; + +/* + * Arguments of OAT_POST_CREATE event + */ +typedef struct +{ + /* + * This flag informs extensions whether the context of this creation is + * invoked by user's operations, or not. E.g, it shall be dealt as + * internal stuff on toast tables or indexes due to type changes. + */ + bool is_internal; +} ObjectAccessPostCreate; + +/* + * Arguments of OAT_DROP event + */ +typedef struct +{ + /* + * Flags to inform extensions the context of this deletion. Also see + * PERFORM_DELETION_* in dependency.h + */ + int dropflags; +} ObjectAccessDrop; + +/* + * Arguments of OAT_POST_ALTER event + */ +typedef struct +{ + /* + * This identifier is used when system catalog takes two IDs to identify a + * particular tuple of the catalog. It is only used when the caller want + * to identify an entry of pg_inherits, pg_db_role_setting or + * pg_user_mapping. Elsewhere, InvalidOid should be set. + */ + Oid auxiliary_id; + + /* + * If this flag is set, the user hasn't requested that the object be + * altered, but we're doing it anyway for some internal reason. + * Permissions-checking hooks may want to skip checks if, say, we're alter + * the constraints of a temporary heap during CLUSTER. + */ + bool is_internal; +} ObjectAccessPostAlter; + +/* + * Arguments of OAT_NAMESPACE_SEARCH + */ +typedef struct +{ + /* + * If true, hook should report an error when permission to search this + * schema is denied. + */ + bool ereport_on_violation; + + /* + * This is, in essence, an out parameter. Core code should initialize + * this to true, and any extension that wants to deny access should reset + * it to false. But an extension should be careful never to store a true + * value here, so that in case there are multiple extensions access is + * only allowed if all extensions agree. + */ + bool result; +} ObjectAccessNamespaceSearch; + +/* Plugin provides a hook function matching this signature. */ +typedef void (*object_access_hook_type) (ObjectAccessType access, + Oid classId, + Oid objectId, + int subId, + void *arg); + +/* Plugin sets this variable to a suitable hook function. */ +extern PGDLLIMPORT object_access_hook_type object_access_hook; + +/* Core code uses these functions to call the hook (see macros below). */ +extern void RunObjectPostCreateHook(Oid classId, Oid objectId, int subId, + bool is_internal); +extern void RunObjectDropHook(Oid classId, Oid objectId, int subId, + int dropflags); +extern void RunObjectTruncateHook(Oid objectId); +extern void RunObjectPostAlterHook(Oid classId, Oid objectId, int subId, + Oid auxiliaryId, bool is_internal); +extern bool RunNamespaceSearchHook(Oid objectId, bool ereport_on_violation); +extern void RunFunctionExecuteHook(Oid objectId); + +/* + * The following macros are wrappers around the functions above; these should + * normally be used to invoke the hook in lieu of calling the above functions + * directly. + */ + +#define InvokeObjectPostCreateHook(classId,objectId,subId) \ + InvokeObjectPostCreateHookArg((classId),(objectId),(subId),false) +#define InvokeObjectPostCreateHookArg(classId,objectId,subId,is_internal) \ + do { \ + if (object_access_hook) \ + RunObjectPostCreateHook((classId),(objectId),(subId), \ + (is_internal)); \ + } while(0) + +#define InvokeObjectDropHook(classId,objectId,subId) \ + InvokeObjectDropHookArg((classId),(objectId),(subId),0) +#define InvokeObjectDropHookArg(classId,objectId,subId,dropflags) \ + do { \ + if (object_access_hook) \ + RunObjectDropHook((classId),(objectId),(subId), \ + (dropflags)); \ + } while(0) + +#define InvokeObjectTruncateHook(objectId) \ + do { \ + if (object_access_hook) \ + RunObjectTruncateHook(objectId); \ + } while(0) + +#define InvokeObjectPostAlterHook(classId,objectId,subId) \ + InvokeObjectPostAlterHookArg((classId),(objectId),(subId), \ + InvalidOid,false) +#define InvokeObjectPostAlterHookArg(classId,objectId,subId, \ + auxiliaryId,is_internal) \ + do { \ + if (object_access_hook) \ + RunObjectPostAlterHook((classId),(objectId),(subId), \ + (auxiliaryId),(is_internal)); \ + } while(0) + +#define InvokeNamespaceSearchHook(objectId, ereport_on_violation) \ + (!object_access_hook \ + ? true \ + : RunNamespaceSearchHook((objectId), (ereport_on_violation))) + +#define InvokeFunctionExecuteHook(objectId) \ + do { \ + if (object_access_hook) \ + RunFunctionExecuteHook(objectId); \ + } while(0) + +#endif /* OBJECTACCESS_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/objectaddress.h b/contrib/libs/postgresql/src/include/catalog/objectaddress.h new file mode 100644 index 0000000000..7f15efd58a --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/objectaddress.h @@ -0,0 +1,84 @@ +/*------------------------------------------------------------------------- + * + * objectaddress.h + * functions for working with object addresses + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/objectaddress.h + * + *------------------------------------------------------------------------- + */ +#ifndef OBJECTADDRESS_H +#define OBJECTADDRESS_H + +#include "access/htup.h" +#include "nodes/parsenodes.h" +#include "storage/lockdefs.h" +#include "utils/relcache.h" + +/* + * An ObjectAddress represents a database object of any type. + */ +typedef struct ObjectAddress +{ + Oid classId; /* Class Id from pg_class */ + Oid objectId; /* OID of the object */ + int32 objectSubId; /* Subitem within object (eg column), or 0 */ +} ObjectAddress; + +extern const ObjectAddress InvalidObjectAddress; + +#define ObjectAddressSubSet(addr, class_id, object_id, object_sub_id) \ + do { \ + (addr).classId = (class_id); \ + (addr).objectId = (object_id); \ + (addr).objectSubId = (object_sub_id); \ + } while (0) + +#define ObjectAddressSet(addr, class_id, object_id) \ + ObjectAddressSubSet(addr, class_id, object_id, 0) + +extern ObjectAddress get_object_address(ObjectType objtype, Node *object, + Relation *relp, + LOCKMODE lockmode, bool missing_ok); + +extern ObjectAddress get_object_address_rv(ObjectType objtype, RangeVar *rel, + List *object, Relation *relp, + LOCKMODE lockmode, bool missing_ok); + +extern void check_object_ownership(Oid roleid, + ObjectType objtype, ObjectAddress address, + Node *object, Relation relation); + +extern Oid get_object_namespace(const ObjectAddress *address); + +extern bool is_objectclass_supported(Oid class_id); +extern Oid get_object_oid_index(Oid class_id); +extern int get_object_catcache_oid(Oid class_id); +extern int get_object_catcache_name(Oid class_id); +extern AttrNumber get_object_attnum_oid(Oid class_id); +extern AttrNumber get_object_attnum_name(Oid class_id); +extern AttrNumber get_object_attnum_namespace(Oid class_id); +extern AttrNumber get_object_attnum_owner(Oid class_id); +extern AttrNumber get_object_attnum_acl(Oid class_id); +extern ObjectType get_object_type(Oid class_id, Oid object_id); +extern bool get_object_namensp_unique(Oid class_id); + +extern HeapTuple get_catalog_object_by_oid(Relation catalog, + AttrNumber oidcol, Oid objectId); + +extern char *getObjectDescription(const ObjectAddress *object); +extern char *getObjectDescriptionOids(Oid classid, Oid objid); + +extern int read_objtype_from_string(const char *objtype); +extern char *getObjectTypeDescription(const ObjectAddress *object); +extern char *getObjectIdentity(const ObjectAddress *address); +extern char *getObjectIdentityParts(const ObjectAddress *address, + List **objname, List **objargs); +extern struct ArrayType *strlist_to_textarray(List *list); + +extern ObjectType get_relkind_objtype(char relkind); + +#endif /* OBJECTADDRESS_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/opfam_internal.h b/contrib/libs/postgresql/src/include/catalog/opfam_internal.h new file mode 100644 index 0000000000..d63bd9ffa3 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/opfam_internal.h @@ -0,0 +1,28 @@ +/*------------------------------------------------------------------------- + * + * opfam_internal.h + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/opfam_internal.h + * + *------------------------------------------------------------------------- + */ +#ifndef OPFAM_INTERNAL_H +#define OPFAM_INTERNAL_H + +/* + * We use lists of this struct type to keep track of both operators and + * procedures while building or adding to an opfamily. + */ +typedef struct +{ + Oid object; /* operator or support proc's OID */ + int number; /* strategy or support proc number */ + Oid lefttype; /* lefttype */ + Oid righttype; /* righttype */ + Oid sortfamily; /* ordering operator's sort opfamily, or 0 */ +} OpFamilyMember; + +#endif /* OPFAM_INTERNAL_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/partition.h b/contrib/libs/postgresql/src/include/catalog/partition.h new file mode 100644 index 0000000000..27873aff6e --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/partition.h @@ -0,0 +1,34 @@ +/*------------------------------------------------------------------------- + * + * partition.h + * Header file for structures and utility functions related to + * partitioning + * + * Copyright (c) 2007-2020, PostgreSQL Global Development Group + * + * src/include/catalog/partition.h + * + *------------------------------------------------------------------------- + */ +#ifndef PARTITION_H +#define PARTITION_H + +#include "partitioning/partdefs.h" +#include "utils/relcache.h" + +/* Seed for the extended hash function */ +#define HASH_PARTITION_SEED UINT64CONST(0x7A5B22367996DCFD) + +extern Oid get_partition_parent(Oid relid); +extern List *get_partition_ancestors(Oid relid); +extern Oid index_get_partition(Relation partition, Oid indexId); +extern List *map_partition_varattnos(List *expr, int fromrel_varno, + Relation to_rel, Relation from_rel); +extern bool has_partition_attrs(Relation rel, Bitmapset *attnums, + bool *used_in_expr); + +extern Oid get_default_partition_oid(Oid parentId); +extern void update_default_partition_oid(Oid parentId, Oid defaultPartId); +extern List *get_proposed_default_constraint(List *new_part_constraints); + +#endif /* PARTITION_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_aggregate.dat b/contrib/libs/postgresql/src/include/catalog/pg_aggregate.dat new file mode 100644 index 0000000000..ffabe275c0 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_aggregate.dat @@ -0,0 +1,598 @@ +#---------------------------------------------------------------------- +# +# pg_aggregate.dat +# Initial contents of the pg_aggregate system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_aggregate.dat +# +#---------------------------------------------------------------------- + +[ + +# avg +{ aggfnoid => 'avg(int8)', aggtransfn => 'int8_avg_accum', + aggfinalfn => 'numeric_poly_avg', aggcombinefn => 'int8_avg_combine', + aggserialfn => 'int8_avg_serialize', aggdeserialfn => 'int8_avg_deserialize', + aggmtransfn => 'int8_avg_accum', aggminvtransfn => 'int8_avg_accum_inv', + aggmfinalfn => 'numeric_poly_avg', aggtranstype => 'internal', + aggtransspace => '48', aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'avg(int4)', aggtransfn => 'int4_avg_accum', + aggfinalfn => 'int8_avg', aggcombinefn => 'int4_avg_combine', + aggmtransfn => 'int4_avg_accum', aggminvtransfn => 'int4_avg_accum_inv', + aggmfinalfn => 'int8_avg', aggtranstype => '_int8', aggmtranstype => '_int8', + agginitval => '{0,0}', aggminitval => '{0,0}' }, +{ aggfnoid => 'avg(int2)', aggtransfn => 'int2_avg_accum', + aggfinalfn => 'int8_avg', aggcombinefn => 'int4_avg_combine', + aggmtransfn => 'int2_avg_accum', aggminvtransfn => 'int2_avg_accum_inv', + aggmfinalfn => 'int8_avg', aggtranstype => '_int8', aggmtranstype => '_int8', + agginitval => '{0,0}', aggminitval => '{0,0}' }, +{ aggfnoid => 'avg(numeric)', aggtransfn => 'numeric_avg_accum', + aggfinalfn => 'numeric_avg', aggcombinefn => 'numeric_avg_combine', + aggserialfn => 'numeric_avg_serialize', + aggdeserialfn => 'numeric_avg_deserialize', + aggmtransfn => 'numeric_avg_accum', aggminvtransfn => 'numeric_accum_inv', + aggmfinalfn => 'numeric_avg', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, +{ aggfnoid => 'avg(float4)', aggtransfn => 'float4_accum', + aggfinalfn => 'float8_avg', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'avg(float8)', aggtransfn => 'float8_accum', + aggfinalfn => 'float8_avg', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'avg(interval)', aggtransfn => 'interval_accum', + aggfinalfn => 'interval_avg', aggcombinefn => 'interval_combine', + aggmtransfn => 'interval_accum', aggminvtransfn => 'interval_accum_inv', + aggmfinalfn => 'interval_avg', aggtranstype => '_interval', + aggmtranstype => '_interval', agginitval => '{0 second,0 second}', + aggminitval => '{0 second,0 second}' }, + +# sum +{ aggfnoid => 'sum(int8)', aggtransfn => 'int8_avg_accum', + aggfinalfn => 'numeric_poly_sum', aggcombinefn => 'int8_avg_combine', + aggserialfn => 'int8_avg_serialize', aggdeserialfn => 'int8_avg_deserialize', + aggmtransfn => 'int8_avg_accum', aggminvtransfn => 'int8_avg_accum_inv', + aggmfinalfn => 'numeric_poly_sum', aggtranstype => 'internal', + aggtransspace => '48', aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'sum(int4)', aggtransfn => 'int4_sum', aggcombinefn => 'int8pl', + aggmtransfn => 'int4_avg_accum', aggminvtransfn => 'int4_avg_accum_inv', + aggmfinalfn => 'int2int4_sum', aggtranstype => 'int8', + aggmtranstype => '_int8', aggminitval => '{0,0}' }, +{ aggfnoid => 'sum(int2)', aggtransfn => 'int2_sum', aggcombinefn => 'int8pl', + aggmtransfn => 'int2_avg_accum', aggminvtransfn => 'int2_avg_accum_inv', + aggmfinalfn => 'int2int4_sum', aggtranstype => 'int8', + aggmtranstype => '_int8', aggminitval => '{0,0}' }, +{ aggfnoid => 'sum(float4)', aggtransfn => 'float4pl', + aggcombinefn => 'float4pl', aggtranstype => 'float4' }, +{ aggfnoid => 'sum(float8)', aggtransfn => 'float8pl', + aggcombinefn => 'float8pl', aggtranstype => 'float8' }, +{ aggfnoid => 'sum(money)', aggtransfn => 'cash_pl', aggcombinefn => 'cash_pl', + aggmtransfn => 'cash_pl', aggminvtransfn => 'cash_mi', + aggtranstype => 'money', aggmtranstype => 'money' }, +{ aggfnoid => 'sum(interval)', aggtransfn => 'interval_pl', + aggcombinefn => 'interval_pl', aggmtransfn => 'interval_pl', + aggminvtransfn => 'interval_mi', aggtranstype => 'interval', + aggmtranstype => 'interval' }, +{ aggfnoid => 'sum(numeric)', aggtransfn => 'numeric_avg_accum', + aggfinalfn => 'numeric_sum', aggcombinefn => 'numeric_avg_combine', + aggserialfn => 'numeric_avg_serialize', + aggdeserialfn => 'numeric_avg_deserialize', + aggmtransfn => 'numeric_avg_accum', aggminvtransfn => 'numeric_accum_inv', + aggmfinalfn => 'numeric_sum', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, + +# max +{ aggfnoid => 'max(int8)', aggtransfn => 'int8larger', + aggcombinefn => 'int8larger', aggsortop => '>(int8,int8)', + aggtranstype => 'int8' }, +{ aggfnoid => 'max(int4)', aggtransfn => 'int4larger', + aggcombinefn => 'int4larger', aggsortop => '>(int4,int4)', + aggtranstype => 'int4' }, +{ aggfnoid => 'max(int2)', aggtransfn => 'int2larger', + aggcombinefn => 'int2larger', aggsortop => '>(int2,int2)', + aggtranstype => 'int2' }, +{ aggfnoid => 'max(oid)', aggtransfn => 'oidlarger', + aggcombinefn => 'oidlarger', aggsortop => '>(oid,oid)', + aggtranstype => 'oid' }, +{ aggfnoid => 'max(float4)', aggtransfn => 'float4larger', + aggcombinefn => 'float4larger', aggsortop => '>(float4,float4)', + aggtranstype => 'float4' }, +{ aggfnoid => 'max(float8)', aggtransfn => 'float8larger', + aggcombinefn => 'float8larger', aggsortop => '>(float8,float8)', + aggtranstype => 'float8' }, +{ aggfnoid => 'max(date)', aggtransfn => 'date_larger', + aggcombinefn => 'date_larger', aggsortop => '>(date,date)', + aggtranstype => 'date' }, +{ aggfnoid => 'max(time)', aggtransfn => 'time_larger', + aggcombinefn => 'time_larger', aggsortop => '>(time,time)', + aggtranstype => 'time' }, +{ aggfnoid => 'max(timetz)', aggtransfn => 'timetz_larger', + aggcombinefn => 'timetz_larger', aggsortop => '>(timetz,timetz)', + aggtranstype => 'timetz' }, +{ aggfnoid => 'max(money)', aggtransfn => 'cashlarger', + aggcombinefn => 'cashlarger', aggsortop => '>(money,money)', + aggtranstype => 'money' }, +{ aggfnoid => 'max(timestamp)', aggtransfn => 'timestamp_larger', + aggcombinefn => 'timestamp_larger', aggsortop => '>(timestamp,timestamp)', + aggtranstype => 'timestamp' }, +{ aggfnoid => 'max(timestamptz)', aggtransfn => 'timestamptz_larger', + aggcombinefn => 'timestamptz_larger', + aggsortop => '>(timestamptz,timestamptz)', aggtranstype => 'timestamptz' }, +{ aggfnoid => 'max(interval)', aggtransfn => 'interval_larger', + aggcombinefn => 'interval_larger', aggsortop => '>(interval,interval)', + aggtranstype => 'interval' }, +{ aggfnoid => 'max(text)', aggtransfn => 'text_larger', + aggcombinefn => 'text_larger', aggsortop => '>(text,text)', + aggtranstype => 'text' }, +{ aggfnoid => 'max(numeric)', aggtransfn => 'numeric_larger', + aggcombinefn => 'numeric_larger', aggsortop => '>(numeric,numeric)', + aggtranstype => 'numeric' }, +{ aggfnoid => 'max(anyarray)', aggtransfn => 'array_larger', + aggcombinefn => 'array_larger', aggsortop => '>(anyarray,anyarray)', + aggtranstype => 'anyarray' }, +{ aggfnoid => 'max(bpchar)', aggtransfn => 'bpchar_larger', + aggcombinefn => 'bpchar_larger', aggsortop => '>(bpchar,bpchar)', + aggtranstype => 'bpchar' }, +{ aggfnoid => 'max(tid)', aggtransfn => 'tidlarger', + aggcombinefn => 'tidlarger', aggsortop => '>(tid,tid)', + aggtranstype => 'tid' }, +{ aggfnoid => 'max(anyenum)', aggtransfn => 'enum_larger', + aggcombinefn => 'enum_larger', aggsortop => '>(anyenum,anyenum)', + aggtranstype => 'anyenum' }, +{ aggfnoid => 'max(inet)', aggtransfn => 'network_larger', + aggcombinefn => 'network_larger', aggsortop => '>(inet,inet)', + aggtranstype => 'inet' }, +{ aggfnoid => 'max(pg_lsn)', aggtransfn => 'pg_lsn_larger', + aggcombinefn => 'pg_lsn_larger', aggsortop => '>(pg_lsn,pg_lsn)', + aggtranstype => 'pg_lsn' }, + +# min +{ aggfnoid => 'min(int8)', aggtransfn => 'int8smaller', + aggcombinefn => 'int8smaller', aggsortop => '<(int8,int8)', + aggtranstype => 'int8' }, +{ aggfnoid => 'min(int4)', aggtransfn => 'int4smaller', + aggcombinefn => 'int4smaller', aggsortop => '<(int4,int4)', + aggtranstype => 'int4' }, +{ aggfnoid => 'min(int2)', aggtransfn => 'int2smaller', + aggcombinefn => 'int2smaller', aggsortop => '<(int2,int2)', + aggtranstype => 'int2' }, +{ aggfnoid => 'min(oid)', aggtransfn => 'oidsmaller', + aggcombinefn => 'oidsmaller', aggsortop => '<(oid,oid)', + aggtranstype => 'oid' }, +{ aggfnoid => 'min(float4)', aggtransfn => 'float4smaller', + aggcombinefn => 'float4smaller', aggsortop => '<(float4,float4)', + aggtranstype => 'float4' }, +{ aggfnoid => 'min(float8)', aggtransfn => 'float8smaller', + aggcombinefn => 'float8smaller', aggsortop => '<(float8,float8)', + aggtranstype => 'float8' }, +{ aggfnoid => 'min(date)', aggtransfn => 'date_smaller', + aggcombinefn => 'date_smaller', aggsortop => '<(date,date)', + aggtranstype => 'date' }, +{ aggfnoid => 'min(time)', aggtransfn => 'time_smaller', + aggcombinefn => 'time_smaller', aggsortop => '<(time,time)', + aggtranstype => 'time' }, +{ aggfnoid => 'min(timetz)', aggtransfn => 'timetz_smaller', + aggcombinefn => 'timetz_smaller', aggsortop => '<(timetz,timetz)', + aggtranstype => 'timetz' }, +{ aggfnoid => 'min(money)', aggtransfn => 'cashsmaller', + aggcombinefn => 'cashsmaller', aggsortop => '<(money,money)', + aggtranstype => 'money' }, +{ aggfnoid => 'min(timestamp)', aggtransfn => 'timestamp_smaller', + aggcombinefn => 'timestamp_smaller', aggsortop => '<(timestamp,timestamp)', + aggtranstype => 'timestamp' }, +{ aggfnoid => 'min(timestamptz)', aggtransfn => 'timestamptz_smaller', + aggcombinefn => 'timestamptz_smaller', + aggsortop => '<(timestamptz,timestamptz)', aggtranstype => 'timestamptz' }, +{ aggfnoid => 'min(interval)', aggtransfn => 'interval_smaller', + aggcombinefn => 'interval_smaller', aggsortop => '<(interval,interval)', + aggtranstype => 'interval' }, +{ aggfnoid => 'min(text)', aggtransfn => 'text_smaller', + aggcombinefn => 'text_smaller', aggsortop => '<(text,text)', + aggtranstype => 'text' }, +{ aggfnoid => 'min(numeric)', aggtransfn => 'numeric_smaller', + aggcombinefn => 'numeric_smaller', aggsortop => '<(numeric,numeric)', + aggtranstype => 'numeric' }, +{ aggfnoid => 'min(anyarray)', aggtransfn => 'array_smaller', + aggcombinefn => 'array_smaller', aggsortop => '<(anyarray,anyarray)', + aggtranstype => 'anyarray' }, +{ aggfnoid => 'min(bpchar)', aggtransfn => 'bpchar_smaller', + aggcombinefn => 'bpchar_smaller', aggsortop => '<(bpchar,bpchar)', + aggtranstype => 'bpchar' }, +{ aggfnoid => 'min(tid)', aggtransfn => 'tidsmaller', + aggcombinefn => 'tidsmaller', aggsortop => '<(tid,tid)', + aggtranstype => 'tid' }, +{ aggfnoid => 'min(anyenum)', aggtransfn => 'enum_smaller', + aggcombinefn => 'enum_smaller', aggsortop => '<(anyenum,anyenum)', + aggtranstype => 'anyenum' }, +{ aggfnoid => 'min(inet)', aggtransfn => 'network_smaller', + aggcombinefn => 'network_smaller', aggsortop => '<(inet,inet)', + aggtranstype => 'inet' }, +{ aggfnoid => 'min(pg_lsn)', aggtransfn => 'pg_lsn_smaller', + aggcombinefn => 'pg_lsn_smaller', aggsortop => '<(pg_lsn,pg_lsn)', + aggtranstype => 'pg_lsn' }, + +# count +{ aggfnoid => 'count(any)', aggtransfn => 'int8inc_any', + aggcombinefn => 'int8pl', aggmtransfn => 'int8inc_any', + aggminvtransfn => 'int8dec_any', aggtranstype => 'int8', + aggmtranstype => 'int8', agginitval => '0', aggminitval => '0' }, +{ aggfnoid => 'count()', aggtransfn => 'int8inc', aggcombinefn => 'int8pl', + aggmtransfn => 'int8inc', aggminvtransfn => 'int8dec', aggtranstype => 'int8', + aggmtranstype => 'int8', agginitval => '0', aggminitval => '0' }, + +# var_pop +{ aggfnoid => 'var_pop(int8)', aggtransfn => 'int8_accum', + aggfinalfn => 'numeric_var_pop', aggcombinefn => 'numeric_combine', + aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize', + aggmtransfn => 'int8_accum', aggminvtransfn => 'int8_accum_inv', + aggmfinalfn => 'numeric_var_pop', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, +{ aggfnoid => 'var_pop(int4)', aggtransfn => 'int4_accum', + aggfinalfn => 'numeric_poly_var_pop', aggcombinefn => 'numeric_poly_combine', + aggserialfn => 'numeric_poly_serialize', + aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int4_accum', + aggminvtransfn => 'int4_accum_inv', aggmfinalfn => 'numeric_poly_var_pop', + aggtranstype => 'internal', aggtransspace => '48', + aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'var_pop(int2)', aggtransfn => 'int2_accum', + aggfinalfn => 'numeric_poly_var_pop', aggcombinefn => 'numeric_poly_combine', + aggserialfn => 'numeric_poly_serialize', + aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int2_accum', + aggminvtransfn => 'int2_accum_inv', aggmfinalfn => 'numeric_poly_var_pop', + aggtranstype => 'internal', aggtransspace => '48', + aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'var_pop(float4)', aggtransfn => 'float4_accum', + aggfinalfn => 'float8_var_pop', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'var_pop(float8)', aggtransfn => 'float8_accum', + aggfinalfn => 'float8_var_pop', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'var_pop(numeric)', aggtransfn => 'numeric_accum', + aggfinalfn => 'numeric_var_pop', aggcombinefn => 'numeric_combine', + aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize', + aggmtransfn => 'numeric_accum', aggminvtransfn => 'numeric_accum_inv', + aggmfinalfn => 'numeric_var_pop', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, + +# var_samp +{ aggfnoid => 'var_samp(int8)', aggtransfn => 'int8_accum', + aggfinalfn => 'numeric_var_samp', aggcombinefn => 'numeric_combine', + aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize', + aggmtransfn => 'int8_accum', aggminvtransfn => 'int8_accum_inv', + aggmfinalfn => 'numeric_var_samp', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, +{ aggfnoid => 'var_samp(int4)', aggtransfn => 'int4_accum', + aggfinalfn => 'numeric_poly_var_samp', aggcombinefn => 'numeric_poly_combine', + aggserialfn => 'numeric_poly_serialize', + aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int4_accum', + aggminvtransfn => 'int4_accum_inv', aggmfinalfn => 'numeric_poly_var_samp', + aggtranstype => 'internal', aggtransspace => '48', + aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'var_samp(int2)', aggtransfn => 'int2_accum', + aggfinalfn => 'numeric_poly_var_samp', aggcombinefn => 'numeric_poly_combine', + aggserialfn => 'numeric_poly_serialize', + aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int2_accum', + aggminvtransfn => 'int2_accum_inv', aggmfinalfn => 'numeric_poly_var_samp', + aggtranstype => 'internal', aggtransspace => '48', + aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'var_samp(float4)', aggtransfn => 'float4_accum', + aggfinalfn => 'float8_var_samp', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'var_samp(float8)', aggtransfn => 'float8_accum', + aggfinalfn => 'float8_var_samp', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'var_samp(numeric)', aggtransfn => 'numeric_accum', + aggfinalfn => 'numeric_var_samp', aggcombinefn => 'numeric_combine', + aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize', + aggmtransfn => 'numeric_accum', aggminvtransfn => 'numeric_accum_inv', + aggmfinalfn => 'numeric_var_samp', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, + +# variance: historical Postgres syntax for var_samp +{ aggfnoid => 'variance(int8)', aggtransfn => 'int8_accum', + aggfinalfn => 'numeric_var_samp', aggcombinefn => 'numeric_combine', + aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize', + aggmtransfn => 'int8_accum', aggminvtransfn => 'int8_accum_inv', + aggmfinalfn => 'numeric_var_samp', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, +{ aggfnoid => 'variance(int4)', aggtransfn => 'int4_accum', + aggfinalfn => 'numeric_poly_var_samp', aggcombinefn => 'numeric_poly_combine', + aggserialfn => 'numeric_poly_serialize', + aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int4_accum', + aggminvtransfn => 'int4_accum_inv', aggmfinalfn => 'numeric_poly_var_samp', + aggtranstype => 'internal', aggtransspace => '48', + aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'variance(int2)', aggtransfn => 'int2_accum', + aggfinalfn => 'numeric_poly_var_samp', aggcombinefn => 'numeric_poly_combine', + aggserialfn => 'numeric_poly_serialize', + aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int2_accum', + aggminvtransfn => 'int2_accum_inv', aggmfinalfn => 'numeric_poly_var_samp', + aggtranstype => 'internal', aggtransspace => '48', + aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'variance(float4)', aggtransfn => 'float4_accum', + aggfinalfn => 'float8_var_samp', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'variance(float8)', aggtransfn => 'float8_accum', + aggfinalfn => 'float8_var_samp', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'variance(numeric)', aggtransfn => 'numeric_accum', + aggfinalfn => 'numeric_var_samp', aggcombinefn => 'numeric_combine', + aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize', + aggmtransfn => 'numeric_accum', aggminvtransfn => 'numeric_accum_inv', + aggmfinalfn => 'numeric_var_samp', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, + +# stddev_pop +{ aggfnoid => 'stddev_pop(int8)', aggtransfn => 'int8_accum', + aggfinalfn => 'numeric_stddev_pop', aggcombinefn => 'numeric_combine', + aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize', + aggmtransfn => 'int8_accum', aggminvtransfn => 'int8_accum_inv', + aggmfinalfn => 'numeric_stddev_pop', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, +{ aggfnoid => 'stddev_pop(int4)', aggtransfn => 'int4_accum', + aggfinalfn => 'numeric_poly_stddev_pop', + aggcombinefn => 'numeric_poly_combine', + aggserialfn => 'numeric_poly_serialize', + aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int4_accum', + aggminvtransfn => 'int4_accum_inv', aggmfinalfn => 'numeric_poly_stddev_pop', + aggtranstype => 'internal', aggtransspace => '48', + aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'stddev_pop(int2)', aggtransfn => 'int2_accum', + aggfinalfn => 'numeric_poly_stddev_pop', + aggcombinefn => 'numeric_poly_combine', + aggserialfn => 'numeric_poly_serialize', + aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int2_accum', + aggminvtransfn => 'int2_accum_inv', aggmfinalfn => 'numeric_poly_stddev_pop', + aggtranstype => 'internal', aggtransspace => '48', + aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'stddev_pop(float4)', aggtransfn => 'float4_accum', + aggfinalfn => 'float8_stddev_pop', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'stddev_pop(float8)', aggtransfn => 'float8_accum', + aggfinalfn => 'float8_stddev_pop', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'stddev_pop(numeric)', aggtransfn => 'numeric_accum', + aggfinalfn => 'numeric_stddev_pop', aggcombinefn => 'numeric_combine', + aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize', + aggmtransfn => 'numeric_accum', aggminvtransfn => 'numeric_accum_inv', + aggmfinalfn => 'numeric_stddev_pop', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, + +# stddev_samp +{ aggfnoid => 'stddev_samp(int8)', aggtransfn => 'int8_accum', + aggfinalfn => 'numeric_stddev_samp', aggcombinefn => 'numeric_combine', + aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize', + aggmtransfn => 'int8_accum', aggminvtransfn => 'int8_accum_inv', + aggmfinalfn => 'numeric_stddev_samp', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, +{ aggfnoid => 'stddev_samp(int4)', aggtransfn => 'int4_accum', + aggfinalfn => 'numeric_poly_stddev_samp', + aggcombinefn => 'numeric_poly_combine', + aggserialfn => 'numeric_poly_serialize', + aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int4_accum', + aggminvtransfn => 'int4_accum_inv', aggmfinalfn => 'numeric_poly_stddev_samp', + aggtranstype => 'internal', aggtransspace => '48', + aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'stddev_samp(int2)', aggtransfn => 'int2_accum', + aggfinalfn => 'numeric_poly_stddev_samp', + aggcombinefn => 'numeric_poly_combine', + aggserialfn => 'numeric_poly_serialize', + aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int2_accum', + aggminvtransfn => 'int2_accum_inv', aggmfinalfn => 'numeric_poly_stddev_samp', + aggtranstype => 'internal', aggtransspace => '48', + aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'stddev_samp(float4)', aggtransfn => 'float4_accum', + aggfinalfn => 'float8_stddev_samp', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'stddev_samp(float8)', aggtransfn => 'float8_accum', + aggfinalfn => 'float8_stddev_samp', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'stddev_samp(numeric)', aggtransfn => 'numeric_accum', + aggfinalfn => 'numeric_stddev_samp', aggcombinefn => 'numeric_combine', + aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize', + aggmtransfn => 'numeric_accum', aggminvtransfn => 'numeric_accum_inv', + aggmfinalfn => 'numeric_stddev_samp', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, + +# stddev: historical Postgres syntax for stddev_samp +{ aggfnoid => 'stddev(int8)', aggtransfn => 'int8_accum', + aggfinalfn => 'numeric_stddev_samp', aggcombinefn => 'numeric_combine', + aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize', + aggmtransfn => 'int8_accum', aggminvtransfn => 'int8_accum_inv', + aggmfinalfn => 'numeric_stddev_samp', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, +{ aggfnoid => 'stddev(int4)', aggtransfn => 'int4_accum', + aggfinalfn => 'numeric_poly_stddev_samp', + aggcombinefn => 'numeric_poly_combine', + aggserialfn => 'numeric_poly_serialize', + aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int4_accum', + aggminvtransfn => 'int4_accum_inv', aggmfinalfn => 'numeric_poly_stddev_samp', + aggtranstype => 'internal', aggtransspace => '48', + aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'stddev(int2)', aggtransfn => 'int2_accum', + aggfinalfn => 'numeric_poly_stddev_samp', + aggcombinefn => 'numeric_poly_combine', + aggserialfn => 'numeric_poly_serialize', + aggdeserialfn => 'numeric_poly_deserialize', aggmtransfn => 'int2_accum', + aggminvtransfn => 'int2_accum_inv', aggmfinalfn => 'numeric_poly_stddev_samp', + aggtranstype => 'internal', aggtransspace => '48', + aggmtranstype => 'internal', aggmtransspace => '48' }, +{ aggfnoid => 'stddev(float4)', aggtransfn => 'float4_accum', + aggfinalfn => 'float8_stddev_samp', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'stddev(float8)', aggtransfn => 'float8_accum', + aggfinalfn => 'float8_stddev_samp', aggcombinefn => 'float8_combine', + aggtranstype => '_float8', agginitval => '{0,0,0}' }, +{ aggfnoid => 'stddev(numeric)', aggtransfn => 'numeric_accum', + aggfinalfn => 'numeric_stddev_samp', aggcombinefn => 'numeric_combine', + aggserialfn => 'numeric_serialize', aggdeserialfn => 'numeric_deserialize', + aggmtransfn => 'numeric_accum', aggminvtransfn => 'numeric_accum_inv', + aggmfinalfn => 'numeric_stddev_samp', aggtranstype => 'internal', + aggtransspace => '128', aggmtranstype => 'internal', + aggmtransspace => '128' }, + +# SQL2003 binary regression aggregates +{ aggfnoid => 'regr_count', aggtransfn => 'int8inc_float8_float8', + aggcombinefn => 'int8pl', aggtranstype => 'int8', agginitval => '0' }, +{ aggfnoid => 'regr_sxx', aggtransfn => 'float8_regr_accum', + aggfinalfn => 'float8_regr_sxx', aggcombinefn => 'float8_regr_combine', + aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' }, +{ aggfnoid => 'regr_syy', aggtransfn => 'float8_regr_accum', + aggfinalfn => 'float8_regr_syy', aggcombinefn => 'float8_regr_combine', + aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' }, +{ aggfnoid => 'regr_sxy', aggtransfn => 'float8_regr_accum', + aggfinalfn => 'float8_regr_sxy', aggcombinefn => 'float8_regr_combine', + aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' }, +{ aggfnoid => 'regr_avgx', aggtransfn => 'float8_regr_accum', + aggfinalfn => 'float8_regr_avgx', aggcombinefn => 'float8_regr_combine', + aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' }, +{ aggfnoid => 'regr_avgy', aggtransfn => 'float8_regr_accum', + aggfinalfn => 'float8_regr_avgy', aggcombinefn => 'float8_regr_combine', + aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' }, +{ aggfnoid => 'regr_r2', aggtransfn => 'float8_regr_accum', + aggfinalfn => 'float8_regr_r2', aggcombinefn => 'float8_regr_combine', + aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' }, +{ aggfnoid => 'regr_slope', aggtransfn => 'float8_regr_accum', + aggfinalfn => 'float8_regr_slope', aggcombinefn => 'float8_regr_combine', + aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' }, +{ aggfnoid => 'regr_intercept', aggtransfn => 'float8_regr_accum', + aggfinalfn => 'float8_regr_intercept', aggcombinefn => 'float8_regr_combine', + aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' }, +{ aggfnoid => 'covar_pop', aggtransfn => 'float8_regr_accum', + aggfinalfn => 'float8_covar_pop', aggcombinefn => 'float8_regr_combine', + aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' }, +{ aggfnoid => 'covar_samp', aggtransfn => 'float8_regr_accum', + aggfinalfn => 'float8_covar_samp', aggcombinefn => 'float8_regr_combine', + aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' }, +{ aggfnoid => 'corr', aggtransfn => 'float8_regr_accum', + aggfinalfn => 'float8_corr', aggcombinefn => 'float8_regr_combine', + aggtranstype => '_float8', agginitval => '{0,0,0,0,0,0}' }, + +# boolean-and and boolean-or +{ aggfnoid => 'bool_and', aggtransfn => 'booland_statefunc', + aggcombinefn => 'booland_statefunc', aggmtransfn => 'bool_accum', + aggminvtransfn => 'bool_accum_inv', aggmfinalfn => 'bool_alltrue', + aggsortop => '<(bool,bool)', aggtranstype => 'bool', + aggmtranstype => 'internal', aggmtransspace => '16' }, +{ aggfnoid => 'bool_or', aggtransfn => 'boolor_statefunc', + aggcombinefn => 'boolor_statefunc', aggmtransfn => 'bool_accum', + aggminvtransfn => 'bool_accum_inv', aggmfinalfn => 'bool_anytrue', + aggsortop => '>(bool,bool)', aggtranstype => 'bool', + aggmtranstype => 'internal', aggmtransspace => '16' }, +{ aggfnoid => 'every', aggtransfn => 'booland_statefunc', + aggcombinefn => 'booland_statefunc', aggmtransfn => 'bool_accum', + aggminvtransfn => 'bool_accum_inv', aggmfinalfn => 'bool_alltrue', + aggsortop => '<(bool,bool)', aggtranstype => 'bool', + aggmtranstype => 'internal', aggmtransspace => '16' }, + +# bitwise integer +{ aggfnoid => 'bit_and(int2)', aggtransfn => 'int2and', + aggcombinefn => 'int2and', aggtranstype => 'int2' }, +{ aggfnoid => 'bit_or(int2)', aggtransfn => 'int2or', aggcombinefn => 'int2or', + aggtranstype => 'int2' }, +{ aggfnoid => 'bit_and(int4)', aggtransfn => 'int4and', + aggcombinefn => 'int4and', aggtranstype => 'int4' }, +{ aggfnoid => 'bit_or(int4)', aggtransfn => 'int4or', aggcombinefn => 'int4or', + aggtranstype => 'int4' }, +{ aggfnoid => 'bit_and(int8)', aggtransfn => 'int8and', + aggcombinefn => 'int8and', aggtranstype => 'int8' }, +{ aggfnoid => 'bit_or(int8)', aggtransfn => 'int8or', aggcombinefn => 'int8or', + aggtranstype => 'int8' }, +{ aggfnoid => 'bit_and(bit)', aggtransfn => 'bitand', aggcombinefn => 'bitand', + aggtranstype => 'bit' }, +{ aggfnoid => 'bit_or(bit)', aggtransfn => 'bitor', aggcombinefn => 'bitor', + aggtranstype => 'bit' }, + +# xml +{ aggfnoid => 'xmlagg', aggtransfn => 'xmlconcat2', aggtranstype => 'xml' }, + +# array +{ aggfnoid => 'array_agg(anynonarray)', aggtransfn => 'array_agg_transfn', + aggfinalfn => 'array_agg_finalfn', aggfinalextra => 't', + aggtranstype => 'internal' }, +{ aggfnoid => 'array_agg(anyarray)', aggtransfn => 'array_agg_array_transfn', + aggfinalfn => 'array_agg_array_finalfn', aggfinalextra => 't', + aggtranstype => 'internal' }, + +# text +{ aggfnoid => 'string_agg(text,text)', aggtransfn => 'string_agg_transfn', + aggfinalfn => 'string_agg_finalfn', aggtranstype => 'internal' }, + +# bytea +{ aggfnoid => 'string_agg(bytea,bytea)', + aggtransfn => 'bytea_string_agg_transfn', + aggfinalfn => 'bytea_string_agg_finalfn', aggtranstype => 'internal' }, + +# json +{ aggfnoid => 'json_agg', aggtransfn => 'json_agg_transfn', + aggfinalfn => 'json_agg_finalfn', aggtranstype => 'internal' }, +{ aggfnoid => 'json_object_agg', aggtransfn => 'json_object_agg_transfn', + aggfinalfn => 'json_object_agg_finalfn', aggtranstype => 'internal' }, + +# jsonb +{ aggfnoid => 'jsonb_agg', aggtransfn => 'jsonb_agg_transfn', + aggfinalfn => 'jsonb_agg_finalfn', aggtranstype => 'internal' }, +{ aggfnoid => 'jsonb_object_agg', aggtransfn => 'jsonb_object_agg_transfn', + aggfinalfn => 'jsonb_object_agg_finalfn', aggtranstype => 'internal' }, + +# ordered-set and hypothetical-set aggregates +{ aggfnoid => 'percentile_disc(float8,anyelement)', aggkind => 'o', + aggnumdirectargs => '1', aggtransfn => 'ordered_set_transition', + aggfinalfn => 'percentile_disc_final', aggfinalextra => 't', + aggfinalmodify => 's', aggmfinalmodify => 's', aggtranstype => 'internal' }, +{ aggfnoid => 'percentile_cont(float8,float8)', aggkind => 'o', + aggnumdirectargs => '1', aggtransfn => 'ordered_set_transition', + aggfinalfn => 'percentile_cont_float8_final', aggfinalmodify => 's', + aggmfinalmodify => 's', aggtranstype => 'internal' }, +{ aggfnoid => 'percentile_cont(float8,interval)', aggkind => 'o', + aggnumdirectargs => '1', aggtransfn => 'ordered_set_transition', + aggfinalfn => 'percentile_cont_interval_final', aggfinalmodify => 's', + aggmfinalmodify => 's', aggtranstype => 'internal' }, +{ aggfnoid => 'percentile_disc(_float8,anyelement)', aggkind => 'o', + aggnumdirectargs => '1', aggtransfn => 'ordered_set_transition', + aggfinalfn => 'percentile_disc_multi_final', aggfinalextra => 't', + aggfinalmodify => 's', aggmfinalmodify => 's', aggtranstype => 'internal' }, +{ aggfnoid => 'percentile_cont(_float8,float8)', aggkind => 'o', + aggnumdirectargs => '1', aggtransfn => 'ordered_set_transition', + aggfinalfn => 'percentile_cont_float8_multi_final', aggfinalmodify => 's', + aggmfinalmodify => 's', aggtranstype => 'internal' }, +{ aggfnoid => 'percentile_cont(_float8,interval)', aggkind => 'o', + aggnumdirectargs => '1', aggtransfn => 'ordered_set_transition', + aggfinalfn => 'percentile_cont_interval_multi_final', aggfinalmodify => 's', + aggmfinalmodify => 's', aggtranstype => 'internal' }, +{ aggfnoid => 'mode', aggkind => 'o', aggtransfn => 'ordered_set_transition', + aggfinalfn => 'mode_final', aggfinalextra => 't', aggfinalmodify => 's', + aggmfinalmodify => 's', aggtranstype => 'internal' }, +{ aggfnoid => 'rank(any)', aggkind => 'h', aggnumdirectargs => '1', + aggtransfn => 'ordered_set_transition_multi', aggfinalfn => 'rank_final', + aggfinalextra => 't', aggfinalmodify => 'w', aggmfinalmodify => 'w', + aggtranstype => 'internal' }, +{ aggfnoid => 'percent_rank(any)', aggkind => 'h', aggnumdirectargs => '1', + aggtransfn => 'ordered_set_transition_multi', + aggfinalfn => 'percent_rank_final', aggfinalextra => 't', + aggfinalmodify => 'w', aggmfinalmodify => 'w', aggtranstype => 'internal' }, +{ aggfnoid => 'cume_dist(any)', aggkind => 'h', aggnumdirectargs => '1', + aggtransfn => 'ordered_set_transition_multi', aggfinalfn => 'cume_dist_final', + aggfinalextra => 't', aggfinalmodify => 'w', aggmfinalmodify => 'w', + aggtranstype => 'internal' }, +{ aggfnoid => 'dense_rank(any)', aggkind => 'h', aggnumdirectargs => '1', + aggtransfn => 'ordered_set_transition_multi', + aggfinalfn => 'dense_rank_final', aggfinalextra => 't', aggfinalmodify => 'w', + aggmfinalmodify => 'w', aggtranstype => 'internal' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_aggregate.h b/contrib/libs/postgresql/src/include/catalog/pg_aggregate.h new file mode 100644 index 0000000000..457ca18444 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_aggregate.h @@ -0,0 +1,176 @@ +/*------------------------------------------------------------------------- + * + * pg_aggregate.h + * definition of the "aggregate" system catalog (pg_aggregate) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_aggregate.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_AGGREGATE_H +#define PG_AGGREGATE_H + +#include "catalog/genbki.h" +#include "catalog/pg_aggregate_d.h" + +#include "catalog/objectaddress.h" +#include "nodes/pg_list.h" + +/* ---------------------------------------------------------------- + * pg_aggregate definition. + * cpp turns this into typedef struct FormData_pg_aggregate + * ---------------------------------------------------------------- + */ +CATALOG(pg_aggregate,2600,AggregateRelationId) +{ + /* pg_proc OID of the aggregate itself */ + regproc aggfnoid BKI_LOOKUP(pg_proc); + + /* aggregate kind, see AGGKIND_ categories below */ + char aggkind BKI_DEFAULT(n); + + /* number of arguments that are "direct" arguments */ + int16 aggnumdirectargs BKI_DEFAULT(0); + + /* transition function */ + regproc aggtransfn BKI_LOOKUP(pg_proc); + + /* final function (0 if none) */ + regproc aggfinalfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); + + /* combine function (0 if none) */ + regproc aggcombinefn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); + + /* function to convert transtype to bytea (0 if none) */ + regproc aggserialfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); + + /* function to convert bytea to transtype (0 if none) */ + regproc aggdeserialfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); + + /* forward function for moving-aggregate mode (0 if none) */ + regproc aggmtransfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); + + /* inverse function for moving-aggregate mode (0 if none) */ + regproc aggminvtransfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); + + /* final function for moving-aggregate mode (0 if none) */ + regproc aggmfinalfn BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); + + /* true to pass extra dummy arguments to aggfinalfn */ + bool aggfinalextra BKI_DEFAULT(f); + + /* true to pass extra dummy arguments to aggmfinalfn */ + bool aggmfinalextra BKI_DEFAULT(f); + + /* tells whether aggfinalfn modifies transition state */ + char aggfinalmodify BKI_DEFAULT(r); + + /* tells whether aggmfinalfn modifies transition state */ + char aggmfinalmodify BKI_DEFAULT(r); + + /* associated sort operator (0 if none) */ + Oid aggsortop BKI_DEFAULT(0) BKI_LOOKUP(pg_operator); + + /* type of aggregate's transition (state) data */ + Oid aggtranstype BKI_LOOKUP(pg_type); + + /* estimated size of state data (0 for default estimate) */ + int32 aggtransspace BKI_DEFAULT(0); + + /* type of moving-aggregate state data (0 if none) */ + Oid aggmtranstype BKI_DEFAULT(0) BKI_LOOKUP(pg_type); + + /* estimated size of moving-agg state (0 for default est) */ + int32 aggmtransspace BKI_DEFAULT(0); + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + + /* initial value for transition state (can be NULL) */ + text agginitval BKI_DEFAULT(_null_); + + /* initial value for moving-agg state (can be NULL) */ + text aggminitval BKI_DEFAULT(_null_); +#endif +} FormData_pg_aggregate; + +/* ---------------- + * Form_pg_aggregate corresponds to a pointer to a tuple with + * the format of pg_aggregate relation. + * ---------------- + */ +typedef FormData_pg_aggregate *Form_pg_aggregate; + +#ifdef EXPOSE_TO_CLIENT_CODE + +/* + * Symbolic values for aggkind column. We distinguish normal aggregates + * from ordered-set aggregates (which have two sets of arguments, namely + * direct and aggregated arguments) and from hypothetical-set aggregates + * (which are a subclass of ordered-set aggregates in which the last + * direct arguments have to match up in number and datatypes with the + * aggregated arguments). + */ +#define AGGKIND_NORMAL 'n' +#define AGGKIND_ORDERED_SET 'o' +#define AGGKIND_HYPOTHETICAL 'h' + +/* Use this macro to test for "ordered-set agg including hypothetical case" */ +#define AGGKIND_IS_ORDERED_SET(kind) ((kind) != AGGKIND_NORMAL) + +/* + * Symbolic values for aggfinalmodify and aggmfinalmodify columns. + * Preferably, finalfns do not modify the transition state value at all, + * but in some cases that would cost too much performance. We distinguish + * "pure read only" and "trashes it arbitrarily" cases, as well as the + * intermediate case where multiple finalfn calls are allowed but the + * transfn cannot be applied anymore after the first finalfn call. + */ +#define AGGMODIFY_READ_ONLY 'r' +#define AGGMODIFY_SHAREABLE 's' +#define AGGMODIFY_READ_WRITE 'w' + +#endif /* EXPOSE_TO_CLIENT_CODE */ + + +extern ObjectAddress AggregateCreate(const char *aggName, + Oid aggNamespace, + bool replace, + char aggKind, + int numArgs, + int numDirectArgs, + oidvector *parameterTypes, + Datum allParameterTypes, + Datum parameterModes, + Datum parameterNames, + List *parameterDefaults, + Oid variadicArgType, + List *aggtransfnName, + List *aggfinalfnName, + List *aggcombinefnName, + List *aggserialfnName, + List *aggdeserialfnName, + List *aggmtransfnName, + List *aggminvtransfnName, + List *aggmfinalfnName, + bool finalfnExtraArgs, + bool mfinalfnExtraArgs, + char finalfnModify, + char mfinalfnModify, + List *aggsortopName, + Oid aggTransType, + int32 aggTransSpace, + Oid aggmTransType, + int32 aggmTransSpace, + const char *agginitval, + const char *aggminitval, + char proparallel); + +#endif /* PG_AGGREGATE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_aggregate_d.h b/contrib/libs/postgresql/src/include/catalog/pg_aggregate_d.h new file mode 100644 index 0000000000..0e5ce1127f --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_aggregate_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_aggregate_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_am.dat b/contrib/libs/postgresql/src/include/catalog/pg_am.dat new file mode 100644 index 0000000000..0f051277a6 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_am.dat @@ -0,0 +1,37 @@ +#---------------------------------------------------------------------- +# +# pg_am.dat +# Initial contents of the pg_am system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_am.dat +# +#---------------------------------------------------------------------- + +[ + +{ oid => '2', oid_symbol => 'HEAP_TABLE_AM_OID', + descr => 'heap table access method', + amname => 'heap', amhandler => 'heap_tableam_handler', amtype => 't' }, +{ oid => '403', oid_symbol => 'BTREE_AM_OID', + descr => 'b-tree index access method', + amname => 'btree', amhandler => 'bthandler', amtype => 'i' }, +{ oid => '405', oid_symbol => 'HASH_AM_OID', + descr => 'hash index access method', + amname => 'hash', amhandler => 'hashhandler', amtype => 'i' }, +{ oid => '783', oid_symbol => 'GIST_AM_OID', + descr => 'GiST index access method', + amname => 'gist', amhandler => 'gisthandler', amtype => 'i' }, +{ oid => '2742', oid_symbol => 'GIN_AM_OID', + descr => 'GIN index access method', + amname => 'gin', amhandler => 'ginhandler', amtype => 'i' }, +{ oid => '4000', oid_symbol => 'SPGIST_AM_OID', + descr => 'SP-GiST index access method', + amname => 'spgist', amhandler => 'spghandler', amtype => 'i' }, +{ oid => '3580', oid_symbol => 'BRIN_AM_OID', + descr => 'block range index (BRIN) access method', + amname => 'brin', amhandler => 'brinhandler', amtype => 'i' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_am.h b/contrib/libs/postgresql/src/include/catalog/pg_am.h new file mode 100644 index 0000000000..63c03c4324 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_am.h @@ -0,0 +1,60 @@ +/*------------------------------------------------------------------------- + * + * pg_am.h + * definition of the "access method" system catalog (pg_am) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_am.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_AM_H +#define PG_AM_H + +#include "catalog/genbki.h" +#include "catalog/pg_am_d.h" + +/* ---------------- + * pg_am definition. cpp turns this into + * typedef struct FormData_pg_am + * ---------------- + */ +CATALOG(pg_am,2601,AccessMethodRelationId) +{ + Oid oid; /* oid */ + + /* access method name */ + NameData amname; + + /* handler function */ + regproc amhandler BKI_LOOKUP(pg_proc); + + /* see AMTYPE_xxx constants below */ + char amtype; +} FormData_pg_am; + +/* ---------------- + * Form_pg_am corresponds to a pointer to a tuple with + * the format of pg_am relation. + * ---------------- + */ +typedef FormData_pg_am *Form_pg_am; + +#ifdef EXPOSE_TO_CLIENT_CODE + +/* + * Allowed values for amtype + */ +#define AMTYPE_INDEX 'i' /* index access method */ +#define AMTYPE_TABLE 't' /* table access method */ + +#endif /* EXPOSE_TO_CLIENT_CODE */ + +#endif /* PG_AM_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_am_d.h b/contrib/libs/postgresql/src/include/catalog/pg_am_d.h new file mode 100644 index 0000000000..607bfd8cee --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_am_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_am_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_amop.dat b/contrib/libs/postgresql/src/include/catalog/pg_amop.dat new file mode 100644 index 0000000000..1dfb6fd373 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_amop.dat @@ -0,0 +1,2463 @@ +#---------------------------------------------------------------------- +# +# pg_amop.dat +# Initial contents of the pg_amop system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_amop.dat +# +#---------------------------------------------------------------------- + +[ + +# btree integer_ops + +# default operators int2 +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int2,int2)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int2,int2)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int2,int2)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int2,int2)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int2,int2)', + amopmethod => 'btree' }, + +# crosstype operators int24 +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int2,int4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int2,int4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int2,int4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int2,int4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int2,int4)', + amopmethod => 'btree' }, + +# crosstype operators int28 +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int2,int8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int2,int8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int2,int8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int2,int8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int2,int8)', + amopmethod => 'btree' }, + +# default operators int4 +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int4,int4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int4,int4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int4,int4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int4,int4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int4,int4)', + amopmethod => 'btree' }, + +# crosstype operators int42 +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int4,int2)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int4,int2)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int4,int2)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int4,int2)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int4,int2)', + amopmethod => 'btree' }, + +# crosstype operators int48 +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int4,int8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int4,int8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int4,int8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int4,int8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int4,int8)', + amopmethod => 'btree' }, + +# default operators int8 +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int8,int8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int8,int8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int8,int8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int8,int8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int8,int8)', + amopmethod => 'btree' }, + +# crosstype operators int82 +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int8,int2)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int8,int2)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int8,int2)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int8,int2)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int8,int2)', + amopmethod => 'btree' }, + +# crosstype operators int84 +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int8,int4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int8,int4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int8,int4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int8,int4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int8,int4)', + amopmethod => 'btree' }, + +# btree oid_ops + +{ amopfamily => 'btree/oid_ops', amoplefttype => 'oid', amoprighttype => 'oid', + amopstrategy => '1', amopopr => '<(oid,oid)', amopmethod => 'btree' }, +{ amopfamily => 'btree/oid_ops', amoplefttype => 'oid', amoprighttype => 'oid', + amopstrategy => '2', amopopr => '<=(oid,oid)', amopmethod => 'btree' }, +{ amopfamily => 'btree/oid_ops', amoplefttype => 'oid', amoprighttype => 'oid', + amopstrategy => '3', amopopr => '=(oid,oid)', amopmethod => 'btree' }, +{ amopfamily => 'btree/oid_ops', amoplefttype => 'oid', amoprighttype => 'oid', + amopstrategy => '4', amopopr => '>=(oid,oid)', amopmethod => 'btree' }, +{ amopfamily => 'btree/oid_ops', amoplefttype => 'oid', amoprighttype => 'oid', + amopstrategy => '5', amopopr => '>(oid,oid)', amopmethod => 'btree' }, + +# btree xid8_ops + +{ amopfamily => 'btree/xid8_ops', amoplefttype => 'xid8', + amoprighttype => 'xid8', amopstrategy => '1', amopopr => '<(xid8,xid8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/xid8_ops', amoplefttype => 'xid8', + amoprighttype => 'xid8', amopstrategy => '2', amopopr => '<=(xid8,xid8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/xid8_ops', amoplefttype => 'xid8', + amoprighttype => 'xid8', amopstrategy => '3', amopopr => '=(xid8,xid8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/xid8_ops', amoplefttype => 'xid8', + amoprighttype => 'xid8', amopstrategy => '4', amopopr => '>=(xid8,xid8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/xid8_ops', amoplefttype => 'xid8', + amoprighttype => 'xid8', amopstrategy => '5', amopopr => '>(xid8,xid8)', + amopmethod => 'btree' }, + +# btree tid_ops + +{ amopfamily => 'btree/tid_ops', amoplefttype => 'tid', amoprighttype => 'tid', + amopstrategy => '1', amopopr => '<(tid,tid)', amopmethod => 'btree' }, +{ amopfamily => 'btree/tid_ops', amoplefttype => 'tid', amoprighttype => 'tid', + amopstrategy => '2', amopopr => '<=(tid,tid)', amopmethod => 'btree' }, +{ amopfamily => 'btree/tid_ops', amoplefttype => 'tid', amoprighttype => 'tid', + amopstrategy => '3', amopopr => '=(tid,tid)', amopmethod => 'btree' }, +{ amopfamily => 'btree/tid_ops', amoplefttype => 'tid', amoprighttype => 'tid', + amopstrategy => '4', amopopr => '>=(tid,tid)', amopmethod => 'btree' }, +{ amopfamily => 'btree/tid_ops', amoplefttype => 'tid', amoprighttype => 'tid', + amopstrategy => '5', amopopr => '>(tid,tid)', amopmethod => 'btree' }, + +# btree oidvector_ops + +{ amopfamily => 'btree/oidvector_ops', amoplefttype => 'oidvector', + amoprighttype => 'oidvector', amopstrategy => '1', + amopopr => '<(oidvector,oidvector)', amopmethod => 'btree' }, +{ amopfamily => 'btree/oidvector_ops', amoplefttype => 'oidvector', + amoprighttype => 'oidvector', amopstrategy => '2', + amopopr => '<=(oidvector,oidvector)', amopmethod => 'btree' }, +{ amopfamily => 'btree/oidvector_ops', amoplefttype => 'oidvector', + amoprighttype => 'oidvector', amopstrategy => '3', + amopopr => '=(oidvector,oidvector)', amopmethod => 'btree' }, +{ amopfamily => 'btree/oidvector_ops', amoplefttype => 'oidvector', + amoprighttype => 'oidvector', amopstrategy => '4', + amopopr => '>=(oidvector,oidvector)', amopmethod => 'btree' }, +{ amopfamily => 'btree/oidvector_ops', amoplefttype => 'oidvector', + amoprighttype => 'oidvector', amopstrategy => '5', + amopopr => '>(oidvector,oidvector)', amopmethod => 'btree' }, + +# btree float_ops + +# default operators float4 +{ amopfamily => 'btree/float_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '1', amopopr => '<(float4,float4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '2', + amopopr => '<=(float4,float4)', amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '3', amopopr => '=(float4,float4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '4', + amopopr => '>=(float4,float4)', amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '5', amopopr => '>(float4,float4)', + amopmethod => 'btree' }, + +# crosstype operators float48 +{ amopfamily => 'btree/float_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '1', amopopr => '<(float4,float8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '2', + amopopr => '<=(float4,float8)', amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '3', amopopr => '=(float4,float8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '4', + amopopr => '>=(float4,float8)', amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '5', amopopr => '>(float4,float8)', + amopmethod => 'btree' }, + +# default operators float8 +{ amopfamily => 'btree/float_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '1', amopopr => '<(float8,float8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '2', + amopopr => '<=(float8,float8)', amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '3', amopopr => '=(float8,float8)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '4', + amopopr => '>=(float8,float8)', amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '5', amopopr => '>(float8,float8)', + amopmethod => 'btree' }, + +# crosstype operators float84 +{ amopfamily => 'btree/float_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '1', amopopr => '<(float8,float4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '2', + amopopr => '<=(float8,float4)', amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '3', amopopr => '=(float8,float4)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '4', + amopopr => '>=(float8,float4)', amopmethod => 'btree' }, +{ amopfamily => 'btree/float_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '5', amopopr => '>(float8,float4)', + amopmethod => 'btree' }, + +# btree char_ops + +{ amopfamily => 'btree/char_ops', amoplefttype => 'char', + amoprighttype => 'char', amopstrategy => '1', amopopr => '<(char,char)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/char_ops', amoplefttype => 'char', + amoprighttype => 'char', amopstrategy => '2', amopopr => '<=(char,char)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/char_ops', amoplefttype => 'char', + amoprighttype => 'char', amopstrategy => '3', amopopr => '=(char,char)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/char_ops', amoplefttype => 'char', + amoprighttype => 'char', amopstrategy => '4', amopopr => '>=(char,char)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/char_ops', amoplefttype => 'char', + amoprighttype => 'char', amopstrategy => '5', amopopr => '>(char,char)', + amopmethod => 'btree' }, + +# btree text_ops + +{ amopfamily => 'btree/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '1', amopopr => '<(text,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '2', amopopr => '<=(text,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '3', amopopr => '=(text,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '4', amopopr => '>=(text,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '5', amopopr => '>(text,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'name', + amoprighttype => 'name', amopstrategy => '1', amopopr => '<(name,name)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'name', + amoprighttype => 'name', amopstrategy => '2', amopopr => '<=(name,name)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'name', + amoprighttype => 'name', amopstrategy => '3', amopopr => '=(name,name)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'name', + amoprighttype => 'name', amopstrategy => '4', amopopr => '>=(name,name)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'name', + amoprighttype => 'name', amopstrategy => '5', amopopr => '>(name,name)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'name', + amoprighttype => 'text', amopstrategy => '1', amopopr => '<(name,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'name', + amoprighttype => 'text', amopstrategy => '2', amopopr => '<=(name,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'name', + amoprighttype => 'text', amopstrategy => '3', amopopr => '=(name,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'name', + amoprighttype => 'text', amopstrategy => '4', amopopr => '>=(name,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'name', + amoprighttype => 'text', amopstrategy => '5', amopopr => '>(name,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'text', + amoprighttype => 'name', amopstrategy => '1', amopopr => '<(text,name)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'text', + amoprighttype => 'name', amopstrategy => '2', amopopr => '<=(text,name)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'text', + amoprighttype => 'name', amopstrategy => '3', amopopr => '=(text,name)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'text', + amoprighttype => 'name', amopstrategy => '4', amopopr => '>=(text,name)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_ops', amoplefttype => 'text', + amoprighttype => 'name', amopstrategy => '5', amopopr => '>(text,name)', + amopmethod => 'btree' }, + +# btree bpchar_ops + +{ amopfamily => 'btree/bpchar_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '1', amopopr => '<(bpchar,bpchar)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/bpchar_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '2', + amopopr => '<=(bpchar,bpchar)', amopmethod => 'btree' }, +{ amopfamily => 'btree/bpchar_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '3', amopopr => '=(bpchar,bpchar)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/bpchar_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '4', + amopopr => '>=(bpchar,bpchar)', amopmethod => 'btree' }, +{ amopfamily => 'btree/bpchar_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '5', amopopr => '>(bpchar,bpchar)', + amopmethod => 'btree' }, + +# btree bytea_ops + +{ amopfamily => 'btree/bytea_ops', amoplefttype => 'bytea', + amoprighttype => 'bytea', amopstrategy => '1', amopopr => '<(bytea,bytea)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/bytea_ops', amoplefttype => 'bytea', + amoprighttype => 'bytea', amopstrategy => '2', amopopr => '<=(bytea,bytea)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/bytea_ops', amoplefttype => 'bytea', + amoprighttype => 'bytea', amopstrategy => '3', amopopr => '=(bytea,bytea)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/bytea_ops', amoplefttype => 'bytea', + amoprighttype => 'bytea', amopstrategy => '4', amopopr => '>=(bytea,bytea)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/bytea_ops', amoplefttype => 'bytea', + amoprighttype => 'bytea', amopstrategy => '5', amopopr => '>(bytea,bytea)', + amopmethod => 'btree' }, + +# btree datetime_ops + +# default operators date +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '1', amopopr => '<(date,date)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '2', amopopr => '<=(date,date)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '3', amopopr => '=(date,date)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '4', amopopr => '>=(date,date)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '5', amopopr => '>(date,date)', + amopmethod => 'btree' }, + +# crosstype operators vs timestamp +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '1', + amopopr => '<(date,timestamp)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '2', + amopopr => '<=(date,timestamp)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '3', + amopopr => '=(date,timestamp)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '4', + amopopr => '>=(date,timestamp)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '5', + amopopr => '>(date,timestamp)', amopmethod => 'btree' }, + +# crosstype operators vs timestamptz +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '1', + amopopr => '<(date,timestamptz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '2', + amopopr => '<=(date,timestamptz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '3', + amopopr => '=(date,timestamptz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '4', + amopopr => '>=(date,timestamptz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '5', + amopopr => '>(date,timestamptz)', amopmethod => 'btree' }, + +# default operators timestamp +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '1', + amopopr => '<(timestamp,timestamp)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '2', + amopopr => '<=(timestamp,timestamp)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '3', + amopopr => '=(timestamp,timestamp)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '4', + amopopr => '>=(timestamp,timestamp)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '5', + amopopr => '>(timestamp,timestamp)', amopmethod => 'btree' }, + +# crosstype operators vs date +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '1', amopopr => '<(timestamp,date)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '2', amopopr => '<=(timestamp,date)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '3', amopopr => '=(timestamp,date)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '4', amopopr => '>=(timestamp,date)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '5', amopopr => '>(timestamp,date)', + amopmethod => 'btree' }, + +# crosstype operators vs timestamptz +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '1', + amopopr => '<(timestamp,timestamptz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '2', + amopopr => '<=(timestamp,timestamptz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '3', + amopopr => '=(timestamp,timestamptz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '4', + amopopr => '>=(timestamp,timestamptz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '5', + amopopr => '>(timestamp,timestamptz)', amopmethod => 'btree' }, + +# default operators timestamptz +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '1', + amopopr => '<(timestamptz,timestamptz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '2', + amopopr => '<=(timestamptz,timestamptz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '3', + amopopr => '=(timestamptz,timestamptz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '4', + amopopr => '>=(timestamptz,timestamptz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '5', + amopopr => '>(timestamptz,timestamptz)', amopmethod => 'btree' }, + +# crosstype operators vs date +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '1', + amopopr => '<(timestamptz,date)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '2', + amopopr => '<=(timestamptz,date)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '3', + amopopr => '=(timestamptz,date)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '4', + amopopr => '>=(timestamptz,date)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '5', + amopopr => '>(timestamptz,date)', amopmethod => 'btree' }, + +# crosstype operators vs timestamp +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '1', + amopopr => '<(timestamptz,timestamp)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '2', + amopopr => '<=(timestamptz,timestamp)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '3', + amopopr => '=(timestamptz,timestamp)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '4', + amopopr => '>=(timestamptz,timestamp)', amopmethod => 'btree' }, +{ amopfamily => 'btree/datetime_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '5', + amopopr => '>(timestamptz,timestamp)', amopmethod => 'btree' }, + +# btree time_ops + +{ amopfamily => 'btree/time_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '1', amopopr => '<(time,time)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/time_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '2', amopopr => '<=(time,time)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/time_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '3', amopopr => '=(time,time)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/time_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '4', amopopr => '>=(time,time)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/time_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '5', amopopr => '>(time,time)', + amopmethod => 'btree' }, + +# btree timetz_ops + +{ amopfamily => 'btree/timetz_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '1', amopopr => '<(timetz,timetz)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/timetz_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '2', + amopopr => '<=(timetz,timetz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/timetz_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '3', amopopr => '=(timetz,timetz)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/timetz_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '4', + amopopr => '>=(timetz,timetz)', amopmethod => 'btree' }, +{ amopfamily => 'btree/timetz_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '5', amopopr => '>(timetz,timetz)', + amopmethod => 'btree' }, + +# btree interval_ops + +{ amopfamily => 'btree/interval_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '1', + amopopr => '<(interval,interval)', amopmethod => 'btree' }, +{ amopfamily => 'btree/interval_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '2', + amopopr => '<=(interval,interval)', amopmethod => 'btree' }, +{ amopfamily => 'btree/interval_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '3', + amopopr => '=(interval,interval)', amopmethod => 'btree' }, +{ amopfamily => 'btree/interval_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '4', + amopopr => '>=(interval,interval)', amopmethod => 'btree' }, +{ amopfamily => 'btree/interval_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '5', + amopopr => '>(interval,interval)', amopmethod => 'btree' }, + +# btree macaddr + +{ amopfamily => 'btree/macaddr_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '1', + amopopr => '<(macaddr,macaddr)', amopmethod => 'btree' }, +{ amopfamily => 'btree/macaddr_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '2', + amopopr => '<=(macaddr,macaddr)', amopmethod => 'btree' }, +{ amopfamily => 'btree/macaddr_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '3', + amopopr => '=(macaddr,macaddr)', amopmethod => 'btree' }, +{ amopfamily => 'btree/macaddr_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '4', + amopopr => '>=(macaddr,macaddr)', amopmethod => 'btree' }, +{ amopfamily => 'btree/macaddr_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '5', + amopopr => '>(macaddr,macaddr)', amopmethod => 'btree' }, + +# btree macaddr8 + +{ amopfamily => 'btree/macaddr8_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '1', + amopopr => '<(macaddr8,macaddr8)', amopmethod => 'btree' }, +{ amopfamily => 'btree/macaddr8_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '2', + amopopr => '<=(macaddr8,macaddr8)', amopmethod => 'btree' }, +{ amopfamily => 'btree/macaddr8_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '3', + amopopr => '=(macaddr8,macaddr8)', amopmethod => 'btree' }, +{ amopfamily => 'btree/macaddr8_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '4', + amopopr => '>=(macaddr8,macaddr8)', amopmethod => 'btree' }, +{ amopfamily => 'btree/macaddr8_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '5', + amopopr => '>(macaddr8,macaddr8)', amopmethod => 'btree' }, + +# btree network + +{ amopfamily => 'btree/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '1', amopopr => '<(inet,inet)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '2', amopopr => '<=(inet,inet)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '3', amopopr => '=(inet,inet)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '4', amopopr => '>=(inet,inet)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '5', amopopr => '>(inet,inet)', + amopmethod => 'btree' }, + +# btree numeric + +{ amopfamily => 'btree/numeric_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '1', + amopopr => '<(numeric,numeric)', amopmethod => 'btree' }, +{ amopfamily => 'btree/numeric_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '2', + amopopr => '<=(numeric,numeric)', amopmethod => 'btree' }, +{ amopfamily => 'btree/numeric_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '3', + amopopr => '=(numeric,numeric)', amopmethod => 'btree' }, +{ amopfamily => 'btree/numeric_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '4', + amopopr => '>=(numeric,numeric)', amopmethod => 'btree' }, +{ amopfamily => 'btree/numeric_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '5', + amopopr => '>(numeric,numeric)', amopmethod => 'btree' }, + +# btree bool + +{ amopfamily => 'btree/bool_ops', amoplefttype => 'bool', + amoprighttype => 'bool', amopstrategy => '1', amopopr => '<(bool,bool)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/bool_ops', amoplefttype => 'bool', + amoprighttype => 'bool', amopstrategy => '2', amopopr => '<=(bool,bool)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/bool_ops', amoplefttype => 'bool', + amoprighttype => 'bool', amopstrategy => '3', amopopr => '=(bool,bool)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/bool_ops', amoplefttype => 'bool', + amoprighttype => 'bool', amopstrategy => '4', amopopr => '>=(bool,bool)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/bool_ops', amoplefttype => 'bool', + amoprighttype => 'bool', amopstrategy => '5', amopopr => '>(bool,bool)', + amopmethod => 'btree' }, + +# btree bit + +{ amopfamily => 'btree/bit_ops', amoplefttype => 'bit', amoprighttype => 'bit', + amopstrategy => '1', amopopr => '<(bit,bit)', amopmethod => 'btree' }, +{ amopfamily => 'btree/bit_ops', amoplefttype => 'bit', amoprighttype => 'bit', + amopstrategy => '2', amopopr => '<=(bit,bit)', amopmethod => 'btree' }, +{ amopfamily => 'btree/bit_ops', amoplefttype => 'bit', amoprighttype => 'bit', + amopstrategy => '3', amopopr => '=(bit,bit)', amopmethod => 'btree' }, +{ amopfamily => 'btree/bit_ops', amoplefttype => 'bit', amoprighttype => 'bit', + amopstrategy => '4', amopopr => '>=(bit,bit)', amopmethod => 'btree' }, +{ amopfamily => 'btree/bit_ops', amoplefttype => 'bit', amoprighttype => 'bit', + amopstrategy => '5', amopopr => '>(bit,bit)', amopmethod => 'btree' }, + +# btree varbit + +{ amopfamily => 'btree/varbit_ops', amoplefttype => 'varbit', + amoprighttype => 'varbit', amopstrategy => '1', amopopr => '<(varbit,varbit)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/varbit_ops', amoplefttype => 'varbit', + amoprighttype => 'varbit', amopstrategy => '2', + amopopr => '<=(varbit,varbit)', amopmethod => 'btree' }, +{ amopfamily => 'btree/varbit_ops', amoplefttype => 'varbit', + amoprighttype => 'varbit', amopstrategy => '3', amopopr => '=(varbit,varbit)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/varbit_ops', amoplefttype => 'varbit', + amoprighttype => 'varbit', amopstrategy => '4', + amopopr => '>=(varbit,varbit)', amopmethod => 'btree' }, +{ amopfamily => 'btree/varbit_ops', amoplefttype => 'varbit', + amoprighttype => 'varbit', amopstrategy => '5', amopopr => '>(varbit,varbit)', + amopmethod => 'btree' }, + +# btree text pattern + +{ amopfamily => 'btree/text_pattern_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '1', amopopr => '~<~(text,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_pattern_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '2', amopopr => '~<=~(text,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_pattern_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '3', amopopr => '=(text,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_pattern_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '4', amopopr => '~>=~(text,text)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/text_pattern_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '5', amopopr => '~>~(text,text)', + amopmethod => 'btree' }, + +# btree bpchar pattern + +{ amopfamily => 'btree/bpchar_pattern_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '1', + amopopr => '~<~(bpchar,bpchar)', amopmethod => 'btree' }, +{ amopfamily => 'btree/bpchar_pattern_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '2', + amopopr => '~<=~(bpchar,bpchar)', amopmethod => 'btree' }, +{ amopfamily => 'btree/bpchar_pattern_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '3', amopopr => '=(bpchar,bpchar)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/bpchar_pattern_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '4', + amopopr => '~>=~(bpchar,bpchar)', amopmethod => 'btree' }, +{ amopfamily => 'btree/bpchar_pattern_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '5', + amopopr => '~>~(bpchar,bpchar)', amopmethod => 'btree' }, + +# btree money_ops + +{ amopfamily => 'btree/money_ops', amoplefttype => 'money', + amoprighttype => 'money', amopstrategy => '1', amopopr => '<(money,money)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/money_ops', amoplefttype => 'money', + amoprighttype => 'money', amopstrategy => '2', amopopr => '<=(money,money)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/money_ops', amoplefttype => 'money', + amoprighttype => 'money', amopstrategy => '3', amopopr => '=(money,money)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/money_ops', amoplefttype => 'money', + amoprighttype => 'money', amopstrategy => '4', amopopr => '>=(money,money)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/money_ops', amoplefttype => 'money', + amoprighttype => 'money', amopstrategy => '5', amopopr => '>(money,money)', + amopmethod => 'btree' }, + +# btree array_ops + +{ amopfamily => 'btree/array_ops', amoplefttype => 'anyarray', + amoprighttype => 'anyarray', amopstrategy => '1', + amopopr => '<(anyarray,anyarray)', amopmethod => 'btree' }, +{ amopfamily => 'btree/array_ops', amoplefttype => 'anyarray', + amoprighttype => 'anyarray', amopstrategy => '2', + amopopr => '<=(anyarray,anyarray)', amopmethod => 'btree' }, +{ amopfamily => 'btree/array_ops', amoplefttype => 'anyarray', + amoprighttype => 'anyarray', amopstrategy => '3', + amopopr => '=(anyarray,anyarray)', amopmethod => 'btree' }, +{ amopfamily => 'btree/array_ops', amoplefttype => 'anyarray', + amoprighttype => 'anyarray', amopstrategy => '4', + amopopr => '>=(anyarray,anyarray)', amopmethod => 'btree' }, +{ amopfamily => 'btree/array_ops', amoplefttype => 'anyarray', + amoprighttype => 'anyarray', amopstrategy => '5', + amopopr => '>(anyarray,anyarray)', amopmethod => 'btree' }, + +# btree record_ops + +{ amopfamily => 'btree/record_ops', amoplefttype => 'record', + amoprighttype => 'record', amopstrategy => '1', amopopr => '<(record,record)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/record_ops', amoplefttype => 'record', + amoprighttype => 'record', amopstrategy => '2', + amopopr => '<=(record,record)', amopmethod => 'btree' }, +{ amopfamily => 'btree/record_ops', amoplefttype => 'record', + amoprighttype => 'record', amopstrategy => '3', amopopr => '=(record,record)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/record_ops', amoplefttype => 'record', + amoprighttype => 'record', amopstrategy => '4', + amopopr => '>=(record,record)', amopmethod => 'btree' }, +{ amopfamily => 'btree/record_ops', amoplefttype => 'record', + amoprighttype => 'record', amopstrategy => '5', amopopr => '>(record,record)', + amopmethod => 'btree' }, + +# btree record_image_ops + +{ amopfamily => 'btree/record_image_ops', amoplefttype => 'record', + amoprighttype => 'record', amopstrategy => '1', + amopopr => '*<(record,record)', amopmethod => 'btree' }, +{ amopfamily => 'btree/record_image_ops', amoplefttype => 'record', + amoprighttype => 'record', amopstrategy => '2', + amopopr => '*<=(record,record)', amopmethod => 'btree' }, +{ amopfamily => 'btree/record_image_ops', amoplefttype => 'record', + amoprighttype => 'record', amopstrategy => '3', + amopopr => '*=(record,record)', amopmethod => 'btree' }, +{ amopfamily => 'btree/record_image_ops', amoplefttype => 'record', + amoprighttype => 'record', amopstrategy => '4', + amopopr => '*>=(record,record)', amopmethod => 'btree' }, +{ amopfamily => 'btree/record_image_ops', amoplefttype => 'record', + amoprighttype => 'record', amopstrategy => '5', + amopopr => '*>(record,record)', amopmethod => 'btree' }, + +# btree uuid_ops + +{ amopfamily => 'btree/uuid_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '1', amopopr => '<(uuid,uuid)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/uuid_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '2', amopopr => '<=(uuid,uuid)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/uuid_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '3', amopopr => '=(uuid,uuid)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/uuid_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '4', amopopr => '>=(uuid,uuid)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/uuid_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '5', amopopr => '>(uuid,uuid)', + amopmethod => 'btree' }, + +# btree pg_lsn_ops + +{ amopfamily => 'btree/pg_lsn_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '1', amopopr => '<(pg_lsn,pg_lsn)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/pg_lsn_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '2', + amopopr => '<=(pg_lsn,pg_lsn)', amopmethod => 'btree' }, +{ amopfamily => 'btree/pg_lsn_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '3', amopopr => '=(pg_lsn,pg_lsn)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/pg_lsn_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '4', + amopopr => '>=(pg_lsn,pg_lsn)', amopmethod => 'btree' }, +{ amopfamily => 'btree/pg_lsn_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '5', amopopr => '>(pg_lsn,pg_lsn)', + amopmethod => 'btree' }, + +# hash index_ops + +# bpchar_ops +{ amopfamily => 'hash/bpchar_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '1', amopopr => '=(bpchar,bpchar)', + amopmethod => 'hash' }, + +# char_ops +{ amopfamily => 'hash/char_ops', amoplefttype => 'char', + amoprighttype => 'char', amopstrategy => '1', amopopr => '=(char,char)', + amopmethod => 'hash' }, + +# date_ops +{ amopfamily => 'hash/date_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '1', amopopr => '=(date,date)', + amopmethod => 'hash' }, + +# float_ops +{ amopfamily => 'hash/float_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '1', amopopr => '=(float4,float4)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/float_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '1', amopopr => '=(float8,float8)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/float_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '1', amopopr => '=(float4,float8)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/float_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '1', amopopr => '=(float8,float4)', + amopmethod => 'hash' }, + +# network_ops +{ amopfamily => 'hash/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '1', amopopr => '=(inet,inet)', + amopmethod => 'hash' }, + +# integer_ops +{ amopfamily => 'hash/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '1', amopopr => '=(int2,int2)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '1', amopopr => '=(int4,int4)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '1', amopopr => '=(int8,int8)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '1', amopopr => '=(int2,int4)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/integer_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '1', amopopr => '=(int2,int8)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '1', amopopr => '=(int4,int2)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/integer_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '1', amopopr => '=(int4,int8)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '1', amopopr => '=(int8,int2)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/integer_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '1', amopopr => '=(int8,int4)', + amopmethod => 'hash' }, + +# interval_ops +{ amopfamily => 'hash/interval_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '1', + amopopr => '=(interval,interval)', amopmethod => 'hash' }, + +# macaddr_ops +{ amopfamily => 'hash/macaddr_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '1', + amopopr => '=(macaddr,macaddr)', amopmethod => 'hash' }, + +# macaddr8_ops +{ amopfamily => 'hash/macaddr8_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '1', + amopopr => '=(macaddr8,macaddr8)', amopmethod => 'hash' }, + +# oid_ops +{ amopfamily => 'hash/oid_ops', amoplefttype => 'oid', amoprighttype => 'oid', + amopstrategy => '1', amopopr => '=(oid,oid)', amopmethod => 'hash' }, + +# oidvector_ops +{ amopfamily => 'hash/oidvector_ops', amoplefttype => 'oidvector', + amoprighttype => 'oidvector', amopstrategy => '1', + amopopr => '=(oidvector,oidvector)', amopmethod => 'hash' }, + +# text_ops +{ amopfamily => 'hash/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '1', amopopr => '=(text,text)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/text_ops', amoplefttype => 'name', + amoprighttype => 'name', amopstrategy => '1', amopopr => '=(name,name)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/text_ops', amoplefttype => 'name', + amoprighttype => 'text', amopstrategy => '1', amopopr => '=(name,text)', + amopmethod => 'hash' }, +{ amopfamily => 'hash/text_ops', amoplefttype => 'text', + amoprighttype => 'name', amopstrategy => '1', amopopr => '=(text,name)', + amopmethod => 'hash' }, + +# time_ops +{ amopfamily => 'hash/time_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '1', amopopr => '=(time,time)', + amopmethod => 'hash' }, + +# timestamptz_ops +{ amopfamily => 'hash/timestamptz_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '1', + amopopr => '=(timestamptz,timestamptz)', amopmethod => 'hash' }, + +# timetz_ops +{ amopfamily => 'hash/timetz_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '1', amopopr => '=(timetz,timetz)', + amopmethod => 'hash' }, + +# timestamp_ops +{ amopfamily => 'hash/timestamp_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '1', + amopopr => '=(timestamp,timestamp)', amopmethod => 'hash' }, + +# bool_ops +{ amopfamily => 'hash/bool_ops', amoplefttype => 'bool', + amoprighttype => 'bool', amopstrategy => '1', amopopr => '=(bool,bool)', + amopmethod => 'hash' }, + +# bytea_ops +{ amopfamily => 'hash/bytea_ops', amoplefttype => 'bytea', + amoprighttype => 'bytea', amopstrategy => '1', amopopr => '=(bytea,bytea)', + amopmethod => 'hash' }, + +# xid_ops +{ amopfamily => 'hash/xid_ops', amoplefttype => 'xid', amoprighttype => 'xid', + amopstrategy => '1', amopopr => '=(xid,xid)', amopmethod => 'hash' }, + +# xid8_ops +{ amopfamily => 'hash/xid8_ops', amoplefttype => 'xid8', + amoprighttype => 'xid8', amopstrategy => '1', amopopr => '=(xid8,xid8)', + amopmethod => 'hash' }, + +# cid_ops +{ amopfamily => 'hash/cid_ops', amoplefttype => 'cid', amoprighttype => 'cid', + amopstrategy => '1', amopopr => '=(cid,cid)', amopmethod => 'hash' }, + +# tid_ops +{ amopfamily => 'hash/tid_ops', amoplefttype => 'tid', amoprighttype => 'tid', + amopstrategy => '1', amopopr => '=(tid,tid)', amopmethod => 'hash' }, + +# text_pattern_ops +{ amopfamily => 'hash/text_pattern_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '1', amopopr => '=(text,text)', + amopmethod => 'hash' }, + +# bpchar_pattern_ops +{ amopfamily => 'hash/bpchar_pattern_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '1', amopopr => '=(bpchar,bpchar)', + amopmethod => 'hash' }, + +# aclitem_ops +{ amopfamily => 'hash/aclitem_ops', amoplefttype => 'aclitem', + amoprighttype => 'aclitem', amopstrategy => '1', + amopopr => '=(aclitem,aclitem)', amopmethod => 'hash' }, + +# uuid_ops +{ amopfamily => 'hash/uuid_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '1', amopopr => '=(uuid,uuid)', + amopmethod => 'hash' }, + +# pg_lsn_ops +{ amopfamily => 'hash/pg_lsn_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '1', amopopr => '=(pg_lsn,pg_lsn)', + amopmethod => 'hash' }, + +# numeric_ops +{ amopfamily => 'hash/numeric_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '1', + amopopr => '=(numeric,numeric)', amopmethod => 'hash' }, + +# array_ops +{ amopfamily => 'hash/array_ops', amoplefttype => 'anyarray', + amoprighttype => 'anyarray', amopstrategy => '1', + amopopr => '=(anyarray,anyarray)', amopmethod => 'hash' }, + +# gist box_ops +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '1', amopopr => '<<(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '2', amopopr => '&<(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '3', amopopr => '&&(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '4', amopopr => '&>(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '5', amopopr => '>>(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '6', amopopr => '~=(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '7', amopopr => '@>(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '8', amopopr => '<@(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '9', amopopr => '&<|(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '10', amopopr => '<<|(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '11', amopopr => '|>>(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '12', amopopr => '|&>(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '13', amopopr => '~(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '14', amopopr => '@(box,box)', amopmethod => 'gist' }, +{ amopfamily => 'gist/box_ops', amoplefttype => 'box', amoprighttype => 'point', + amopstrategy => '15', amoppurpose => 'o', amopopr => '<->(box,point)', + amopmethod => 'gist', amopsortfamily => 'btree/float_ops' }, + +# gist point_ops +{ amopfamily => 'gist/point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '11', amopopr => '>^(point,point)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '1', amopopr => '<<(point,point)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '5', amopopr => '>>(point,point)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '10', amopopr => '<^(point,point)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '6', amopopr => '~=(point,point)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o', + amopopr => '<->(point,point)', amopmethod => 'gist', + amopsortfamily => 'btree/float_ops' }, +{ amopfamily => 'gist/point_ops', amoplefttype => 'point', + amoprighttype => 'box', amopstrategy => '28', amopopr => '<@(point,box)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/point_ops', amoplefttype => 'point', + amoprighttype => 'polygon', amopstrategy => '48', + amopopr => '<@(point,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/point_ops', amoplefttype => 'point', + amoprighttype => 'circle', amopstrategy => '68', + amopopr => '<@(point,circle)', amopmethod => 'gist' }, + +# gist poly_ops (supports polygons) +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '1', + amopopr => '<<(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '2', + amopopr => '&<(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '3', + amopopr => '&&(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '4', + amopopr => '&>(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '5', + amopopr => '>>(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '6', + amopopr => '~=(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '7', + amopopr => '@>(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '8', + amopopr => '<@(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '9', + amopopr => '&<|(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '10', + amopopr => '<<|(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '11', + amopopr => '|>>(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '12', + amopopr => '|&>(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '13', + amopopr => '~(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '14', + amopopr => '@(polygon,polygon)', amopmethod => 'gist' }, +{ amopfamily => 'gist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o', + amopopr => '<->(polygon,point)', amopmethod => 'gist', + amopsortfamily => 'btree/float_ops' }, + +# gist circle_ops +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '1', + amopopr => '<<(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '2', + amopopr => '&<(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '3', + amopopr => '&&(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '4', + amopopr => '&>(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '5', + amopopr => '>>(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '6', + amopopr => '~=(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '7', + amopopr => '@>(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '8', + amopopr => '<@(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '9', + amopopr => '&<|(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '10', + amopopr => '<<|(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '11', + amopopr => '|>>(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '12', + amopopr => '|&>(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '13', + amopopr => '~(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'circle', amopstrategy => '14', + amopopr => '@(circle,circle)', amopmethod => 'gist' }, +{ amopfamily => 'gist/circle_ops', amoplefttype => 'circle', + amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o', + amopopr => '<->(circle,point)', amopmethod => 'gist', + amopsortfamily => 'btree/float_ops' }, + +# gin array_ops +{ amopfamily => 'gin/array_ops', amoplefttype => 'anyarray', + amoprighttype => 'anyarray', amopstrategy => '1', + amopopr => '&&(anyarray,anyarray)', amopmethod => 'gin' }, +{ amopfamily => 'gin/array_ops', amoplefttype => 'anyarray', + amoprighttype => 'anyarray', amopstrategy => '2', + amopopr => '@>(anyarray,anyarray)', amopmethod => 'gin' }, +{ amopfamily => 'gin/array_ops', amoplefttype => 'anyarray', + amoprighttype => 'anyarray', amopstrategy => '3', + amopopr => '<@(anyarray,anyarray)', amopmethod => 'gin' }, +{ amopfamily => 'gin/array_ops', amoplefttype => 'anyarray', + amoprighttype => 'anyarray', amopstrategy => '4', + amopopr => '=(anyarray,anyarray)', amopmethod => 'gin' }, + +# btree enum_ops +{ amopfamily => 'btree/enum_ops', amoplefttype => 'anyenum', + amoprighttype => 'anyenum', amopstrategy => '1', + amopopr => '<(anyenum,anyenum)', amopmethod => 'btree' }, +{ amopfamily => 'btree/enum_ops', amoplefttype => 'anyenum', + amoprighttype => 'anyenum', amopstrategy => '2', + amopopr => '<=(anyenum,anyenum)', amopmethod => 'btree' }, +{ amopfamily => 'btree/enum_ops', amoplefttype => 'anyenum', + amoprighttype => 'anyenum', amopstrategy => '3', + amopopr => '=(anyenum,anyenum)', amopmethod => 'btree' }, +{ amopfamily => 'btree/enum_ops', amoplefttype => 'anyenum', + amoprighttype => 'anyenum', amopstrategy => '4', + amopopr => '>=(anyenum,anyenum)', amopmethod => 'btree' }, +{ amopfamily => 'btree/enum_ops', amoplefttype => 'anyenum', + amoprighttype => 'anyenum', amopstrategy => '5', + amopopr => '>(anyenum,anyenum)', amopmethod => 'btree' }, + +# hash enum_ops +{ amopfamily => 'hash/enum_ops', amoplefttype => 'anyenum', + amoprighttype => 'anyenum', amopstrategy => '1', + amopopr => '=(anyenum,anyenum)', amopmethod => 'hash' }, + +# btree tsvector_ops +{ amopfamily => 'btree/tsvector_ops', amoplefttype => 'tsvector', + amoprighttype => 'tsvector', amopstrategy => '1', + amopopr => '<(tsvector,tsvector)', amopmethod => 'btree' }, +{ amopfamily => 'btree/tsvector_ops', amoplefttype => 'tsvector', + amoprighttype => 'tsvector', amopstrategy => '2', + amopopr => '<=(tsvector,tsvector)', amopmethod => 'btree' }, +{ amopfamily => 'btree/tsvector_ops', amoplefttype => 'tsvector', + amoprighttype => 'tsvector', amopstrategy => '3', + amopopr => '=(tsvector,tsvector)', amopmethod => 'btree' }, +{ amopfamily => 'btree/tsvector_ops', amoplefttype => 'tsvector', + amoprighttype => 'tsvector', amopstrategy => '4', + amopopr => '>=(tsvector,tsvector)', amopmethod => 'btree' }, +{ amopfamily => 'btree/tsvector_ops', amoplefttype => 'tsvector', + amoprighttype => 'tsvector', amopstrategy => '5', + amopopr => '>(tsvector,tsvector)', amopmethod => 'btree' }, + +# GiST tsvector_ops +{ amopfamily => 'gist/tsvector_ops', amoplefttype => 'tsvector', + amoprighttype => 'tsquery', amopstrategy => '1', + amopopr => '@@(tsvector,tsquery)', amopmethod => 'gist' }, + +# GIN tsvector_ops +{ amopfamily => 'gin/tsvector_ops', amoplefttype => 'tsvector', + amoprighttype => 'tsquery', amopstrategy => '1', + amopopr => '@@(tsvector,tsquery)', amopmethod => 'gin' }, +{ amopfamily => 'gin/tsvector_ops', amoplefttype => 'tsvector', + amoprighttype => 'tsquery', amopstrategy => '2', + amopopr => '@@@(tsvector,tsquery)', amopmethod => 'gin' }, + +# btree tsquery_ops +{ amopfamily => 'btree/tsquery_ops', amoplefttype => 'tsquery', + amoprighttype => 'tsquery', amopstrategy => '1', + amopopr => '<(tsquery,tsquery)', amopmethod => 'btree' }, +{ amopfamily => 'btree/tsquery_ops', amoplefttype => 'tsquery', + amoprighttype => 'tsquery', amopstrategy => '2', + amopopr => '<=(tsquery,tsquery)', amopmethod => 'btree' }, +{ amopfamily => 'btree/tsquery_ops', amoplefttype => 'tsquery', + amoprighttype => 'tsquery', amopstrategy => '3', + amopopr => '=(tsquery,tsquery)', amopmethod => 'btree' }, +{ amopfamily => 'btree/tsquery_ops', amoplefttype => 'tsquery', + amoprighttype => 'tsquery', amopstrategy => '4', + amopopr => '>=(tsquery,tsquery)', amopmethod => 'btree' }, +{ amopfamily => 'btree/tsquery_ops', amoplefttype => 'tsquery', + amoprighttype => 'tsquery', amopstrategy => '5', + amopopr => '>(tsquery,tsquery)', amopmethod => 'btree' }, + +# GiST tsquery_ops +{ amopfamily => 'gist/tsquery_ops', amoplefttype => 'tsquery', + amoprighttype => 'tsquery', amopstrategy => '7', + amopopr => '@>(tsquery,tsquery)', amopmethod => 'gist' }, +{ amopfamily => 'gist/tsquery_ops', amoplefttype => 'tsquery', + amoprighttype => 'tsquery', amopstrategy => '8', + amopopr => '<@(tsquery,tsquery)', amopmethod => 'gist' }, + +# btree range_ops +{ amopfamily => 'btree/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '1', + amopopr => '<(anyrange,anyrange)', amopmethod => 'btree' }, +{ amopfamily => 'btree/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '2', + amopopr => '<=(anyrange,anyrange)', amopmethod => 'btree' }, +{ amopfamily => 'btree/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '3', + amopopr => '=(anyrange,anyrange)', amopmethod => 'btree' }, +{ amopfamily => 'btree/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '4', + amopopr => '>=(anyrange,anyrange)', amopmethod => 'btree' }, +{ amopfamily => 'btree/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '5', + amopopr => '>(anyrange,anyrange)', amopmethod => 'btree' }, + +# hash range_ops +{ amopfamily => 'hash/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '1', + amopopr => '=(anyrange,anyrange)', amopmethod => 'hash' }, + +# GiST range_ops +{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '1', + amopopr => '<<(anyrange,anyrange)', amopmethod => 'gist' }, +{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '2', + amopopr => '&<(anyrange,anyrange)', amopmethod => 'gist' }, +{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '3', + amopopr => '&&(anyrange,anyrange)', amopmethod => 'gist' }, +{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '4', + amopopr => '&>(anyrange,anyrange)', amopmethod => 'gist' }, +{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '5', + amopopr => '>>(anyrange,anyrange)', amopmethod => 'gist' }, +{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '6', + amopopr => '-|-(anyrange,anyrange)', amopmethod => 'gist' }, +{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '7', + amopopr => '@>(anyrange,anyrange)', amopmethod => 'gist' }, +{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '8', + amopopr => '<@(anyrange,anyrange)', amopmethod => 'gist' }, +{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyelement', amopstrategy => '16', + amopopr => '@>(anyrange,anyelement)', amopmethod => 'gist' }, +{ amopfamily => 'gist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '18', + amopopr => '=(anyrange,anyrange)', amopmethod => 'gist' }, + +# SP-GiST quad_point_ops +{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '11', amopopr => '>^(point,point)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '1', amopopr => '<<(point,point)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '5', amopopr => '>>(point,point)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '10', amopopr => '<^(point,point)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '6', amopopr => '~=(point,point)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point', + amoprighttype => 'box', amopstrategy => '8', amopopr => '<@(point,box)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/quad_point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o', + amopopr => '<->(point,point)', amopmethod => 'spgist', + amopsortfamily => 'btree/float_ops' }, + +# SP-GiST kd_point_ops +{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '11', amopopr => '>^(point,point)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '1', amopopr => '<<(point,point)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '5', amopopr => '>>(point,point)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '10', amopopr => '<^(point,point)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '6', amopopr => '~=(point,point)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point', + amoprighttype => 'box', amopstrategy => '8', amopopr => '<@(point,box)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/kd_point_ops', amoplefttype => 'point', + amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o', + amopopr => '<->(point,point)', amopmethod => 'spgist', + amopsortfamily => 'btree/float_ops' }, + +# SP-GiST text_ops +{ amopfamily => 'spgist/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '1', amopopr => '~<~(text,text)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '2', amopopr => '~<=~(text,text)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '3', amopopr => '=(text,text)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '4', amopopr => '~>=~(text,text)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '5', amopopr => '~>~(text,text)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '11', amopopr => '<(text,text)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '12', amopopr => '<=(text,text)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '14', amopopr => '>=(text,text)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '15', amopopr => '>(text,text)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/text_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '28', amopopr => '^@(text,text)', + amopmethod => 'spgist' }, + +# btree jsonb_ops +{ amopfamily => 'btree/jsonb_ops', amoplefttype => 'jsonb', + amoprighttype => 'jsonb', amopstrategy => '1', amopopr => '<(jsonb,jsonb)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/jsonb_ops', amoplefttype => 'jsonb', + amoprighttype => 'jsonb', amopstrategy => '2', amopopr => '<=(jsonb,jsonb)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/jsonb_ops', amoplefttype => 'jsonb', + amoprighttype => 'jsonb', amopstrategy => '3', amopopr => '=(jsonb,jsonb)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/jsonb_ops', amoplefttype => 'jsonb', + amoprighttype => 'jsonb', amopstrategy => '4', amopopr => '>=(jsonb,jsonb)', + amopmethod => 'btree' }, +{ amopfamily => 'btree/jsonb_ops', amoplefttype => 'jsonb', + amoprighttype => 'jsonb', amopstrategy => '5', amopopr => '>(jsonb,jsonb)', + amopmethod => 'btree' }, + +# hash jsonb_ops +{ amopfamily => 'hash/jsonb_ops', amoplefttype => 'jsonb', + amoprighttype => 'jsonb', amopstrategy => '1', amopopr => '=(jsonb,jsonb)', + amopmethod => 'hash' }, + +# GIN jsonb_ops +{ amopfamily => 'gin/jsonb_ops', amoplefttype => 'jsonb', + amoprighttype => 'jsonb', amopstrategy => '7', amopopr => '@>(jsonb,jsonb)', + amopmethod => 'gin' }, +{ amopfamily => 'gin/jsonb_ops', amoplefttype => 'jsonb', + amoprighttype => 'text', amopstrategy => '9', amopopr => '?(jsonb,text)', + amopmethod => 'gin' }, +{ amopfamily => 'gin/jsonb_ops', amoplefttype => 'jsonb', + amoprighttype => '_text', amopstrategy => '10', amopopr => '?|(jsonb,_text)', + amopmethod => 'gin' }, +{ amopfamily => 'gin/jsonb_ops', amoplefttype => 'jsonb', + amoprighttype => '_text', amopstrategy => '11', amopopr => '?&(jsonb,_text)', + amopmethod => 'gin' }, +{ amopfamily => 'gin/jsonb_ops', amoplefttype => 'jsonb', + amoprighttype => 'jsonpath', amopstrategy => '15', + amopopr => '@?(jsonb,jsonpath)', amopmethod => 'gin' }, +{ amopfamily => 'gin/jsonb_ops', amoplefttype => 'jsonb', + amoprighttype => 'jsonpath', amopstrategy => '16', + amopopr => '@@(jsonb,jsonpath)', amopmethod => 'gin' }, + +# GIN jsonb_path_ops +{ amopfamily => 'gin/jsonb_path_ops', amoplefttype => 'jsonb', + amoprighttype => 'jsonb', amopstrategy => '7', amopopr => '@>(jsonb,jsonb)', + amopmethod => 'gin' }, +{ amopfamily => 'gin/jsonb_path_ops', amoplefttype => 'jsonb', + amoprighttype => 'jsonpath', amopstrategy => '15', + amopopr => '@?(jsonb,jsonpath)', amopmethod => 'gin' }, +{ amopfamily => 'gin/jsonb_path_ops', amoplefttype => 'jsonb', + amoprighttype => 'jsonpath', amopstrategy => '16', + amopopr => '@@(jsonb,jsonpath)', amopmethod => 'gin' }, + +# SP-GiST range_ops +{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '1', + amopopr => '<<(anyrange,anyrange)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '2', + amopopr => '&<(anyrange,anyrange)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '3', + amopopr => '&&(anyrange,anyrange)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '4', + amopopr => '&>(anyrange,anyrange)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '5', + amopopr => '>>(anyrange,anyrange)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '6', + amopopr => '-|-(anyrange,anyrange)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '7', + amopopr => '@>(anyrange,anyrange)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '8', + amopopr => '<@(anyrange,anyrange)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyelement', amopstrategy => '16', + amopopr => '@>(anyrange,anyelement)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/range_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '18', + amopopr => '=(anyrange,anyrange)', amopmethod => 'spgist' }, + +# SP-GiST box_ops +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '1', amopopr => '<<(box,box)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '2', amopopr => '&<(box,box)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '3', amopopr => '&&(box,box)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '4', amopopr => '&>(box,box)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '5', amopopr => '>>(box,box)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '6', amopopr => '~=(box,box)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '7', amopopr => '@>(box,box)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '8', amopopr => '<@(box,box)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '9', amopopr => '&<|(box,box)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '10', amopopr => '<<|(box,box)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '11', amopopr => '|>>(box,box)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', amoprighttype => 'box', + amopstrategy => '12', amopopr => '|&>(box,box)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/box_ops', amoplefttype => 'box', + amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o', + amopopr => '<->(box,point)', amopmethod => 'spgist', + amopsortfamily => 'btree/float_ops' }, + +# SP-GiST poly_ops (supports polygons) +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '1', + amopopr => '<<(polygon,polygon)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '2', + amopopr => '&<(polygon,polygon)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '3', + amopopr => '&&(polygon,polygon)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '4', + amopopr => '&>(polygon,polygon)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '5', + amopopr => '>>(polygon,polygon)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '6', + amopopr => '~=(polygon,polygon)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '7', + amopopr => '@>(polygon,polygon)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '8', + amopopr => '<@(polygon,polygon)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '9', + amopopr => '&<|(polygon,polygon)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '10', + amopopr => '<<|(polygon,polygon)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '11', + amopopr => '|>>(polygon,polygon)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'polygon', amopstrategy => '12', + amopopr => '|&>(polygon,polygon)', amopmethod => 'spgist' }, +{ amopfamily => 'spgist/poly_ops', amoplefttype => 'polygon', + amoprighttype => 'point', amopstrategy => '15', amoppurpose => 'o', + amopopr => '<->(polygon,point)', amopmethod => 'spgist', + amopsortfamily => 'btree/float_ops' }, + +# GiST inet_ops +{ amopfamily => 'gist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '3', amopopr => '&&(inet,inet)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '18', amopopr => '=(inet,inet)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '19', amopopr => '<>(inet,inet)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '20', amopopr => '<(inet,inet)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '21', amopopr => '<=(inet,inet)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '22', amopopr => '>(inet,inet)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '23', amopopr => '>=(inet,inet)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '24', amopopr => '<<(inet,inet)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '25', amopopr => '<<=(inet,inet)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '26', amopopr => '>>(inet,inet)', + amopmethod => 'gist' }, +{ amopfamily => 'gist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '27', amopopr => '>>=(inet,inet)', + amopmethod => 'gist' }, + +# SP-GiST inet_ops +{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '3', amopopr => '&&(inet,inet)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '18', amopopr => '=(inet,inet)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '19', amopopr => '<>(inet,inet)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '20', amopopr => '<(inet,inet)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '21', amopopr => '<=(inet,inet)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '22', amopopr => '>(inet,inet)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '23', amopopr => '>=(inet,inet)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '24', amopopr => '<<(inet,inet)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '25', amopopr => '<<=(inet,inet)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '26', amopopr => '>>(inet,inet)', + amopmethod => 'spgist' }, +{ amopfamily => 'spgist/network_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '27', amopopr => '>>=(inet,inet)', + amopmethod => 'spgist' }, + +# BRIN opclasses + +# minmax bytea +{ amopfamily => 'brin/bytea_minmax_ops', amoplefttype => 'bytea', + amoprighttype => 'bytea', amopstrategy => '1', amopopr => '<(bytea,bytea)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/bytea_minmax_ops', amoplefttype => 'bytea', + amoprighttype => 'bytea', amopstrategy => '2', amopopr => '<=(bytea,bytea)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/bytea_minmax_ops', amoplefttype => 'bytea', + amoprighttype => 'bytea', amopstrategy => '3', amopopr => '=(bytea,bytea)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/bytea_minmax_ops', amoplefttype => 'bytea', + amoprighttype => 'bytea', amopstrategy => '4', amopopr => '>=(bytea,bytea)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/bytea_minmax_ops', amoplefttype => 'bytea', + amoprighttype => 'bytea', amopstrategy => '5', amopopr => '>(bytea,bytea)', + amopmethod => 'brin' }, + +# minmax "char" +{ amopfamily => 'brin/char_minmax_ops', amoplefttype => 'char', + amoprighttype => 'char', amopstrategy => '1', amopopr => '<(char,char)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/char_minmax_ops', amoplefttype => 'char', + amoprighttype => 'char', amopstrategy => '2', amopopr => '<=(char,char)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/char_minmax_ops', amoplefttype => 'char', + amoprighttype => 'char', amopstrategy => '3', amopopr => '=(char,char)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/char_minmax_ops', amoplefttype => 'char', + amoprighttype => 'char', amopstrategy => '4', amopopr => '>=(char,char)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/char_minmax_ops', amoplefttype => 'char', + amoprighttype => 'char', amopstrategy => '5', amopopr => '>(char,char)', + amopmethod => 'brin' }, + +# minmax name +{ amopfamily => 'brin/name_minmax_ops', amoplefttype => 'name', + amoprighttype => 'name', amopstrategy => '1', amopopr => '<(name,name)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/name_minmax_ops', amoplefttype => 'name', + amoprighttype => 'name', amopstrategy => '2', amopopr => '<=(name,name)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/name_minmax_ops', amoplefttype => 'name', + amoprighttype => 'name', amopstrategy => '3', amopopr => '=(name,name)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/name_minmax_ops', amoplefttype => 'name', + amoprighttype => 'name', amopstrategy => '4', amopopr => '>=(name,name)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/name_minmax_ops', amoplefttype => 'name', + amoprighttype => 'name', amopstrategy => '5', amopopr => '>(name,name)', + amopmethod => 'brin' }, + +# minmax integer + +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int8,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int8,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int8,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int8,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int8,int8)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int8,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int8,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int8,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int8,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int8,int2)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int8,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int8,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int8,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int8,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int8', + amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int8,int4)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int2,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int2,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int2,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int2,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int2,int2)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int2,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int2,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int2,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int2,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int2,int8)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int2,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int2,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int2,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int2,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int2', + amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int2,int4)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '1', amopopr => '<(int4,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '2', amopopr => '<=(int4,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '3', amopopr => '=(int4,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '4', amopopr => '>=(int4,int4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int4', amopstrategy => '5', amopopr => '>(int4,int4)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '1', amopopr => '<(int4,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '2', amopopr => '<=(int4,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '3', amopopr => '=(int4,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '4', amopopr => '>=(int4,int2)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int2', amopstrategy => '5', amopopr => '>(int4,int2)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '1', amopopr => '<(int4,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '2', amopopr => '<=(int4,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '3', amopopr => '=(int4,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '4', amopopr => '>=(int4,int8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/integer_minmax_ops', amoplefttype => 'int4', + amoprighttype => 'int8', amopstrategy => '5', amopopr => '>(int4,int8)', + amopmethod => 'brin' }, + +# minmax text +{ amopfamily => 'brin/text_minmax_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '1', amopopr => '<(text,text)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/text_minmax_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '2', amopopr => '<=(text,text)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/text_minmax_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '3', amopopr => '=(text,text)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/text_minmax_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '4', amopopr => '>=(text,text)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/text_minmax_ops', amoplefttype => 'text', + amoprighttype => 'text', amopstrategy => '5', amopopr => '>(text,text)', + amopmethod => 'brin' }, + +# minmax oid +{ amopfamily => 'brin/oid_minmax_ops', amoplefttype => 'oid', + amoprighttype => 'oid', amopstrategy => '1', amopopr => '<(oid,oid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/oid_minmax_ops', amoplefttype => 'oid', + amoprighttype => 'oid', amopstrategy => '2', amopopr => '<=(oid,oid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/oid_minmax_ops', amoplefttype => 'oid', + amoprighttype => 'oid', amopstrategy => '3', amopopr => '=(oid,oid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/oid_minmax_ops', amoplefttype => 'oid', + amoprighttype => 'oid', amopstrategy => '4', amopopr => '>=(oid,oid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/oid_minmax_ops', amoplefttype => 'oid', + amoprighttype => 'oid', amopstrategy => '5', amopopr => '>(oid,oid)', + amopmethod => 'brin' }, + +# minmax tid +{ amopfamily => 'brin/tid_minmax_ops', amoplefttype => 'tid', + amoprighttype => 'tid', amopstrategy => '1', amopopr => '<(tid,tid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/tid_minmax_ops', amoplefttype => 'tid', + amoprighttype => 'tid', amopstrategy => '2', amopopr => '<=(tid,tid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/tid_minmax_ops', amoplefttype => 'tid', + amoprighttype => 'tid', amopstrategy => '3', amopopr => '=(tid,tid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/tid_minmax_ops', amoplefttype => 'tid', + amoprighttype => 'tid', amopstrategy => '4', amopopr => '>=(tid,tid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/tid_minmax_ops', amoplefttype => 'tid', + amoprighttype => 'tid', amopstrategy => '5', amopopr => '>(tid,tid)', + amopmethod => 'brin' }, + +# minmax float (float4, float8) + +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '1', amopopr => '<(float4,float4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '2', + amopopr => '<=(float4,float4)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '3', amopopr => '=(float4,float4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '4', + amopopr => '>=(float4,float4)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4', + amoprighttype => 'float4', amopstrategy => '5', amopopr => '>(float4,float4)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '1', amopopr => '<(float4,float8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '2', + amopopr => '<=(float4,float8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '3', amopopr => '=(float4,float8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '4', + amopopr => '>=(float4,float8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float4', + amoprighttype => 'float8', amopstrategy => '5', amopopr => '>(float4,float8)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '1', amopopr => '<(float8,float4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '2', + amopopr => '<=(float8,float4)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '3', amopopr => '=(float8,float4)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '4', + amopopr => '>=(float8,float4)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8', + amoprighttype => 'float4', amopstrategy => '5', amopopr => '>(float8,float4)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '1', amopopr => '<(float8,float8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '2', + amopopr => '<=(float8,float8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '3', amopopr => '=(float8,float8)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '4', + amopopr => '>=(float8,float8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/float_minmax_ops', amoplefttype => 'float8', + amoprighttype => 'float8', amopstrategy => '5', amopopr => '>(float8,float8)', + amopmethod => 'brin' }, + +# minmax macaddr +{ amopfamily => 'brin/macaddr_minmax_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '1', + amopopr => '<(macaddr,macaddr)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr_minmax_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '2', + amopopr => '<=(macaddr,macaddr)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr_minmax_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '3', + amopopr => '=(macaddr,macaddr)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr_minmax_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '4', + amopopr => '>=(macaddr,macaddr)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr_minmax_ops', amoplefttype => 'macaddr', + amoprighttype => 'macaddr', amopstrategy => '5', + amopopr => '>(macaddr,macaddr)', amopmethod => 'brin' }, + +# minmax macaddr8 +{ amopfamily => 'brin/macaddr8_minmax_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '1', + amopopr => '<(macaddr8,macaddr8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr8_minmax_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '2', + amopopr => '<=(macaddr8,macaddr8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr8_minmax_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '3', + amopopr => '=(macaddr8,macaddr8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr8_minmax_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '4', + amopopr => '>=(macaddr8,macaddr8)', amopmethod => 'brin' }, +{ amopfamily => 'brin/macaddr8_minmax_ops', amoplefttype => 'macaddr8', + amoprighttype => 'macaddr8', amopstrategy => '5', + amopopr => '>(macaddr8,macaddr8)', amopmethod => 'brin' }, + +# minmax inet +{ amopfamily => 'brin/network_minmax_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '1', amopopr => '<(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_minmax_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '2', amopopr => '<=(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_minmax_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '3', amopopr => '=(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_minmax_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '4', amopopr => '>=(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_minmax_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '5', amopopr => '>(inet,inet)', + amopmethod => 'brin' }, + +# inclusion inet +{ amopfamily => 'brin/network_inclusion_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '3', amopopr => '&&(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_inclusion_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '7', amopopr => '>>=(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_inclusion_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '8', amopopr => '<<=(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_inclusion_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '18', amopopr => '=(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_inclusion_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '24', amopopr => '>>(inet,inet)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/network_inclusion_ops', amoplefttype => 'inet', + amoprighttype => 'inet', amopstrategy => '26', amopopr => '<<(inet,inet)', + amopmethod => 'brin' }, + +# minmax character +{ amopfamily => 'brin/bpchar_minmax_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '1', amopopr => '<(bpchar,bpchar)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/bpchar_minmax_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '2', + amopopr => '<=(bpchar,bpchar)', amopmethod => 'brin' }, +{ amopfamily => 'brin/bpchar_minmax_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '3', amopopr => '=(bpchar,bpchar)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/bpchar_minmax_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '4', + amopopr => '>=(bpchar,bpchar)', amopmethod => 'brin' }, +{ amopfamily => 'brin/bpchar_minmax_ops', amoplefttype => 'bpchar', + amoprighttype => 'bpchar', amopstrategy => '5', amopopr => '>(bpchar,bpchar)', + amopmethod => 'brin' }, + +# minmax time without time zone +{ amopfamily => 'brin/time_minmax_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '1', amopopr => '<(time,time)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/time_minmax_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '2', amopopr => '<=(time,time)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/time_minmax_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '3', amopopr => '=(time,time)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/time_minmax_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '4', amopopr => '>=(time,time)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/time_minmax_ops', amoplefttype => 'time', + amoprighttype => 'time', amopstrategy => '5', amopopr => '>(time,time)', + amopmethod => 'brin' }, + +# minmax datetime (date, timestamp, timestamptz) + +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '1', + amopopr => '<(timestamp,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '2', + amopopr => '<=(timestamp,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '3', + amopopr => '=(timestamp,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '4', + amopopr => '>=(timestamp,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamp', amopstrategy => '5', + amopopr => '>(timestamp,timestamp)', amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '1', amopopr => '<(timestamp,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '2', amopopr => '<=(timestamp,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '3', amopopr => '=(timestamp,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '4', amopopr => '>=(timestamp,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'date', amopstrategy => '5', amopopr => '>(timestamp,date)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '1', + amopopr => '<(timestamp,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '2', + amopopr => '<=(timestamp,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '3', + amopopr => '=(timestamp,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '4', + amopopr => '>=(timestamp,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamp', + amoprighttype => 'timestamptz', amopstrategy => '5', + amopopr => '>(timestamp,timestamptz)', amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '1', amopopr => '<(date,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '2', amopopr => '<=(date,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '3', amopopr => '=(date,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '4', amopopr => '>=(date,date)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'date', amopstrategy => '5', amopopr => '>(date,date)', + amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '1', + amopopr => '<(date,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '2', + amopopr => '<=(date,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '3', + amopopr => '=(date,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '4', + amopopr => '>=(date,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'timestamp', amopstrategy => '5', + amopopr => '>(date,timestamp)', amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '1', + amopopr => '<(date,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '2', + amopopr => '<=(date,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '3', + amopopr => '=(date,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '4', + amopopr => '>=(date,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'date', + amoprighttype => 'timestamptz', amopstrategy => '5', + amopopr => '>(date,timestamptz)', amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '1', + amopopr => '<(timestamptz,date)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '2', + amopopr => '<=(timestamptz,date)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '3', + amopopr => '=(timestamptz,date)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '4', + amopopr => '>=(timestamptz,date)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'date', amopstrategy => '5', + amopopr => '>(timestamptz,date)', amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '1', + amopopr => '<(timestamptz,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '2', + amopopr => '<=(timestamptz,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '3', + amopopr => '=(timestamptz,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '4', + amopopr => '>=(timestamptz,timestamp)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamp', amopstrategy => '5', + amopopr => '>(timestamptz,timestamp)', amopmethod => 'brin' }, + +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '1', + amopopr => '<(timestamptz,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '2', + amopopr => '<=(timestamptz,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '3', + amopopr => '=(timestamptz,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '4', + amopopr => '>=(timestamptz,timestamptz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/datetime_minmax_ops', amoplefttype => 'timestamptz', + amoprighttype => 'timestamptz', amopstrategy => '5', + amopopr => '>(timestamptz,timestamptz)', amopmethod => 'brin' }, + +# minmax interval +{ amopfamily => 'brin/interval_minmax_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '1', + amopopr => '<(interval,interval)', amopmethod => 'brin' }, +{ amopfamily => 'brin/interval_minmax_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '2', + amopopr => '<=(interval,interval)', amopmethod => 'brin' }, +{ amopfamily => 'brin/interval_minmax_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '3', + amopopr => '=(interval,interval)', amopmethod => 'brin' }, +{ amopfamily => 'brin/interval_minmax_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '4', + amopopr => '>=(interval,interval)', amopmethod => 'brin' }, +{ amopfamily => 'brin/interval_minmax_ops', amoplefttype => 'interval', + amoprighttype => 'interval', amopstrategy => '5', + amopopr => '>(interval,interval)', amopmethod => 'brin' }, + +# minmax time with time zone +{ amopfamily => 'brin/timetz_minmax_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '1', amopopr => '<(timetz,timetz)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/timetz_minmax_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '2', + amopopr => '<=(timetz,timetz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/timetz_minmax_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '3', amopopr => '=(timetz,timetz)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/timetz_minmax_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '4', + amopopr => '>=(timetz,timetz)', amopmethod => 'brin' }, +{ amopfamily => 'brin/timetz_minmax_ops', amoplefttype => 'timetz', + amoprighttype => 'timetz', amopstrategy => '5', amopopr => '>(timetz,timetz)', + amopmethod => 'brin' }, + +# minmax bit +{ amopfamily => 'brin/bit_minmax_ops', amoplefttype => 'bit', + amoprighttype => 'bit', amopstrategy => '1', amopopr => '<(bit,bit)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/bit_minmax_ops', amoplefttype => 'bit', + amoprighttype => 'bit', amopstrategy => '2', amopopr => '<=(bit,bit)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/bit_minmax_ops', amoplefttype => 'bit', + amoprighttype => 'bit', amopstrategy => '3', amopopr => '=(bit,bit)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/bit_minmax_ops', amoplefttype => 'bit', + amoprighttype => 'bit', amopstrategy => '4', amopopr => '>=(bit,bit)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/bit_minmax_ops', amoplefttype => 'bit', + amoprighttype => 'bit', amopstrategy => '5', amopopr => '>(bit,bit)', + amopmethod => 'brin' }, + +# minmax bit varying +{ amopfamily => 'brin/varbit_minmax_ops', amoplefttype => 'varbit', + amoprighttype => 'varbit', amopstrategy => '1', amopopr => '<(varbit,varbit)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/varbit_minmax_ops', amoplefttype => 'varbit', + amoprighttype => 'varbit', amopstrategy => '2', + amopopr => '<=(varbit,varbit)', amopmethod => 'brin' }, +{ amopfamily => 'brin/varbit_minmax_ops', amoplefttype => 'varbit', + amoprighttype => 'varbit', amopstrategy => '3', amopopr => '=(varbit,varbit)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/varbit_minmax_ops', amoplefttype => 'varbit', + amoprighttype => 'varbit', amopstrategy => '4', + amopopr => '>=(varbit,varbit)', amopmethod => 'brin' }, +{ amopfamily => 'brin/varbit_minmax_ops', amoplefttype => 'varbit', + amoprighttype => 'varbit', amopstrategy => '5', amopopr => '>(varbit,varbit)', + amopmethod => 'brin' }, + +# minmax numeric +{ amopfamily => 'brin/numeric_minmax_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '1', + amopopr => '<(numeric,numeric)', amopmethod => 'brin' }, +{ amopfamily => 'brin/numeric_minmax_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '2', + amopopr => '<=(numeric,numeric)', amopmethod => 'brin' }, +{ amopfamily => 'brin/numeric_minmax_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '3', + amopopr => '=(numeric,numeric)', amopmethod => 'brin' }, +{ amopfamily => 'brin/numeric_minmax_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '4', + amopopr => '>=(numeric,numeric)', amopmethod => 'brin' }, +{ amopfamily => 'brin/numeric_minmax_ops', amoplefttype => 'numeric', + amoprighttype => 'numeric', amopstrategy => '5', + amopopr => '>(numeric,numeric)', amopmethod => 'brin' }, + +# minmax uuid +{ amopfamily => 'brin/uuid_minmax_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '1', amopopr => '<(uuid,uuid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/uuid_minmax_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '2', amopopr => '<=(uuid,uuid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/uuid_minmax_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '3', amopopr => '=(uuid,uuid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/uuid_minmax_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '4', amopopr => '>=(uuid,uuid)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/uuid_minmax_ops', amoplefttype => 'uuid', + amoprighttype => 'uuid', amopstrategy => '5', amopopr => '>(uuid,uuid)', + amopmethod => 'brin' }, + +# inclusion range types +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '1', + amopopr => '<<(anyrange,anyrange)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '2', + amopopr => '&<(anyrange,anyrange)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '3', + amopopr => '&&(anyrange,anyrange)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '4', + amopopr => '&>(anyrange,anyrange)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '5', + amopopr => '>>(anyrange,anyrange)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '7', + amopopr => '@>(anyrange,anyrange)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '8', + amopopr => '<@(anyrange,anyrange)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyelement', amopstrategy => '16', + amopopr => '@>(anyrange,anyelement)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '17', + amopopr => '-|-(anyrange,anyrange)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '18', + amopopr => '=(anyrange,anyrange)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '20', + amopopr => '<(anyrange,anyrange)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '21', + amopopr => '<=(anyrange,anyrange)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '22', + amopopr => '>(anyrange,anyrange)', amopmethod => 'brin' }, +{ amopfamily => 'brin/range_inclusion_ops', amoplefttype => 'anyrange', + amoprighttype => 'anyrange', amopstrategy => '23', + amopopr => '>=(anyrange,anyrange)', amopmethod => 'brin' }, + +# minmax pg_lsn +{ amopfamily => 'brin/pg_lsn_minmax_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '1', amopopr => '<(pg_lsn,pg_lsn)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/pg_lsn_minmax_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '2', + amopopr => '<=(pg_lsn,pg_lsn)', amopmethod => 'brin' }, +{ amopfamily => 'brin/pg_lsn_minmax_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '3', amopopr => '=(pg_lsn,pg_lsn)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/pg_lsn_minmax_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '4', + amopopr => '>=(pg_lsn,pg_lsn)', amopmethod => 'brin' }, +{ amopfamily => 'brin/pg_lsn_minmax_ops', amoplefttype => 'pg_lsn', + amoprighttype => 'pg_lsn', amopstrategy => '5', amopopr => '>(pg_lsn,pg_lsn)', + amopmethod => 'brin' }, + +# inclusion box +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'box', amopstrategy => '1', amopopr => '<<(box,box)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'box', amopstrategy => '2', amopopr => '&<(box,box)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'box', amopstrategy => '3', amopopr => '&&(box,box)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'box', amopstrategy => '4', amopopr => '&>(box,box)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'box', amopstrategy => '5', amopopr => '>>(box,box)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'box', amopstrategy => '6', amopopr => '~=(box,box)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'box', amopstrategy => '7', amopopr => '@>(box,box)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'box', amopstrategy => '8', amopopr => '<@(box,box)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'box', amopstrategy => '9', amopopr => '&<|(box,box)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'box', amopstrategy => '10', amopopr => '<<|(box,box)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'box', amopstrategy => '11', amopopr => '|>>(box,box)', + amopmethod => 'brin' }, +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'box', amopstrategy => '12', amopopr => '|&>(box,box)', + amopmethod => 'brin' }, + +# we could, but choose not to, supply entries for strategies 13 and 14 + +{ amopfamily => 'brin/box_inclusion_ops', amoplefttype => 'box', + amoprighttype => 'point', amopstrategy => '7', amopopr => '@>(box,point)', + amopmethod => 'brin' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_amop.h b/contrib/libs/postgresql/src/include/catalog/pg_amop.h new file mode 100644 index 0000000000..81a7eb6049 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_amop.h @@ -0,0 +1,98 @@ +/*------------------------------------------------------------------------- + * + * pg_amop.h + * definition of the "access method operator" system catalog (pg_amop) + * + * The amop table identifies the operators associated with each index operator + * family and operator class (classes are subsets of families). An associated + * operator can be either a search operator or an ordering operator, as + * identified by amoppurpose. + * + * The primary key for this table is <amopfamily, amoplefttype, amoprighttype, + * amopstrategy>. amoplefttype and amoprighttype are just copies of the + * operator's oprleft/oprright, ie its declared input data types. The + * "default" operators for a particular opclass within the family are those + * with amoplefttype = amoprighttype = opclass's opcintype. An opfamily may + * also contain other operators, typically cross-data-type operators. All the + * operators within a family are supposed to be compatible, in a way that is + * defined by each individual index AM. + * + * We also keep a unique index on <amopopr, amoppurpose, amopfamily>, so that + * we can use a syscache to quickly answer questions of the form "is this + * operator in this opfamily, and if so what are its semantics with respect to + * the family?" This implies that the same operator cannot be listed for + * multiple strategy numbers within a single opfamily, with the exception that + * it's possible to list it for both search and ordering purposes (with + * different strategy numbers for the two purposes). + * + * amopmethod is a copy of the owning opfamily's opfmethod field. This is an + * intentional denormalization of the catalogs to buy lookup speed. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_amop.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_AMOP_H +#define PG_AMOP_H + +#include "catalog/genbki.h" +#include "catalog/pg_amop_d.h" + +/* ---------------- + * pg_amop definition. cpp turns this into + * typedef struct FormData_pg_amop + * ---------------- + */ +CATALOG(pg_amop,2602,AccessMethodOperatorRelationId) +{ + Oid oid; /* oid */ + + /* the index opfamily this entry is for */ + Oid amopfamily BKI_LOOKUP(pg_opfamily); + + /* operator's left input data type */ + Oid amoplefttype BKI_LOOKUP(pg_type); + + /* operator's right input data type */ + Oid amoprighttype BKI_LOOKUP(pg_type); + + /* operator strategy number */ + int16 amopstrategy; + + /* is operator for 's'earch or 'o'rdering? */ + char amoppurpose BKI_DEFAULT(s); + + /* the operator's pg_operator OID */ + Oid amopopr BKI_LOOKUP(pg_operator); + + /* the index access method this entry is for */ + Oid amopmethod BKI_LOOKUP(pg_am); + + /* ordering opfamily OID, or 0 if search op */ + Oid amopsortfamily BKI_DEFAULT(0) BKI_LOOKUP(pg_opfamily); +} FormData_pg_amop; + +/* ---------------- + * Form_pg_amop corresponds to a pointer to a tuple with + * the format of pg_amop relation. + * ---------------- + */ +typedef FormData_pg_amop *Form_pg_amop; + +#ifdef EXPOSE_TO_CLIENT_CODE + +/* allowed values of amoppurpose: */ +#define AMOP_SEARCH 's' /* operator is for search */ +#define AMOP_ORDER 'o' /* operator is for ordering */ + +#endif /* EXPOSE_TO_CLIENT_CODE */ + +#endif /* PG_AMOP_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_amop_d.h b/contrib/libs/postgresql/src/include/catalog/pg_amop_d.h new file mode 100644 index 0000000000..3bf63b84c4 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_amop_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_amop_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_amproc.dat b/contrib/libs/postgresql/src/include/catalog/pg_amproc.dat new file mode 100644 index 0000000000..37b580883f --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_amproc.dat @@ -0,0 +1,1316 @@ +#---------------------------------------------------------------------- +# +# pg_amproc.dat +# Initial contents of the pg_amproc system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_amproc.dat +# +#---------------------------------------------------------------------- + +[ + +# btree +{ amprocfamily => 'btree/array_ops', amproclefttype => 'anyarray', + amprocrighttype => 'anyarray', amprocnum => '1', amproc => 'btarraycmp' }, +{ amprocfamily => 'btree/bit_ops', amproclefttype => 'bit', + amprocrighttype => 'bit', amprocnum => '1', amproc => 'bitcmp' }, +{ amprocfamily => 'btree/bit_ops', amproclefttype => 'bit', + amprocrighttype => 'bit', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/bool_ops', amproclefttype => 'bool', + amprocrighttype => 'bool', amprocnum => '1', amproc => 'btboolcmp' }, +{ amprocfamily => 'btree/bool_ops', amproclefttype => 'bool', + amprocrighttype => 'bool', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/bpchar_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '1', amproc => 'bpcharcmp' }, +{ amprocfamily => 'btree/bpchar_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '2', + amproc => 'bpchar_sortsupport' }, +{ amprocfamily => 'btree/bpchar_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '4', + amproc => 'btvarstrequalimage' }, +{ amprocfamily => 'btree/bytea_ops', amproclefttype => 'bytea', + amprocrighttype => 'bytea', amprocnum => '1', amproc => 'byteacmp' }, +{ amprocfamily => 'btree/bytea_ops', amproclefttype => 'bytea', + amprocrighttype => 'bytea', amprocnum => '2', amproc => 'bytea_sortsupport' }, +{ amprocfamily => 'btree/bytea_ops', amproclefttype => 'bytea', + amprocrighttype => 'bytea', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/char_ops', amproclefttype => 'char', + amprocrighttype => 'char', amprocnum => '1', amproc => 'btcharcmp' }, +{ amprocfamily => 'btree/char_ops', amproclefttype => 'char', + amprocrighttype => 'char', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '1', amproc => 'date_cmp' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '2', amproc => 'date_sortsupport' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'date', + amprocrighttype => 'timestamp', amprocnum => '1', + amproc => 'date_cmp_timestamp' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'date', + amprocrighttype => 'timestamptz', amprocnum => '1', + amproc => 'date_cmp_timestamptz' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '1', amproc => 'timestamp_cmp' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '2', + amproc => 'timestamp_sortsupport' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamp', + amprocrighttype => 'date', amprocnum => '1', amproc => 'timestamp_cmp_date' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamptz', amprocnum => '1', + amproc => 'timestamp_cmp_timestamptz' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '1', + amproc => 'timestamptz_cmp' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '2', + amproc => 'timestamp_sortsupport' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '4', + amproc => 'btequalimage' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'date', amprocnum => '1', + amproc => 'timestamptz_cmp_date' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamp', amprocnum => '1', + amproc => 'timestamptz_cmp_timestamp' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'date', + amprocrighttype => 'interval', amprocnum => '3', + amproc => 'in_range(date,date,interval,bool,bool)' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamp', + amprocrighttype => 'interval', amprocnum => '3', + amproc => 'in_range(timestamp,timestamp,interval,bool,bool)' }, +{ amprocfamily => 'btree/datetime_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'interval', amprocnum => '3', + amproc => 'in_range(timestamptz,timestamptz,interval,bool,bool)' }, +{ amprocfamily => 'btree/float_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '1', amproc => 'btfloat4cmp' }, +{ amprocfamily => 'btree/float_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '2', + amproc => 'btfloat4sortsupport' }, +{ amprocfamily => 'btree/float_ops', amproclefttype => 'float4', + amprocrighttype => 'float8', amprocnum => '1', amproc => 'btfloat48cmp' }, +{ amprocfamily => 'btree/float_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '1', amproc => 'btfloat8cmp' }, +{ amprocfamily => 'btree/float_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '2', + amproc => 'btfloat8sortsupport' }, +{ amprocfamily => 'btree/float_ops', amproclefttype => 'float8', + amprocrighttype => 'float4', amprocnum => '1', amproc => 'btfloat84cmp' }, +{ amprocfamily => 'btree/float_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '3', + amproc => 'in_range(float8,float8,float8,bool,bool)' }, +{ amprocfamily => 'btree/float_ops', amproclefttype => 'float4', + amprocrighttype => 'float8', amprocnum => '3', + amproc => 'in_range(float4,float4,float8,bool,bool)' }, +{ amprocfamily => 'btree/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '1', amproc => 'network_cmp' }, +{ amprocfamily => 'btree/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '2', + amproc => 'network_sortsupport' }, +{ amprocfamily => 'btree/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '1', amproc => 'btint2cmp' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '2', amproc => 'btint2sortsupport' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2', + amprocrighttype => 'int4', amprocnum => '1', amproc => 'btint24cmp' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2', + amprocrighttype => 'int8', amprocnum => '1', amproc => 'btint28cmp' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2', + amprocrighttype => 'int8', amprocnum => '3', + amproc => 'in_range(int2,int2,int8,bool,bool)' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2', + amprocrighttype => 'int4', amprocnum => '3', + amproc => 'in_range(int2,int2,int4,bool,bool)' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '3', + amproc => 'in_range(int2,int2,int2,bool,bool)' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '1', amproc => 'btint4cmp' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '2', amproc => 'btint4sortsupport' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4', + amprocrighttype => 'int8', amprocnum => '1', amproc => 'btint48cmp' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4', + amprocrighttype => 'int2', amprocnum => '1', amproc => 'btint42cmp' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4', + amprocrighttype => 'int8', amprocnum => '3', + amproc => 'in_range(int4,int4,int8,bool,bool)' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '3', + amproc => 'in_range(int4,int4,int4,bool,bool)' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int4', + amprocrighttype => 'int2', amprocnum => '3', + amproc => 'in_range(int4,int4,int2,bool,bool)' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '1', amproc => 'btint8cmp' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '2', amproc => 'btint8sortsupport' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int8', + amprocrighttype => 'int4', amprocnum => '1', amproc => 'btint84cmp' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int8', + amprocrighttype => 'int2', amprocnum => '1', amproc => 'btint82cmp' }, +{ amprocfamily => 'btree/integer_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '3', + amproc => 'in_range(int8,int8,int8,bool,bool)' }, +{ amprocfamily => 'btree/interval_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '1', amproc => 'interval_cmp' }, +{ amprocfamily => 'btree/interval_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '3', + amproc => 'in_range(interval,interval,interval,bool,bool)' }, +{ amprocfamily => 'btree/interval_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/macaddr_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '1', amproc => 'macaddr_cmp' }, +{ amprocfamily => 'btree/macaddr_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '2', + amproc => 'macaddr_sortsupport' }, +{ amprocfamily => 'btree/macaddr_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/numeric_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '1', amproc => 'numeric_cmp' }, +{ amprocfamily => 'btree/numeric_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '2', + amproc => 'numeric_sortsupport' }, +{ amprocfamily => 'btree/numeric_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '3', + amproc => 'in_range(numeric,numeric,numeric,bool,bool)' }, +{ amprocfamily => 'btree/oid_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '1', amproc => 'btoidcmp' }, +{ amprocfamily => 'btree/oid_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '2', amproc => 'btoidsortsupport' }, +{ amprocfamily => 'btree/oid_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/oidvector_ops', amproclefttype => 'oidvector', + amprocrighttype => 'oidvector', amprocnum => '1', + amproc => 'btoidvectorcmp' }, +{ amprocfamily => 'btree/oidvector_ops', amproclefttype => 'oidvector', + amprocrighttype => 'oidvector', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/text_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '1', amproc => 'bttextcmp' }, +{ amprocfamily => 'btree/text_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '2', amproc => 'bttextsortsupport' }, +{ amprocfamily => 'btree/text_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '4', amproc => 'btvarstrequalimage' }, +{ amprocfamily => 'btree/text_ops', amproclefttype => 'name', + amprocrighttype => 'name', amprocnum => '1', amproc => 'btnamecmp' }, +{ amprocfamily => 'btree/text_ops', amproclefttype => 'name', + amprocrighttype => 'name', amprocnum => '2', amproc => 'btnamesortsupport' }, +{ amprocfamily => 'btree/text_ops', amproclefttype => 'name', + amprocrighttype => 'name', amprocnum => '4', amproc => 'btvarstrequalimage' }, +{ amprocfamily => 'btree/text_ops', amproclefttype => 'name', + amprocrighttype => 'text', amprocnum => '1', amproc => 'btnametextcmp' }, +{ amprocfamily => 'btree/text_ops', amproclefttype => 'text', + amprocrighttype => 'name', amprocnum => '1', amproc => 'bttextnamecmp' }, +{ amprocfamily => 'btree/time_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '1', amproc => 'time_cmp' }, +{ amprocfamily => 'btree/time_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/time_ops', amproclefttype => 'time', + amprocrighttype => 'interval', amprocnum => '3', + amproc => 'in_range(time,time,interval,bool,bool)' }, +{ amprocfamily => 'btree/timetz_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '1', amproc => 'timetz_cmp' }, +{ amprocfamily => 'btree/timetz_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/timetz_ops', amproclefttype => 'timetz', + amprocrighttype => 'interval', amprocnum => '3', + amproc => 'in_range(timetz,timetz,interval,bool,bool)' }, +{ amprocfamily => 'btree/varbit_ops', amproclefttype => 'varbit', + amprocrighttype => 'varbit', amprocnum => '1', amproc => 'varbitcmp' }, +{ amprocfamily => 'btree/varbit_ops', amproclefttype => 'varbit', + amprocrighttype => 'varbit', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/text_pattern_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '1', amproc => 'bttext_pattern_cmp' }, +{ amprocfamily => 'btree/text_pattern_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '2', + amproc => 'bttext_pattern_sortsupport' }, +{ amprocfamily => 'btree/text_pattern_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/bpchar_pattern_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '1', + amproc => 'btbpchar_pattern_cmp' }, +{ amprocfamily => 'btree/bpchar_pattern_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '2', + amproc => 'btbpchar_pattern_sortsupport' }, +{ amprocfamily => 'btree/bpchar_pattern_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/money_ops', amproclefttype => 'money', + amprocrighttype => 'money', amprocnum => '1', amproc => 'cash_cmp' }, +{ amprocfamily => 'btree/money_ops', amproclefttype => 'money', + amprocrighttype => 'money', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/tid_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '1', amproc => 'bttidcmp' }, +{ amprocfamily => 'btree/tid_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/uuid_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '1', amproc => 'uuid_cmp' }, +{ amprocfamily => 'btree/uuid_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '2', amproc => 'uuid_sortsupport' }, +{ amprocfamily => 'btree/uuid_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/record_ops', amproclefttype => 'record', + amprocrighttype => 'record', amprocnum => '1', amproc => 'btrecordcmp' }, +{ amprocfamily => 'btree/record_image_ops', amproclefttype => 'record', + amprocrighttype => 'record', amprocnum => '1', amproc => 'btrecordimagecmp' }, +{ amprocfamily => 'btree/pg_lsn_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '1', amproc => 'pg_lsn_cmp' }, +{ amprocfamily => 'btree/pg_lsn_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/macaddr8_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '1', amproc => 'macaddr8_cmp' }, +{ amprocfamily => 'btree/macaddr8_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/enum_ops', amproclefttype => 'anyenum', + amprocrighttype => 'anyenum', amprocnum => '1', amproc => 'enum_cmp' }, +{ amprocfamily => 'btree/enum_ops', amproclefttype => 'anyenum', + amprocrighttype => 'anyenum', amprocnum => '4', amproc => 'btequalimage' }, +{ amprocfamily => 'btree/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '1', amproc => 'tsvector_cmp' }, +{ amprocfamily => 'btree/tsquery_ops', amproclefttype => 'tsquery', + amprocrighttype => 'tsquery', amprocnum => '1', amproc => 'tsquery_cmp' }, +{ amprocfamily => 'btree/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '1', amproc => 'range_cmp' }, +{ amprocfamily => 'btree/jsonb_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '1', amproc => 'jsonb_cmp' }, +{ amprocfamily => 'btree/xid8_ops', amproclefttype => 'xid8', + amprocrighttype => 'xid8', amprocnum => '1', amproc => 'xid8cmp' }, +{ amprocfamily => 'btree/xid8_ops', amproclefttype => 'xid8', + amprocrighttype => 'xid8', amprocnum => '4', amproc => 'btequalimage' }, + +# hash +{ amprocfamily => 'hash/bpchar_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '1', amproc => 'hashbpchar' }, +{ amprocfamily => 'hash/bpchar_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '2', + amproc => 'hashbpcharextended' }, +{ amprocfamily => 'hash/char_ops', amproclefttype => 'char', + amprocrighttype => 'char', amprocnum => '1', amproc => 'hashchar' }, +{ amprocfamily => 'hash/char_ops', amproclefttype => 'char', + amprocrighttype => 'char', amprocnum => '2', amproc => 'hashcharextended' }, +{ amprocfamily => 'hash/date_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '1', amproc => 'hashint4' }, +{ amprocfamily => 'hash/date_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '2', amproc => 'hashint4extended' }, +{ amprocfamily => 'hash/array_ops', amproclefttype => 'anyarray', + amprocrighttype => 'anyarray', amprocnum => '1', amproc => 'hash_array' }, +{ amprocfamily => 'hash/array_ops', amproclefttype => 'anyarray', + amprocrighttype => 'anyarray', amprocnum => '2', + amproc => 'hash_array_extended' }, +{ amprocfamily => 'hash/float_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '1', amproc => 'hashfloat4' }, +{ amprocfamily => 'hash/float_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '2', + amproc => 'hashfloat4extended' }, +{ amprocfamily => 'hash/float_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '1', amproc => 'hashfloat8' }, +{ amprocfamily => 'hash/float_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '2', + amproc => 'hashfloat8extended' }, +{ amprocfamily => 'hash/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '1', amproc => 'hashinet' }, +{ amprocfamily => 'hash/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '2', amproc => 'hashinetextended' }, +{ amprocfamily => 'hash/integer_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '1', amproc => 'hashint2' }, +{ amprocfamily => 'hash/integer_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '2', amproc => 'hashint2extended' }, +{ amprocfamily => 'hash/integer_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '1', amproc => 'hashint4' }, +{ amprocfamily => 'hash/integer_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '2', amproc => 'hashint4extended' }, +{ amprocfamily => 'hash/integer_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '1', amproc => 'hashint8' }, +{ amprocfamily => 'hash/integer_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '2', amproc => 'hashint8extended' }, +{ amprocfamily => 'hash/interval_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '1', amproc => 'interval_hash' }, +{ amprocfamily => 'hash/interval_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '2', + amproc => 'interval_hash_extended' }, +{ amprocfamily => 'hash/macaddr_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '1', amproc => 'hashmacaddr' }, +{ amprocfamily => 'hash/macaddr_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '2', + amproc => 'hashmacaddrextended' }, +{ amprocfamily => 'hash/oid_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '1', amproc => 'hashoid' }, +{ amprocfamily => 'hash/oid_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '2', amproc => 'hashoidextended' }, +{ amprocfamily => 'hash/oidvector_ops', amproclefttype => 'oidvector', + amprocrighttype => 'oidvector', amprocnum => '1', amproc => 'hashoidvector' }, +{ amprocfamily => 'hash/oidvector_ops', amproclefttype => 'oidvector', + amprocrighttype => 'oidvector', amprocnum => '2', + amproc => 'hashoidvectorextended' }, +{ amprocfamily => 'hash/text_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '1', amproc => 'hashtext' }, +{ amprocfamily => 'hash/text_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '2', amproc => 'hashtextextended' }, +{ amprocfamily => 'hash/text_ops', amproclefttype => 'name', + amprocrighttype => 'name', amprocnum => '1', amproc => 'hashname' }, +{ amprocfamily => 'hash/text_ops', amproclefttype => 'name', + amprocrighttype => 'name', amprocnum => '2', amproc => 'hashnameextended' }, +{ amprocfamily => 'hash/time_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '1', amproc => 'time_hash' }, +{ amprocfamily => 'hash/time_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '2', amproc => 'time_hash_extended' }, +{ amprocfamily => 'hash/numeric_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '1', amproc => 'hash_numeric' }, +{ amprocfamily => 'hash/numeric_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '2', + amproc => 'hash_numeric_extended' }, +{ amprocfamily => 'hash/timestamptz_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '1', + amproc => 'timestamp_hash' }, +{ amprocfamily => 'hash/timestamptz_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '2', + amproc => 'timestamp_hash_extended' }, +{ amprocfamily => 'hash/timetz_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '1', amproc => 'timetz_hash' }, +{ amprocfamily => 'hash/timetz_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '2', + amproc => 'timetz_hash_extended' }, +{ amprocfamily => 'hash/timestamp_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '1', + amproc => 'timestamp_hash' }, +{ amprocfamily => 'hash/timestamp_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '2', + amproc => 'timestamp_hash_extended' }, +{ amprocfamily => 'hash/bool_ops', amproclefttype => 'bool', + amprocrighttype => 'bool', amprocnum => '1', amproc => 'hashchar' }, +{ amprocfamily => 'hash/bool_ops', amproclefttype => 'bool', + amprocrighttype => 'bool', amprocnum => '2', amproc => 'hashcharextended' }, +{ amprocfamily => 'hash/bytea_ops', amproclefttype => 'bytea', + amprocrighttype => 'bytea', amprocnum => '1', amproc => 'hashvarlena' }, +{ amprocfamily => 'hash/bytea_ops', amproclefttype => 'bytea', + amprocrighttype => 'bytea', amprocnum => '2', + amproc => 'hashvarlenaextended' }, +{ amprocfamily => 'hash/xid_ops', amproclefttype => 'xid', + amprocrighttype => 'xid', amprocnum => '1', amproc => 'hashint4' }, +{ amprocfamily => 'hash/xid_ops', amproclefttype => 'xid', + amprocrighttype => 'xid', amprocnum => '2', amproc => 'hashint4extended' }, +{ amprocfamily => 'hash/xid8_ops', amproclefttype => 'xid8', + amprocrighttype => 'xid8', amprocnum => '1', amproc => 'hashint8' }, +{ amprocfamily => 'hash/xid8_ops', amproclefttype => 'xid8', + amprocrighttype => 'xid8', amprocnum => '2', amproc => 'hashint8extended' }, +{ amprocfamily => 'hash/cid_ops', amproclefttype => 'cid', + amprocrighttype => 'cid', amprocnum => '1', amproc => 'hashint4' }, +{ amprocfamily => 'hash/cid_ops', amproclefttype => 'cid', + amprocrighttype => 'cid', amprocnum => '2', amproc => 'hashint4extended' }, +{ amprocfamily => 'hash/tid_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '1', amproc => 'hashtid' }, +{ amprocfamily => 'hash/tid_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '2', amproc => 'hashtidextended' }, +{ amprocfamily => 'hash/text_pattern_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '1', amproc => 'hashtext' }, +{ amprocfamily => 'hash/text_pattern_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '2', amproc => 'hashtextextended' }, +{ amprocfamily => 'hash/bpchar_pattern_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '1', amproc => 'hashbpchar' }, +{ amprocfamily => 'hash/bpchar_pattern_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '2', + amproc => 'hashbpcharextended' }, +{ amprocfamily => 'hash/aclitem_ops', amproclefttype => 'aclitem', + amprocrighttype => 'aclitem', amprocnum => '1', amproc => 'hash_aclitem' }, +{ amprocfamily => 'hash/aclitem_ops', amproclefttype => 'aclitem', + amprocrighttype => 'aclitem', amprocnum => '2', + amproc => 'hash_aclitem_extended' }, +{ amprocfamily => 'hash/uuid_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '1', amproc => 'uuid_hash' }, +{ amprocfamily => 'hash/uuid_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '2', amproc => 'uuid_hash_extended' }, +{ amprocfamily => 'hash/pg_lsn_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '1', amproc => 'pg_lsn_hash' }, +{ amprocfamily => 'hash/pg_lsn_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '2', + amproc => 'pg_lsn_hash_extended' }, +{ amprocfamily => 'hash/macaddr8_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '1', amproc => 'hashmacaddr8' }, +{ amprocfamily => 'hash/macaddr8_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '2', + amproc => 'hashmacaddr8extended' }, +{ amprocfamily => 'hash/enum_ops', amproclefttype => 'anyenum', + amprocrighttype => 'anyenum', amprocnum => '1', amproc => 'hashenum' }, +{ amprocfamily => 'hash/enum_ops', amproclefttype => 'anyenum', + amprocrighttype => 'anyenum', amprocnum => '2', + amproc => 'hashenumextended' }, +{ amprocfamily => 'hash/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '1', amproc => 'hash_range' }, +{ amprocfamily => 'hash/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '2', + amproc => 'hash_range_extended' }, +{ amprocfamily => 'hash/jsonb_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '1', amproc => 'jsonb_hash' }, +{ amprocfamily => 'hash/jsonb_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '2', + amproc => 'jsonb_hash_extended' }, + +# gist +{ amprocfamily => 'gist/point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '1', + amproc => 'gist_point_consistent' }, +{ amprocfamily => 'gist/point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '2', amproc => 'gist_box_union' }, +{ amprocfamily => 'gist/point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '3', + amproc => 'gist_point_compress' }, +{ amprocfamily => 'gist/point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '5', amproc => 'gist_box_penalty' }, +{ amprocfamily => 'gist/point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '6', + amproc => 'gist_box_picksplit' }, +{ amprocfamily => 'gist/point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '7', amproc => 'gist_box_same' }, +{ amprocfamily => 'gist/point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '8', + amproc => 'gist_point_distance' }, +{ amprocfamily => 'gist/point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '9', amproc => 'gist_point_fetch' }, +{ amprocfamily => 'gist/box_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '1', amproc => 'gist_box_consistent' }, +{ amprocfamily => 'gist/box_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '2', amproc => 'gist_box_union' }, +{ amprocfamily => 'gist/box_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '5', amproc => 'gist_box_penalty' }, +{ amprocfamily => 'gist/box_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '6', amproc => 'gist_box_picksplit' }, +{ amprocfamily => 'gist/box_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '7', amproc => 'gist_box_same' }, +{ amprocfamily => 'gist/box_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '8', amproc => 'gist_box_distance' }, +{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '1', + amproc => 'gist_poly_consistent' }, +{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '2', amproc => 'gist_box_union' }, +{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '3', + amproc => 'gist_poly_compress' }, +{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '5', + amproc => 'gist_box_penalty' }, +{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '6', + amproc => 'gist_box_picksplit' }, +{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '7', amproc => 'gist_box_same' }, +{ amprocfamily => 'gist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '8', + amproc => 'gist_poly_distance' }, +{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle', + amprocrighttype => 'circle', amprocnum => '1', + amproc => 'gist_circle_consistent' }, +{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle', + amprocrighttype => 'circle', amprocnum => '2', amproc => 'gist_box_union' }, +{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle', + amprocrighttype => 'circle', amprocnum => '3', + amproc => 'gist_circle_compress' }, +{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle', + amprocrighttype => 'circle', amprocnum => '5', amproc => 'gist_box_penalty' }, +{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle', + amprocrighttype => 'circle', amprocnum => '6', + amproc => 'gist_box_picksplit' }, +{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle', + amprocrighttype => 'circle', amprocnum => '7', amproc => 'gist_box_same' }, +{ amprocfamily => 'gist/circle_ops', amproclefttype => 'circle', + amprocrighttype => 'circle', amprocnum => '8', + amproc => 'gist_circle_distance' }, +{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '1', + amproc => 'gtsvector_consistent(internal,tsvector,int2,oid,internal)' }, +{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '2', + amproc => 'gtsvector_union' }, +{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '3', + amproc => 'gtsvector_compress' }, +{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '4', + amproc => 'gtsvector_decompress' }, +{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '5', + amproc => 'gtsvector_penalty' }, +{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '6', + amproc => 'gtsvector_picksplit' }, +{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '7', amproc => 'gtsvector_same' }, +{ amprocfamily => 'gist/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '10', + amproc => 'gtsvector_options' }, +{ amprocfamily => 'gist/tsquery_ops', amproclefttype => 'tsquery', + amprocrighttype => 'tsquery', amprocnum => '1', + amproc => 'gtsquery_consistent(internal,tsquery,int2,oid,internal)' }, +{ amprocfamily => 'gist/tsquery_ops', amproclefttype => 'tsquery', + amprocrighttype => 'tsquery', amprocnum => '2', amproc => 'gtsquery_union' }, +{ amprocfamily => 'gist/tsquery_ops', amproclefttype => 'tsquery', + amprocrighttype => 'tsquery', amprocnum => '3', + amproc => 'gtsquery_compress' }, +{ amprocfamily => 'gist/tsquery_ops', amproclefttype => 'tsquery', + amprocrighttype => 'tsquery', amprocnum => '5', + amproc => 'gtsquery_penalty' }, +{ amprocfamily => 'gist/tsquery_ops', amproclefttype => 'tsquery', + amprocrighttype => 'tsquery', amprocnum => '6', + amproc => 'gtsquery_picksplit' }, +{ amprocfamily => 'gist/tsquery_ops', amproclefttype => 'tsquery', + amprocrighttype => 'tsquery', amprocnum => '7', amproc => 'gtsquery_same' }, +{ amprocfamily => 'gist/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '1', + amproc => 'range_gist_consistent' }, +{ amprocfamily => 'gist/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '2', + amproc => 'range_gist_union' }, +{ amprocfamily => 'gist/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '5', + amproc => 'range_gist_penalty' }, +{ amprocfamily => 'gist/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '6', + amproc => 'range_gist_picksplit' }, +{ amprocfamily => 'gist/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '7', + amproc => 'range_gist_same' }, +{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '1', + amproc => 'inet_gist_consistent' }, +{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '2', amproc => 'inet_gist_union' }, +{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '3', amproc => 'inet_gist_compress' }, +{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '5', amproc => 'inet_gist_penalty' }, +{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '6', + amproc => 'inet_gist_picksplit' }, +{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '7', amproc => 'inet_gist_same' }, +{ amprocfamily => 'gist/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '9', amproc => 'inet_gist_fetch' }, + +# gin +{ amprocfamily => 'gin/array_ops', amproclefttype => 'anyarray', + amprocrighttype => 'anyarray', amprocnum => '2', + amproc => 'ginarrayextract(anyarray,internal,internal)' }, +{ amprocfamily => 'gin/array_ops', amproclefttype => 'anyarray', + amprocrighttype => 'anyarray', amprocnum => '3', + amproc => 'ginqueryarrayextract' }, +{ amprocfamily => 'gin/array_ops', amproclefttype => 'anyarray', + amprocrighttype => 'anyarray', amprocnum => '4', + amproc => 'ginarrayconsistent' }, +{ amprocfamily => 'gin/array_ops', amproclefttype => 'anyarray', + amprocrighttype => 'anyarray', amprocnum => '6', + amproc => 'ginarraytriconsistent' }, +{ amprocfamily => 'gin/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '1', + amproc => 'gin_cmp_tslexeme' }, +{ amprocfamily => 'gin/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '2', + amproc => 'gin_extract_tsvector(tsvector,internal,internal)' }, +{ amprocfamily => 'gin/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '3', + amproc => 'gin_extract_tsquery(tsvector,internal,int2,internal,internal,internal,internal)' }, +{ amprocfamily => 'gin/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '4', + amproc => 'gin_tsquery_consistent(internal,int2,tsvector,int4,internal,internal,internal,internal)' }, +{ amprocfamily => 'gin/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '5', amproc => 'gin_cmp_prefix' }, +{ amprocfamily => 'gin/tsvector_ops', amproclefttype => 'tsvector', + amprocrighttype => 'tsvector', amprocnum => '6', + amproc => 'gin_tsquery_triconsistent' }, +{ amprocfamily => 'gin/jsonb_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '1', amproc => 'gin_compare_jsonb' }, +{ amprocfamily => 'gin/jsonb_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '2', amproc => 'gin_extract_jsonb' }, +{ amprocfamily => 'gin/jsonb_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '3', + amproc => 'gin_extract_jsonb_query' }, +{ amprocfamily => 'gin/jsonb_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '4', + amproc => 'gin_consistent_jsonb' }, +{ amprocfamily => 'gin/jsonb_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '6', + amproc => 'gin_triconsistent_jsonb' }, +{ amprocfamily => 'gin/jsonb_path_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '1', amproc => 'btint4cmp' }, +{ amprocfamily => 'gin/jsonb_path_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '2', + amproc => 'gin_extract_jsonb_path' }, +{ amprocfamily => 'gin/jsonb_path_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '3', + amproc => 'gin_extract_jsonb_query_path' }, +{ amprocfamily => 'gin/jsonb_path_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '4', + amproc => 'gin_consistent_jsonb_path' }, +{ amprocfamily => 'gin/jsonb_path_ops', amproclefttype => 'jsonb', + amprocrighttype => 'jsonb', amprocnum => '6', + amproc => 'gin_triconsistent_jsonb_path' }, + +# sp-gist +{ amprocfamily => 'spgist/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '1', + amproc => 'spg_range_quad_config' }, +{ amprocfamily => 'spgist/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '2', + amproc => 'spg_range_quad_choose' }, +{ amprocfamily => 'spgist/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '3', + amproc => 'spg_range_quad_picksplit' }, +{ amprocfamily => 'spgist/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '4', + amproc => 'spg_range_quad_inner_consistent' }, +{ amprocfamily => 'spgist/range_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '5', + amproc => 'spg_range_quad_leaf_consistent' }, +{ amprocfamily => 'spgist/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '1', amproc => 'inet_spg_config' }, +{ amprocfamily => 'spgist/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '2', amproc => 'inet_spg_choose' }, +{ amprocfamily => 'spgist/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '3', amproc => 'inet_spg_picksplit' }, +{ amprocfamily => 'spgist/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '4', + amproc => 'inet_spg_inner_consistent' }, +{ amprocfamily => 'spgist/network_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '5', + amproc => 'inet_spg_leaf_consistent' }, +{ amprocfamily => 'spgist/quad_point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '1', amproc => 'spg_quad_config' }, +{ amprocfamily => 'spgist/quad_point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '2', amproc => 'spg_quad_choose' }, +{ amprocfamily => 'spgist/quad_point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '3', + amproc => 'spg_quad_picksplit' }, +{ amprocfamily => 'spgist/quad_point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '4', + amproc => 'spg_quad_inner_consistent' }, +{ amprocfamily => 'spgist/quad_point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '5', + amproc => 'spg_quad_leaf_consistent' }, +{ amprocfamily => 'spgist/kd_point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '1', amproc => 'spg_kd_config' }, +{ amprocfamily => 'spgist/kd_point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '2', amproc => 'spg_kd_choose' }, +{ amprocfamily => 'spgist/kd_point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '3', amproc => 'spg_kd_picksplit' }, +{ amprocfamily => 'spgist/kd_point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '4', + amproc => 'spg_kd_inner_consistent' }, +{ amprocfamily => 'spgist/kd_point_ops', amproclefttype => 'point', + amprocrighttype => 'point', amprocnum => '5', + amproc => 'spg_quad_leaf_consistent' }, +{ amprocfamily => 'spgist/text_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '1', amproc => 'spg_text_config' }, +{ amprocfamily => 'spgist/text_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '2', amproc => 'spg_text_choose' }, +{ amprocfamily => 'spgist/text_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '3', amproc => 'spg_text_picksplit' }, +{ amprocfamily => 'spgist/text_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '4', + amproc => 'spg_text_inner_consistent' }, +{ amprocfamily => 'spgist/text_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '5', + amproc => 'spg_text_leaf_consistent' }, +{ amprocfamily => 'spgist/box_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '1', amproc => 'spg_box_quad_config' }, +{ amprocfamily => 'spgist/box_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '2', amproc => 'spg_box_quad_choose' }, +{ amprocfamily => 'spgist/box_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '3', + amproc => 'spg_box_quad_picksplit' }, +{ amprocfamily => 'spgist/box_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '4', + amproc => 'spg_box_quad_inner_consistent' }, +{ amprocfamily => 'spgist/box_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '5', + amproc => 'spg_box_quad_leaf_consistent' }, +{ amprocfamily => 'spgist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '1', + amproc => 'spg_bbox_quad_config' }, +{ amprocfamily => 'spgist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '2', + amproc => 'spg_box_quad_choose' }, +{ amprocfamily => 'spgist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '3', + amproc => 'spg_box_quad_picksplit' }, +{ amprocfamily => 'spgist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '4', + amproc => 'spg_box_quad_inner_consistent' }, +{ amprocfamily => 'spgist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '5', + amproc => 'spg_box_quad_leaf_consistent' }, +{ amprocfamily => 'spgist/poly_ops', amproclefttype => 'polygon', + amprocrighttype => 'polygon', amprocnum => '6', + amproc => 'spg_poly_quad_compress' }, + +# BRIN opclasses + +# minmax bytea +{ amprocfamily => 'brin/bytea_minmax_ops', amproclefttype => 'bytea', + amprocrighttype => 'bytea', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/bytea_minmax_ops', amproclefttype => 'bytea', + amprocrighttype => 'bytea', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/bytea_minmax_ops', amproclefttype => 'bytea', + amprocrighttype => 'bytea', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/bytea_minmax_ops', amproclefttype => 'bytea', + amprocrighttype => 'bytea', amprocnum => '4', amproc => 'brin_minmax_union' }, + +# minmax "char" +{ amprocfamily => 'brin/char_minmax_ops', amproclefttype => 'char', + amprocrighttype => 'char', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/char_minmax_ops', amproclefttype => 'char', + amprocrighttype => 'char', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/char_minmax_ops', amproclefttype => 'char', + amprocrighttype => 'char', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/char_minmax_ops', amproclefttype => 'char', + amprocrighttype => 'char', amprocnum => '4', amproc => 'brin_minmax_union' }, + +# minmax name +{ amprocfamily => 'brin/name_minmax_ops', amproclefttype => 'name', + amprocrighttype => 'name', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/name_minmax_ops', amproclefttype => 'name', + amprocrighttype => 'name', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/name_minmax_ops', amproclefttype => 'name', + amprocrighttype => 'name', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/name_minmax_ops', amproclefttype => 'name', + amprocrighttype => 'name', amprocnum => '4', amproc => 'brin_minmax_union' }, + +# minmax integer: int2, int4, int8 +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8', + amprocrighttype => 'int8', amprocnum => '4', amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8', + amprocrighttype => 'int2', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8', + amprocrighttype => 'int2', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8', + amprocrighttype => 'int2', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8', + amprocrighttype => 'int2', amprocnum => '4', amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8', + amprocrighttype => 'int4', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8', + amprocrighttype => 'int4', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8', + amprocrighttype => 'int4', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int8', + amprocrighttype => 'int4', amprocnum => '4', amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2', + amprocrighttype => 'int2', amprocnum => '4', amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2', + amprocrighttype => 'int8', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2', + amprocrighttype => 'int8', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2', + amprocrighttype => 'int8', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2', + amprocrighttype => 'int8', amprocnum => '4', amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2', + amprocrighttype => 'int4', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2', + amprocrighttype => 'int4', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2', + amprocrighttype => 'int4', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int2', + amprocrighttype => 'int4', amprocnum => '4', amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', + amprocrighttype => 'int4', amprocnum => '4', amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', + amprocrighttype => 'int8', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', + amprocrighttype => 'int8', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', + amprocrighttype => 'int8', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', + amprocrighttype => 'int8', amprocnum => '4', amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', + amprocrighttype => 'int2', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', + amprocrighttype => 'int2', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', + amprocrighttype => 'int2', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/integer_minmax_ops', amproclefttype => 'int4', + amprocrighttype => 'int2', amprocnum => '4', amproc => 'brin_minmax_union' }, + +# minmax text +{ amprocfamily => 'brin/text_minmax_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/text_minmax_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/text_minmax_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/text_minmax_ops', amproclefttype => 'text', + amprocrighttype => 'text', amprocnum => '4', amproc => 'brin_minmax_union' }, + +# minmax oid +{ amprocfamily => 'brin/oid_minmax_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '1', amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/oid_minmax_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/oid_minmax_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/oid_minmax_ops', amproclefttype => 'oid', + amprocrighttype => 'oid', amprocnum => '4', amproc => 'brin_minmax_union' }, + +# minmax tid +{ amprocfamily => 'brin/tid_minmax_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '1', amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/tid_minmax_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/tid_minmax_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/tid_minmax_ops', amproclefttype => 'tid', + amprocrighttype => 'tid', amprocnum => '4', amproc => 'brin_minmax_union' }, + +# minmax float +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4', + amprocrighttype => 'float4', amprocnum => '4', + amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4', + amprocrighttype => 'float8', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4', + amprocrighttype => 'float8', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4', + amprocrighttype => 'float8', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float4', + amprocrighttype => 'float8', amprocnum => '4', + amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8', + amprocrighttype => 'float8', amprocnum => '4', + amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8', + amprocrighttype => 'float4', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8', + amprocrighttype => 'float4', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8', + amprocrighttype => 'float4', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/float_minmax_ops', amproclefttype => 'float8', + amprocrighttype => 'float4', amprocnum => '4', + amproc => 'brin_minmax_union' }, + +# minmax macaddr +{ amprocfamily => 'brin/macaddr_minmax_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/macaddr_minmax_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/macaddr_minmax_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/macaddr_minmax_ops', amproclefttype => 'macaddr', + amprocrighttype => 'macaddr', amprocnum => '4', + amproc => 'brin_minmax_union' }, + +# minmax macaddr8 +{ amprocfamily => 'brin/macaddr8_minmax_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/macaddr8_minmax_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/macaddr8_minmax_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/macaddr8_minmax_ops', amproclefttype => 'macaddr8', + amprocrighttype => 'macaddr8', amprocnum => '4', + amproc => 'brin_minmax_union' }, + +# minmax inet +{ amprocfamily => 'brin/network_minmax_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/network_minmax_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/network_minmax_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/network_minmax_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '4', amproc => 'brin_minmax_union' }, + +# inclusion inet +{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '1', + amproc => 'brin_inclusion_opcinfo' }, +{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '2', + amproc => 'brin_inclusion_add_value' }, +{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '3', + amproc => 'brin_inclusion_consistent' }, +{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '4', + amproc => 'brin_inclusion_union' }, +{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '11', amproc => 'inet_merge' }, +{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '12', amproc => 'inet_same_family' }, +{ amprocfamily => 'brin/network_inclusion_ops', amproclefttype => 'inet', + amprocrighttype => 'inet', amprocnum => '13', amproc => 'network_supeq' }, + +# minmax character +{ amprocfamily => 'brin/bpchar_minmax_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/bpchar_minmax_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/bpchar_minmax_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/bpchar_minmax_ops', amproclefttype => 'bpchar', + amprocrighttype => 'bpchar', amprocnum => '4', + amproc => 'brin_minmax_union' }, + +# minmax time without time zone +{ amprocfamily => 'brin/time_minmax_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/time_minmax_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/time_minmax_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/time_minmax_ops', amproclefttype => 'time', + amprocrighttype => 'time', amprocnum => '4', amproc => 'brin_minmax_union' }, + +# minmax datetime (date, timestamp, timestamptz) +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamp', amprocnum => '4', + amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamptz', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamptz', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamptz', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp', + amprocrighttype => 'timestamptz', amprocnum => '4', + amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp', + amprocrighttype => 'date', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp', + amprocrighttype => 'date', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp', + amprocrighttype => 'date', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamp', + amprocrighttype => 'date', amprocnum => '4', amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamptz', amprocnum => '4', + amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamp', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamp', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamp', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'timestamp', amprocnum => '4', + amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'date', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'date', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'date', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'timestamptz', + amprocrighttype => 'date', amprocnum => '4', amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date', + amprocrighttype => 'date', amprocnum => '4', amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date', + amprocrighttype => 'timestamp', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date', + amprocrighttype => 'timestamp', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date', + amprocrighttype => 'timestamp', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date', + amprocrighttype => 'timestamp', amprocnum => '4', + amproc => 'brin_minmax_union' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date', + amprocrighttype => 'timestamptz', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date', + amprocrighttype => 'timestamptz', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date', + amprocrighttype => 'timestamptz', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/datetime_minmax_ops', amproclefttype => 'date', + amprocrighttype => 'timestamptz', amprocnum => '4', + amproc => 'brin_minmax_union' }, + +# minmax interval +{ amprocfamily => 'brin/interval_minmax_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/interval_minmax_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/interval_minmax_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/interval_minmax_ops', amproclefttype => 'interval', + amprocrighttype => 'interval', amprocnum => '4', + amproc => 'brin_minmax_union' }, + +# minmax time with time zone +{ amprocfamily => 'brin/timetz_minmax_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/timetz_minmax_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/timetz_minmax_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/timetz_minmax_ops', amproclefttype => 'timetz', + amprocrighttype => 'timetz', amprocnum => '4', + amproc => 'brin_minmax_union' }, + +# minmax bit +{ amprocfamily => 'brin/bit_minmax_ops', amproclefttype => 'bit', + amprocrighttype => 'bit', amprocnum => '1', amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/bit_minmax_ops', amproclefttype => 'bit', + amprocrighttype => 'bit', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/bit_minmax_ops', amproclefttype => 'bit', + amprocrighttype => 'bit', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/bit_minmax_ops', amproclefttype => 'bit', + amprocrighttype => 'bit', amprocnum => '4', amproc => 'brin_minmax_union' }, + +# minmax bit varying +{ amprocfamily => 'brin/varbit_minmax_ops', amproclefttype => 'varbit', + amprocrighttype => 'varbit', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/varbit_minmax_ops', amproclefttype => 'varbit', + amprocrighttype => 'varbit', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/varbit_minmax_ops', amproclefttype => 'varbit', + amprocrighttype => 'varbit', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/varbit_minmax_ops', amproclefttype => 'varbit', + amprocrighttype => 'varbit', amprocnum => '4', + amproc => 'brin_minmax_union' }, + +# minmax numeric +{ amprocfamily => 'brin/numeric_minmax_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/numeric_minmax_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/numeric_minmax_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/numeric_minmax_ops', amproclefttype => 'numeric', + amprocrighttype => 'numeric', amprocnum => '4', + amproc => 'brin_minmax_union' }, + +# minmax uuid +{ amprocfamily => 'brin/uuid_minmax_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/uuid_minmax_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/uuid_minmax_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/uuid_minmax_ops', amproclefttype => 'uuid', + amprocrighttype => 'uuid', amprocnum => '4', amproc => 'brin_minmax_union' }, + +# inclusion range types +{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '1', + amproc => 'brin_inclusion_opcinfo' }, +{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '2', + amproc => 'brin_inclusion_add_value' }, +{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '3', + amproc => 'brin_inclusion_consistent' }, +{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '4', + amproc => 'brin_inclusion_union' }, +{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '11', amproc => 'range_merge' }, +{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '13', + amproc => 'range_contains' }, +{ amprocfamily => 'brin/range_inclusion_ops', amproclefttype => 'anyrange', + amprocrighttype => 'anyrange', amprocnum => '14', amproc => 'isempty' }, + +# minmax pg_lsn +{ amprocfamily => 'brin/pg_lsn_minmax_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '1', + amproc => 'brin_minmax_opcinfo' }, +{ amprocfamily => 'brin/pg_lsn_minmax_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '2', + amproc => 'brin_minmax_add_value' }, +{ amprocfamily => 'brin/pg_lsn_minmax_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '3', + amproc => 'brin_minmax_consistent' }, +{ amprocfamily => 'brin/pg_lsn_minmax_ops', amproclefttype => 'pg_lsn', + amprocrighttype => 'pg_lsn', amprocnum => '4', + amproc => 'brin_minmax_union' }, + +# inclusion box +{ amprocfamily => 'brin/box_inclusion_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '1', + amproc => 'brin_inclusion_opcinfo' }, +{ amprocfamily => 'brin/box_inclusion_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '2', + amproc => 'brin_inclusion_add_value' }, +{ amprocfamily => 'brin/box_inclusion_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '3', + amproc => 'brin_inclusion_consistent' }, +{ amprocfamily => 'brin/box_inclusion_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '4', + amproc => 'brin_inclusion_union' }, +{ amprocfamily => 'brin/box_inclusion_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '11', amproc => 'bound_box' }, +{ amprocfamily => 'brin/box_inclusion_ops', amproclefttype => 'box', + amprocrighttype => 'box', amprocnum => '13', amproc => 'box_contain' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_amproc.h b/contrib/libs/postgresql/src/include/catalog/pg_amproc.h new file mode 100644 index 0000000000..e39bd70c29 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_amproc.h @@ -0,0 +1,70 @@ +/*------------------------------------------------------------------------- + * + * pg_amproc.h + * definition of the "access method procedure" system catalog (pg_amproc) + * + * The amproc table identifies support procedures associated with index + * operator families and classes. These procedures can't be listed in pg_amop + * since they are not the implementation of any indexable operator. + * + * The primary key for this table is <amprocfamily, amproclefttype, + * amprocrighttype, amprocnum>. The "default" support functions for a + * particular opclass within the family are those with amproclefttype = + * amprocrighttype = opclass's opcintype. These are the ones loaded into the + * relcache for an index and typically used for internal index operations. + * Other support functions are typically used to handle cross-type indexable + * operators with oprleft/oprright matching the entry's amproclefttype and + * amprocrighttype. The exact behavior depends on the index AM, however, and + * some don't pay attention to non-default functions at all. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_amproc.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_AMPROC_H +#define PG_AMPROC_H + +#include "catalog/genbki.h" +#include "catalog/pg_amproc_d.h" + +/* ---------------- + * pg_amproc definition. cpp turns this into + * typedef struct FormData_pg_amproc + * ---------------- + */ +CATALOG(pg_amproc,2603,AccessMethodProcedureRelationId) +{ + Oid oid; /* oid */ + + /* the index opfamily this entry is for */ + Oid amprocfamily BKI_LOOKUP(pg_opfamily); + + /* procedure's left input data type */ + Oid amproclefttype BKI_LOOKUP(pg_type); + + /* procedure's right input data type */ + Oid amprocrighttype BKI_LOOKUP(pg_type); + + /* support procedure index */ + int16 amprocnum; + + /* OID of the proc */ + regproc amproc BKI_LOOKUP(pg_proc); +} FormData_pg_amproc; + +/* ---------------- + * Form_pg_amproc corresponds to a pointer to a tuple with + * the format of pg_amproc relation. + * ---------------- + */ +typedef FormData_pg_amproc *Form_pg_amproc; + +#endif /* PG_AMPROC_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_amproc_d.h b/contrib/libs/postgresql/src/include/catalog/pg_amproc_d.h new file mode 100644 index 0000000000..7df62bb78f --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_amproc_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_amproc_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_attrdef.h b/contrib/libs/postgresql/src/include/catalog/pg_attrdef.h new file mode 100644 index 0000000000..7b661df311 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_attrdef.h @@ -0,0 +1,49 @@ +/*------------------------------------------------------------------------- + * + * pg_attrdef.h + * definition of the "attribute defaults" system catalog (pg_attrdef) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_attrdef.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_ATTRDEF_H +#define PG_ATTRDEF_H + +#include "catalog/genbki.h" +#include "catalog/pg_attrdef_d.h" + +/* ---------------- + * pg_attrdef definition. cpp turns this into + * typedef struct FormData_pg_attrdef + * ---------------- + */ +CATALOG(pg_attrdef,2604,AttrDefaultRelationId) +{ + Oid oid; /* oid */ + + Oid adrelid; /* OID of table containing attribute */ + int16 adnum; /* attnum of attribute */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + pg_node_tree adbin BKI_FORCE_NOT_NULL; /* nodeToString representation of + * default */ +#endif +} FormData_pg_attrdef; + +/* ---------------- + * Form_pg_attrdef corresponds to a pointer to a tuple with + * the format of pg_attrdef relation. + * ---------------- + */ +typedef FormData_pg_attrdef *Form_pg_attrdef; + +#endif /* PG_ATTRDEF_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_attrdef_d.h b/contrib/libs/postgresql/src/include/catalog/pg_attrdef_d.h new file mode 100644 index 0000000000..a5544bf1e0 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_attrdef_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_attrdef_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_attribute.h b/contrib/libs/postgresql/src/include/catalog/pg_attribute.h new file mode 100644 index 0000000000..a4cc80adad --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_attribute.h @@ -0,0 +1,204 @@ +/*------------------------------------------------------------------------- + * + * pg_attribute.h + * definition of the "attribute" system catalog (pg_attribute) + * + * The initial contents of pg_attribute are generated at compile time by + * genbki.pl, so there is no pg_attribute.dat file. Only "bootstrapped" + * relations need be included. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_attribute.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_ATTRIBUTE_H +#define PG_ATTRIBUTE_H + +#include "catalog/genbki.h" +#include "catalog/pg_attribute_d.h" + +/* ---------------- + * pg_attribute definition. cpp turns this into + * typedef struct FormData_pg_attribute + * + * If you change the following, make sure you change the structs for + * system attributes in catalog/heap.c also. + * You may need to change catalog/genbki.pl as well. + * ---------------- + */ +CATALOG(pg_attribute,1249,AttributeRelationId) BKI_BOOTSTRAP BKI_ROWTYPE_OID(75,AttributeRelation_Rowtype_Id) BKI_SCHEMA_MACRO +{ + Oid attrelid; /* OID of relation containing this attribute */ + NameData attname; /* name of attribute */ + + /* + * atttypid is the OID of the instance in Catalog Class pg_type that + * defines the data type of this attribute (e.g. int4). Information in + * that instance is redundant with the attlen, attbyval, and attalign + * attributes of this instance, so they had better match or Postgres will + * fail. + */ + Oid atttypid; + + /* + * attstattarget is the target number of statistics datapoints to collect + * during VACUUM ANALYZE of this column. A zero here indicates that we do + * not wish to collect any stats about this column. A "-1" here indicates + * that no value has been explicitly set for this column, so ANALYZE + * should use the default setting. + */ + int32 attstattarget BKI_DEFAULT(-1); + + /* + * attlen is a copy of the typlen field from pg_type for this attribute. + * See atttypid comments above. + */ + int16 attlen; + + /* + * attnum is the "attribute number" for the attribute: A value that + * uniquely identifies this attribute within its class. For user + * attributes, Attribute numbers are greater than 0 and not greater than + * the number of attributes in the class. I.e. if the Class pg_class says + * that Class XYZ has 10 attributes, then the user attribute numbers in + * Class pg_attribute must be 1-10. + * + * System attributes have attribute numbers less than 0 that are unique + * within the class, but not constrained to any particular range. + * + * Note that (attnum - 1) is often used as the index to an array. + */ + int16 attnum; + + /* + * attndims is the declared number of dimensions, if an array type, + * otherwise zero. + */ + int32 attndims; + + /* + * fastgetattr() uses attcacheoff to cache byte offsets of attributes in + * heap tuples. The value actually stored in pg_attribute (-1) indicates + * no cached value. But when we copy these tuples into a tuple + * descriptor, we may then update attcacheoff in the copies. This speeds + * up the attribute walking process. + */ + int32 attcacheoff BKI_DEFAULT(-1); + + /* + * atttypmod records type-specific data supplied at table creation time + * (for example, the max length of a varchar field). It is passed to + * type-specific input and output functions as the third argument. The + * value will generally be -1 for types that do not need typmod. + */ + int32 atttypmod BKI_DEFAULT(-1); + + /* + * attbyval is a copy of the typbyval field from pg_type for this + * attribute. See atttypid comments above. + */ + bool attbyval; + + /*---------- + * attstorage tells for VARLENA attributes, what the heap access + * methods can do to it if a given tuple doesn't fit into a page. + * Possible values are as for pg_type.typstorage (see TYPSTORAGE macros). + *---------- + */ + char attstorage; + + /* + * attalign is a copy of the typalign field from pg_type for this + * attribute. See atttypid comments above. + */ + char attalign; + + /* This flag represents the "NOT NULL" constraint */ + bool attnotnull; + + /* Has DEFAULT value or not */ + bool atthasdef BKI_DEFAULT(f); + + /* Has a missing value or not */ + bool atthasmissing BKI_DEFAULT(f); + + /* One of the ATTRIBUTE_IDENTITY_* constants below, or '\0' */ + char attidentity BKI_DEFAULT('\0'); + + /* One of the ATTRIBUTE_GENERATED_* constants below, or '\0' */ + char attgenerated BKI_DEFAULT('\0'); + + /* Is dropped (ie, logically invisible) or not */ + bool attisdropped BKI_DEFAULT(f); + + /* + * This flag specifies whether this column has ever had a local + * definition. It is set for normal non-inherited columns, but also for + * columns that are inherited from parents if also explicitly listed in + * CREATE TABLE INHERITS. It is also set when inheritance is removed from + * a table with ALTER TABLE NO INHERIT. If the flag is set, the column is + * not dropped by a parent's DROP COLUMN even if this causes the column's + * attinhcount to become zero. + */ + bool attislocal BKI_DEFAULT(t); + + /* Number of times inherited from direct parent relation(s) */ + int32 attinhcount BKI_DEFAULT(0); + + /* attribute's collation */ + Oid attcollation; + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + /* NOTE: The following fields are not present in tuple descriptors. */ + + /* Column-level access permissions */ + aclitem attacl[1] BKI_DEFAULT(_null_); + + /* Column-level options */ + text attoptions[1] BKI_DEFAULT(_null_); + + /* Column-level FDW options */ + text attfdwoptions[1] BKI_DEFAULT(_null_); + + /* + * Missing value for added columns. This is a one element array which lets + * us store a value of the attribute type here. + */ + anyarray attmissingval BKI_DEFAULT(_null_); +#endif +} FormData_pg_attribute; + +/* + * ATTRIBUTE_FIXED_PART_SIZE is the size of the fixed-layout, + * guaranteed-not-null part of a pg_attribute row. This is in fact as much + * of the row as gets copied into tuple descriptors, so don't expect you + * can access fields beyond attcollation except in a real tuple! + */ +#define ATTRIBUTE_FIXED_PART_SIZE \ + (offsetof(FormData_pg_attribute,attcollation) + sizeof(Oid)) + +/* ---------------- + * Form_pg_attribute corresponds to a pointer to a tuple with + * the format of pg_attribute relation. + * ---------------- + */ +typedef FormData_pg_attribute *Form_pg_attribute; + +#ifdef EXPOSE_TO_CLIENT_CODE + +#define ATTRIBUTE_IDENTITY_ALWAYS 'a' +#define ATTRIBUTE_IDENTITY_BY_DEFAULT 'd' + +#define ATTRIBUTE_GENERATED_STORED 's' + +#endif /* EXPOSE_TO_CLIENT_CODE */ + +#endif /* PG_ATTRIBUTE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_attribute_d.h b/contrib/libs/postgresql/src/include/catalog/pg_attribute_d.h new file mode 100644 index 0000000000..2fea2c5e48 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_attribute_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_attribute_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_auth_members.h b/contrib/libs/postgresql/src/include/catalog/pg_auth_members.h new file mode 100644 index 0000000000..8563feb6c5 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_auth_members.h @@ -0,0 +1,45 @@ +/*------------------------------------------------------------------------- + * + * pg_auth_members.h + * definition of the "authorization identifier members" system catalog + * (pg_auth_members). + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_auth_members.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_AUTH_MEMBERS_H +#define PG_AUTH_MEMBERS_H + +#include "catalog/genbki.h" +#include "catalog/pg_auth_members_d.h" + +/* ---------------- + * pg_auth_members definition. cpp turns this into + * typedef struct FormData_pg_auth_members + * ---------------- + */ +CATALOG(pg_auth_members,1261,AuthMemRelationId) BKI_SHARED_RELATION BKI_ROWTYPE_OID(2843,AuthMemRelation_Rowtype_Id) BKI_SCHEMA_MACRO +{ + Oid roleid; /* ID of a role */ + Oid member; /* ID of a member of that role */ + Oid grantor; /* who granted the membership */ + bool admin_option; /* granted with admin option? */ +} FormData_pg_auth_members; + +/* ---------------- + * Form_pg_auth_members corresponds to a pointer to a tuple with + * the format of pg_auth_members relation. + * ---------------- + */ +typedef FormData_pg_auth_members *Form_pg_auth_members; + +#endif /* PG_AUTH_MEMBERS_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_auth_members_d.h b/contrib/libs/postgresql/src/include/catalog/pg_auth_members_d.h new file mode 100644 index 0000000000..8298e984f3 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_auth_members_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_auth_members_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_authid.dat b/contrib/libs/postgresql/src/include/catalog/pg_authid.dat new file mode 100644 index 0000000000..7c08851550 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_authid.dat @@ -0,0 +1,64 @@ +#---------------------------------------------------------------------- +# +# pg_authid.dat +# Initial contents of the pg_authid system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_authid.dat +# +#---------------------------------------------------------------------- + +[ + +# The C code typically refers to these roles using the #define symbols, +# so make sure every entry has an oid_symbol value. + +{ oid => '10', oid_symbol => 'BOOTSTRAP_SUPERUSERID', + rolname => 'POSTGRES', rolsuper => 't', rolinherit => 't', + rolcreaterole => 't', rolcreatedb => 't', rolcanlogin => 't', + rolreplication => 't', rolbypassrls => 't', rolconnlimit => '-1', + rolpassword => '_null_', rolvaliduntil => '_null_' }, +{ oid => '3373', oid_symbol => 'DEFAULT_ROLE_MONITOR', + rolname => 'pg_monitor', rolsuper => 'f', rolinherit => 't', + rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f', + rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1', + rolpassword => '_null_', rolvaliduntil => '_null_' }, +{ oid => '3374', oid_symbol => 'DEFAULT_ROLE_READ_ALL_SETTINGS', + rolname => 'pg_read_all_settings', rolsuper => 'f', rolinherit => 't', + rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f', + rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1', + rolpassword => '_null_', rolvaliduntil => '_null_' }, +{ oid => '3375', oid_symbol => 'DEFAULT_ROLE_READ_ALL_STATS', + rolname => 'pg_read_all_stats', rolsuper => 'f', rolinherit => 't', + rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f', + rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1', + rolpassword => '_null_', rolvaliduntil => '_null_' }, +{ oid => '3377', oid_symbol => 'DEFAULT_ROLE_STAT_SCAN_TABLES', + rolname => 'pg_stat_scan_tables', rolsuper => 'f', rolinherit => 't', + rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f', + rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1', + rolpassword => '_null_', rolvaliduntil => '_null_' }, +{ oid => '4569', oid_symbol => 'DEFAULT_ROLE_READ_SERVER_FILES', + rolname => 'pg_read_server_files', rolsuper => 'f', rolinherit => 't', + rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f', + rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1', + rolpassword => '_null_', rolvaliduntil => '_null_' }, +{ oid => '4570', oid_symbol => 'DEFAULT_ROLE_WRITE_SERVER_FILES', + rolname => 'pg_write_server_files', rolsuper => 'f', rolinherit => 't', + rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f', + rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1', + rolpassword => '_null_', rolvaliduntil => '_null_' }, +{ oid => '4571', oid_symbol => 'DEFAULT_ROLE_EXECUTE_SERVER_PROGRAM', + rolname => 'pg_execute_server_program', rolsuper => 'f', rolinherit => 't', + rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f', + rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1', + rolpassword => '_null_', rolvaliduntil => '_null_' }, +{ oid => '4200', oid_symbol => 'DEFAULT_ROLE_SIGNAL_BACKENDID', + rolname => 'pg_signal_backend', rolsuper => 'f', rolinherit => 't', + rolcreaterole => 'f', rolcreatedb => 'f', rolcanlogin => 'f', + rolreplication => 'f', rolbypassrls => 'f', rolconnlimit => '-1', + rolpassword => '_null_', rolvaliduntil => '_null_' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_authid.h b/contrib/libs/postgresql/src/include/catalog/pg_authid.h new file mode 100644 index 0000000000..88a5373080 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_authid.h @@ -0,0 +1,58 @@ +/*------------------------------------------------------------------------- + * + * pg_authid.h + * definition of the "authorization identifier" system catalog (pg_authid) + * + * pg_shadow and pg_group are now publicly accessible views on pg_authid. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_authid.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_AUTHID_H +#define PG_AUTHID_H + +#include "catalog/genbki.h" +#include "catalog/pg_authid_d.h" + +/* ---------------- + * pg_authid definition. cpp turns this into + * typedef struct FormData_pg_authid + * ---------------- + */ +CATALOG(pg_authid,1260,AuthIdRelationId) BKI_SHARED_RELATION BKI_ROWTYPE_OID(2842,AuthIdRelation_Rowtype_Id) BKI_SCHEMA_MACRO +{ + Oid oid; /* oid */ + NameData rolname; /* name of role */ + bool rolsuper; /* read this field via superuser() only! */ + bool rolinherit; /* inherit privileges from other roles? */ + bool rolcreaterole; /* allowed to create more roles? */ + bool rolcreatedb; /* allowed to create databases? */ + bool rolcanlogin; /* allowed to log in as session user? */ + bool rolreplication; /* role used for streaming replication */ + bool rolbypassrls; /* bypasses row level security? */ + int32 rolconnlimit; /* max connections allowed (-1=no limit) */ + + /* remaining fields may be null; use heap_getattr to read them! */ +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + text rolpassword; /* password, if any */ + timestamptz rolvaliduntil; /* password expiration time, if any */ +#endif +} FormData_pg_authid; + +/* ---------------- + * Form_pg_authid corresponds to a pointer to a tuple with + * the format of pg_authid relation. + * ---------------- + */ +typedef FormData_pg_authid *Form_pg_authid; + +#endif /* PG_AUTHID_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_authid_d.h b/contrib/libs/postgresql/src/include/catalog/pg_authid_d.h new file mode 100644 index 0000000000..ac7acb4f82 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_authid_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_authid_d.h" /* inclink generated by yamaker */ diff --git a/ydb/library/yql/parser/pg_catalog/pg_cast.dat b/contrib/libs/postgresql/src/include/catalog/pg_cast.dat index 5a58f50fbb..5a58f50fbb 100644 --- a/ydb/library/yql/parser/pg_catalog/pg_cast.dat +++ b/contrib/libs/postgresql/src/include/catalog/pg_cast.dat diff --git a/contrib/libs/postgresql/src/include/catalog/pg_cast.h b/contrib/libs/postgresql/src/include/catalog/pg_cast.h new file mode 100644 index 0000000000..2620ff40f0 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_cast.h @@ -0,0 +1,99 @@ +/*------------------------------------------------------------------------- + * + * pg_cast.h + * definition of the "type casts" system catalog (pg_cast) + * + * As of Postgres 8.0, pg_cast describes not only type coercion functions + * but also length coercion functions. + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_cast.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_CAST_H +#define PG_CAST_H + +#include "catalog/dependency.h" +#include "catalog/genbki.h" +#include "catalog/pg_cast_d.h" + +/* ---------------- + * pg_cast definition. cpp turns this into + * typedef struct FormData_pg_cast + * ---------------- + */ +CATALOG(pg_cast,2605,CastRelationId) +{ + Oid oid; /* oid */ + + /* source datatype for cast */ + Oid castsource BKI_LOOKUP(pg_type); + + /* destination datatype for cast */ + Oid casttarget BKI_LOOKUP(pg_type); + + /* cast function; 0 = binary coercible */ + Oid castfunc BKI_LOOKUP(pg_proc); + + /* contexts in which cast can be used */ + char castcontext; + + /* cast method */ + char castmethod; +} FormData_pg_cast; + +/* ---------------- + * Form_pg_cast corresponds to a pointer to a tuple with + * the format of pg_cast relation. + * ---------------- + */ +typedef FormData_pg_cast *Form_pg_cast; + +#ifdef EXPOSE_TO_CLIENT_CODE + +/* + * The allowable values for pg_cast.castcontext are specified by this enum. + * Since castcontext is stored as a "char", we use ASCII codes for human + * convenience in reading the table. Note that internally to the backend, + * these values are converted to the CoercionContext enum (see primnodes.h), + * which is defined to sort in a convenient order; the ASCII codes don't + * have to sort in any special order. + */ + +typedef enum CoercionCodes +{ + COERCION_CODE_IMPLICIT = 'i', /* coercion in context of expression */ + COERCION_CODE_ASSIGNMENT = 'a', /* coercion in context of assignment */ + COERCION_CODE_EXPLICIT = 'e' /* explicit cast operation */ +} CoercionCodes; + +/* + * The allowable values for pg_cast.castmethod are specified by this enum. + * Since castmethod is stored as a "char", we use ASCII codes for human + * convenience in reading the table. + */ +typedef enum CoercionMethod +{ + COERCION_METHOD_FUNCTION = 'f', /* use a function */ + COERCION_METHOD_BINARY = 'b', /* types are binary-compatible */ + COERCION_METHOD_INOUT = 'i' /* use input/output functions */ +} CoercionMethod; + +#endif /* EXPOSE_TO_CLIENT_CODE */ + + +extern ObjectAddress CastCreate(Oid sourcetypeid, + Oid targettypeid, + Oid funcid, + char castcontext, + char castmethod, + DependencyType behavior); + +#endif /* PG_CAST_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_cast_d.h b/contrib/libs/postgresql/src/include/catalog/pg_cast_d.h new file mode 100644 index 0000000000..c57c7aa932 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_cast_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_cast_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_class.dat b/contrib/libs/postgresql/src/include/catalog/pg_class.dat new file mode 100644 index 0000000000..b28bba7cc3 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_class.dat @@ -0,0 +1,28 @@ +#---------------------------------------------------------------------- +# +# pg_class.dat +# Initial contents of the pg_class system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_class.dat +# +#---------------------------------------------------------------------- + +[ + +# Note: only bootstrap catalogs, ie those marked BKI_BOOTSTRAP, need to +# have entries here. Be sure that the OIDs listed here match those given in +# their CATALOG and BKI_ROWTYPE_OID macros. + +{ oid => '1247', + relname => 'pg_type', reltype => 'pg_type' }, +{ oid => '1249', + relname => 'pg_attribute', reltype => 'pg_attribute' }, +{ oid => '1255', + relname => 'pg_proc', reltype => 'pg_proc' }, +{ oid => '1259', + relname => 'pg_class', reltype => 'pg_class' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_class.h b/contrib/libs/postgresql/src/include/catalog/pg_class.h new file mode 100644 index 0000000000..78b33b2a7f --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_class.h @@ -0,0 +1,200 @@ +/*------------------------------------------------------------------------- + * + * pg_class.h + * definition of the "relation" system catalog (pg_class) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_class.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_CLASS_H +#define PG_CLASS_H + +#include "catalog/genbki.h" +#include "catalog/pg_class_d.h" + +/* ---------------- + * pg_class definition. cpp turns this into + * typedef struct FormData_pg_class + * + * Note that the BKI_DEFAULT values below are only used for rows describing + * BKI_BOOTSTRAP catalogs, since only those rows appear in pg_class.dat. + * ---------------- + */ +CATALOG(pg_class,1259,RelationRelationId) BKI_BOOTSTRAP BKI_ROWTYPE_OID(83,RelationRelation_Rowtype_Id) BKI_SCHEMA_MACRO +{ + /* oid */ + Oid oid; + + /* class name */ + NameData relname; + + /* OID of namespace containing this class */ + Oid relnamespace BKI_DEFAULT(PGNSP); + + /* OID of entry in pg_type for table's implicit row type */ + Oid reltype BKI_LOOKUP(pg_type); + + /* OID of entry in pg_type for underlying composite type */ + Oid reloftype BKI_DEFAULT(0) BKI_LOOKUP(pg_type); + + /* class owner */ + Oid relowner BKI_DEFAULT(PGUID); + + /* access method; 0 if not a table / index */ + Oid relam BKI_DEFAULT(heap) BKI_LOOKUP(pg_am); + + /* identifier of physical storage file */ + /* relfilenode == 0 means it is a "mapped" relation, see relmapper.c */ + Oid relfilenode BKI_DEFAULT(0); + + /* identifier of table space for relation (0 means default for database) */ + Oid reltablespace BKI_DEFAULT(0) BKI_LOOKUP(pg_tablespace); + + /* # of blocks (not always up-to-date) */ + int32 relpages BKI_DEFAULT(0); + + /* # of tuples (not always up-to-date) */ + float4 reltuples BKI_DEFAULT(0); + + /* # of all-visible blocks (not always up-to-date) */ + int32 relallvisible BKI_DEFAULT(0); + + /* OID of toast table; 0 if none */ + Oid reltoastrelid BKI_DEFAULT(0); + + /* T if has (or has had) any indexes */ + bool relhasindex BKI_DEFAULT(f); + + /* T if shared across databases */ + bool relisshared BKI_DEFAULT(f); + + /* see RELPERSISTENCE_xxx constants below */ + char relpersistence BKI_DEFAULT(p); + + /* see RELKIND_xxx constants below */ + char relkind BKI_DEFAULT(r); + + /* number of user attributes */ + int16 relnatts BKI_DEFAULT(0); /* genbki.pl will fill this in */ + + /* + * Class pg_attribute must contain exactly "relnatts" user attributes + * (with attnums ranging from 1 to relnatts) for this class. It may also + * contain entries with negative attnums for system attributes. + */ + + /* # of CHECK constraints for class */ + int16 relchecks BKI_DEFAULT(0); + + /* has (or has had) any rules */ + bool relhasrules BKI_DEFAULT(f); + + /* has (or has had) any TRIGGERs */ + bool relhastriggers BKI_DEFAULT(f); + + /* has (or has had) child tables or indexes */ + bool relhassubclass BKI_DEFAULT(f); + + /* row security is enabled or not */ + bool relrowsecurity BKI_DEFAULT(f); + + /* row security forced for owners or not */ + bool relforcerowsecurity BKI_DEFAULT(f); + + /* matview currently holds query results */ + bool relispopulated BKI_DEFAULT(t); + + /* see REPLICA_IDENTITY_xxx constants */ + char relreplident BKI_DEFAULT(n); + + /* is relation a partition? */ + bool relispartition BKI_DEFAULT(f); + + /* heap for rewrite during DDL, link to original rel */ + Oid relrewrite BKI_DEFAULT(0); + + /* all Xids < this are frozen in this rel */ + TransactionId relfrozenxid BKI_DEFAULT(3); /* FirstNormalTransactionId */ + + /* all multixacts in this rel are >= this; it is really a MultiXactId */ + TransactionId relminmxid BKI_DEFAULT(1); /* FirstMultiXactId */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + /* NOTE: These fields are not present in a relcache entry's rd_rel field. */ + /* access permissions */ + aclitem relacl[1] BKI_DEFAULT(_null_); + + /* access-method-specific options */ + text reloptions[1] BKI_DEFAULT(_null_); + + /* partition bound node tree */ + pg_node_tree relpartbound BKI_DEFAULT(_null_); +#endif +} FormData_pg_class; + +/* Size of fixed part of pg_class tuples, not counting var-length fields */ +#define CLASS_TUPLE_SIZE \ + (offsetof(FormData_pg_class,relminmxid) + sizeof(TransactionId)) + +/* ---------------- + * Form_pg_class corresponds to a pointer to a tuple with + * the format of pg_class relation. + * ---------------- + */ +typedef FormData_pg_class *Form_pg_class; + +#ifdef EXPOSE_TO_CLIENT_CODE + +#define RELKIND_RELATION 'r' /* ordinary table */ +#define RELKIND_INDEX 'i' /* secondary index */ +#define RELKIND_SEQUENCE 'S' /* sequence object */ +#define RELKIND_TOASTVALUE 't' /* for out-of-line values */ +#define RELKIND_VIEW 'v' /* view */ +#define RELKIND_MATVIEW 'm' /* materialized view */ +#define RELKIND_COMPOSITE_TYPE 'c' /* composite type */ +#define RELKIND_FOREIGN_TABLE 'f' /* foreign table */ +#define RELKIND_PARTITIONED_TABLE 'p' /* partitioned table */ +#define RELKIND_PARTITIONED_INDEX 'I' /* partitioned index */ + +#define RELPERSISTENCE_PERMANENT 'p' /* regular table */ +#define RELPERSISTENCE_UNLOGGED 'u' /* unlogged permanent table */ +#define RELPERSISTENCE_TEMP 't' /* temporary table */ + +/* default selection for replica identity (primary key or nothing) */ +#define REPLICA_IDENTITY_DEFAULT 'd' +/* no replica identity is logged for this relation */ +#define REPLICA_IDENTITY_NOTHING 'n' +/* all columns are logged as replica identity */ +#define REPLICA_IDENTITY_FULL 'f' +/* + * an explicitly chosen candidate key's columns are used as replica identity. + * Note this will still be set if the index has been dropped; in that case it + * has the same meaning as 'd'. + */ +#define REPLICA_IDENTITY_INDEX 'i' + +/* + * Relation kinds that have physical storage. These relations normally have + * relfilenode set to non-zero, but it can also be zero if the relation is + * mapped. + */ +#define RELKIND_HAS_STORAGE(relkind) \ + ((relkind) == RELKIND_RELATION || \ + (relkind) == RELKIND_INDEX || \ + (relkind) == RELKIND_SEQUENCE || \ + (relkind) == RELKIND_TOASTVALUE || \ + (relkind) == RELKIND_MATVIEW) + + +#endif /* EXPOSE_TO_CLIENT_CODE */ + +#endif /* PG_CLASS_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_class_d.h b/contrib/libs/postgresql/src/include/catalog/pg_class_d.h new file mode 100644 index 0000000000..48f407763d --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_class_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_class_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_collation.dat b/contrib/libs/postgresql/src/include/catalog/pg_collation.dat new file mode 100644 index 0000000000..ba1b3e201b --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_collation.dat @@ -0,0 +1,31 @@ +#---------------------------------------------------------------------- +# +# pg_collation.dat +# Initial contents of the pg_collation system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_collation.dat +# +#---------------------------------------------------------------------- + +[ + +{ oid => '100', oid_symbol => 'DEFAULT_COLLATION_OID', + descr => 'database\'s default collation', + collname => 'default', collnamespace => 'PGNSP', collowner => 'PGUID', + collprovider => 'd', collencoding => '-1', collcollate => '', collctype => '', + collversion => '_null_' }, +{ oid => '950', oid_symbol => 'C_COLLATION_OID', + descr => 'standard C collation', + collname => 'C', collnamespace => 'PGNSP', collowner => 'PGUID', + collprovider => 'c', collencoding => '-1', collcollate => 'C', + collctype => 'C', collversion => '_null_' }, +{ oid => '951', oid_symbol => 'POSIX_COLLATION_OID', + descr => 'standard POSIX collation', + collname => 'POSIX', collnamespace => 'PGNSP', collowner => 'PGUID', + collprovider => 'c', collencoding => '-1', collcollate => 'POSIX', + collctype => 'POSIX', collversion => '_null_' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_collation.h b/contrib/libs/postgresql/src/include/catalog/pg_collation.h new file mode 100644 index 0000000000..6955bb1273 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_collation.h @@ -0,0 +1,73 @@ +/*------------------------------------------------------------------------- + * + * pg_collation.h + * definition of the "collation" system catalog (pg_collation) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_collation.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_COLLATION_H +#define PG_COLLATION_H + +#include "catalog/genbki.h" +#include "catalog/pg_collation_d.h" + +/* ---------------- + * pg_collation definition. cpp turns this into + * typedef struct FormData_pg_collation + * ---------------- + */ +CATALOG(pg_collation,3456,CollationRelationId) +{ + Oid oid; /* oid */ + NameData collname; /* collation name */ + Oid collnamespace; /* OID of namespace containing collation */ + Oid collowner; /* owner of collation */ + char collprovider; /* see constants below */ + bool collisdeterministic BKI_DEFAULT(t); + int32 collencoding; /* encoding for this collation; -1 = "all" */ + NameData collcollate; /* LC_COLLATE setting */ + NameData collctype; /* LC_CTYPE setting */ +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + text collversion; /* provider-dependent version of collation + * data */ +#endif +} FormData_pg_collation; + +/* ---------------- + * Form_pg_collation corresponds to a pointer to a row with + * the format of pg_collation relation. + * ---------------- + */ +typedef FormData_pg_collation *Form_pg_collation; + +#ifdef EXPOSE_TO_CLIENT_CODE + +#define COLLPROVIDER_DEFAULT 'd' +#define COLLPROVIDER_ICU 'i' +#define COLLPROVIDER_LIBC 'c' + +#endif /* EXPOSE_TO_CLIENT_CODE */ + + +extern Oid CollationCreate(const char *collname, Oid collnamespace, + Oid collowner, + char collprovider, + bool collisdeterministic, + int32 collencoding, + const char *collcollate, const char *collctype, + const char *collversion, + bool if_not_exists, + bool quiet); +extern void RemoveCollationById(Oid collationOid); + +#endif /* PG_COLLATION_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_collation_d.h b/contrib/libs/postgresql/src/include/catalog/pg_collation_d.h new file mode 100644 index 0000000000..2ad4d6d60d --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_collation_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_collation_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_constraint.h b/contrib/libs/postgresql/src/include/catalog/pg_constraint.h new file mode 100644 index 0000000000..9600ece93c --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_constraint.h @@ -0,0 +1,247 @@ +/*------------------------------------------------------------------------- + * + * pg_constraint.h + * definition of the "constraint" system catalog (pg_constraint) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_constraint.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_CONSTRAINT_H +#define PG_CONSTRAINT_H + +#include "catalog/dependency.h" +#include "catalog/genbki.h" +#include "catalog/pg_constraint_d.h" +#include "nodes/pg_list.h" + +/* ---------------- + * pg_constraint definition. cpp turns this into + * typedef struct FormData_pg_constraint + * ---------------- + */ +CATALOG(pg_constraint,2606,ConstraintRelationId) +{ + Oid oid; /* oid */ + + /* + * conname + connamespace is deliberately not unique; we allow, for + * example, the same name to be used for constraints of different + * relations. This is partly for backwards compatibility with past + * Postgres practice, and partly because we don't want to have to obtain a + * global lock to generate a globally unique name for a nameless + * constraint. We associate a namespace with constraint names only for + * SQL-spec compatibility. + * + * However, we do require conname to be unique among the constraints of a + * single relation or domain. This is enforced by a unique index on + * conrelid + contypid + conname. + */ + NameData conname; /* name of this constraint */ + Oid connamespace; /* OID of namespace containing constraint */ + char contype; /* constraint type; see codes below */ + bool condeferrable; /* deferrable constraint? */ + bool condeferred; /* deferred by default? */ + bool convalidated; /* constraint has been validated? */ + + /* + * conrelid and conkey are only meaningful if the constraint applies to a + * specific relation (this excludes domain constraints and assertions). + * Otherwise conrelid is 0 and conkey is NULL. + */ + Oid conrelid; /* relation this constraint constrains */ + + /* + * contypid links to the pg_type row for a domain if this is a domain + * constraint. Otherwise it's 0. + * + * For SQL-style global ASSERTIONs, both conrelid and contypid would be + * zero. This is not presently supported, however. + */ + Oid contypid; /* domain this constraint constrains */ + + /* + * conindid links to the index supporting the constraint, if any; + * otherwise it's 0. This is used for unique, primary-key, and exclusion + * constraints, and less obviously for foreign-key constraints (where the + * index is a unique index on the referenced relation's referenced + * columns). Notice that the index is on conrelid in the first case but + * confrelid in the second. + */ + Oid conindid; /* index supporting this constraint */ + + /* + * If this constraint is on a partition inherited from a partitioned + * table, this is the OID of the corresponding constraint in the parent. + */ + Oid conparentid; + + /* + * These fields, plus confkey, are only meaningful for a foreign-key + * constraint. Otherwise confrelid is 0 and the char fields are spaces. + */ + Oid confrelid; /* relation referenced by foreign key */ + char confupdtype; /* foreign key's ON UPDATE action */ + char confdeltype; /* foreign key's ON DELETE action */ + char confmatchtype; /* foreign key's match type */ + + /* Has a local definition (hence, do not drop when coninhcount is 0) */ + bool conislocal; + + /* Number of times inherited from direct parent relation(s) */ + int32 coninhcount; + + /* Has a local definition and cannot be inherited */ + bool connoinherit; + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + + /* + * Columns of conrelid that the constraint applies to, if known (this is + * NULL for trigger constraints) + */ + int16 conkey[1]; + + /* + * If a foreign key, the referenced columns of confrelid + */ + int16 confkey[1]; + + /* + * If a foreign key, the OIDs of the PK = FK equality operators for each + * column of the constraint + */ + Oid conpfeqop[1]; + + /* + * If a foreign key, the OIDs of the PK = PK equality operators for each + * column of the constraint (i.e., equality for the referenced columns) + */ + Oid conppeqop[1]; + + /* + * If a foreign key, the OIDs of the FK = FK equality operators for each + * column of the constraint (i.e., equality for the referencing columns) + */ + Oid conffeqop[1]; + + /* + * If an exclusion constraint, the OIDs of the exclusion operators for + * each column of the constraint + */ + Oid conexclop[1]; + + /* + * If a check constraint, nodeToString representation of expression + */ + pg_node_tree conbin; +#endif +} FormData_pg_constraint; + +/* ---------------- + * Form_pg_constraint corresponds to a pointer to a tuple with + * the format of pg_constraint relation. + * ---------------- + */ +typedef FormData_pg_constraint *Form_pg_constraint; + +#ifdef EXPOSE_TO_CLIENT_CODE + +/* Valid values for contype */ +#define CONSTRAINT_CHECK 'c' +#define CONSTRAINT_FOREIGN 'f' +#define CONSTRAINT_PRIMARY 'p' +#define CONSTRAINT_UNIQUE 'u' +#define CONSTRAINT_TRIGGER 't' +#define CONSTRAINT_EXCLUSION 'x' + +/* + * Valid values for confupdtype and confdeltype are the FKCONSTR_ACTION_xxx + * constants defined in parsenodes.h. Valid values for confmatchtype are + * the FKCONSTR_MATCH_xxx constants defined in parsenodes.h. + */ + +#endif /* EXPOSE_TO_CLIENT_CODE */ + +/* + * Identify constraint type for lookup purposes + */ +typedef enum ConstraintCategory +{ + CONSTRAINT_RELATION, + CONSTRAINT_DOMAIN, + CONSTRAINT_ASSERTION /* for future expansion */ +} ConstraintCategory; + + +extern Oid CreateConstraintEntry(const char *constraintName, + Oid constraintNamespace, + char constraintType, + bool isDeferrable, + bool isDeferred, + bool isValidated, + Oid parentConstrId, + Oid relId, + const int16 *constraintKey, + int constraintNKeys, + int constraintNTotalKeys, + Oid domainId, + Oid indexRelId, + Oid foreignRelId, + const int16 *foreignKey, + const Oid *pfEqOp, + const Oid *ppEqOp, + const Oid *ffEqOp, + int foreignNKeys, + char foreignUpdateType, + char foreignDeleteType, + char foreignMatchType, + const Oid *exclOp, + Node *conExpr, + const char *conBin, + bool conIsLocal, + int conInhCount, + bool conNoInherit, + bool is_internal); + +extern void RemoveConstraintById(Oid conId); +extern void RenameConstraintById(Oid conId, const char *newname); + +extern bool ConstraintNameIsUsed(ConstraintCategory conCat, Oid objId, + const char *conname); +extern bool ConstraintNameExists(const char *conname, Oid namespaceid); +extern char *ChooseConstraintName(const char *name1, const char *name2, + const char *label, Oid namespaceid, + List *others); + +extern void AlterConstraintNamespaces(Oid ownerId, Oid oldNspId, + Oid newNspId, bool isType, ObjectAddresses *objsMoved); +extern void ConstraintSetParentConstraint(Oid childConstrId, + Oid parentConstrId, + Oid childTableId); +extern Oid get_relation_constraint_oid(Oid relid, const char *conname, bool missing_ok); +extern Bitmapset *get_relation_constraint_attnos(Oid relid, const char *conname, + bool missing_ok, Oid *constraintOid); +extern Oid get_domain_constraint_oid(Oid typid, const char *conname, bool missing_ok); +extern Oid get_relation_idx_constraint_oid(Oid relationId, Oid indexId); + +extern Bitmapset *get_primary_key_attnos(Oid relid, bool deferrableOk, + Oid *constraintOid); +extern void DeconstructFkConstraintRow(HeapTuple tuple, int *numfks, + AttrNumber *conkey, AttrNumber *confkey, + Oid *pf_eq_oprs, Oid *pp_eq_oprs, Oid *ff_eq_oprs); + +extern bool check_functional_grouping(Oid relid, + Index varno, Index varlevelsup, + List *grouping_columns, + List **constraintDeps); + +#endif /* PG_CONSTRAINT_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_constraint_d.h b/contrib/libs/postgresql/src/include/catalog/pg_constraint_d.h new file mode 100644 index 0000000000..34106f4933 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_constraint_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_constraint_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_control.h b/contrib/libs/postgresql/src/include/catalog/pg_control.h new file mode 100644 index 0000000000..9201330160 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_control.h @@ -0,0 +1,252 @@ +/*------------------------------------------------------------------------- + * + * pg_control.h + * The system control file "pg_control" is not a heap relation. + * However, we define it here so that the format is documented. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_control.h + * + *------------------------------------------------------------------------- + */ +#ifndef PG_CONTROL_H +#define PG_CONTROL_H + +#include "access/transam.h" +#include "access/xlogdefs.h" +#include "pgtime.h" /* for pg_time_t */ +#include "port/pg_crc32c.h" + + +/* Version identifier for this pg_control format */ +#define PG_CONTROL_VERSION 1300 + +/* Nonce key length, see below */ +#define MOCK_AUTH_NONCE_LEN 32 + +/* + * Body of CheckPoint XLOG records. This is declared here because we keep + * a copy of the latest one in pg_control for possible disaster recovery. + * Changing this struct requires a PG_CONTROL_VERSION bump. + */ +typedef struct CheckPoint +{ + XLogRecPtr redo; /* next RecPtr available when we began to + * create CheckPoint (i.e. REDO start point) */ + TimeLineID ThisTimeLineID; /* current TLI */ + TimeLineID PrevTimeLineID; /* previous TLI, if this record begins a new + * timeline (equals ThisTimeLineID otherwise) */ + bool fullPageWrites; /* current full_page_writes */ + FullTransactionId nextFullXid; /* next free full transaction ID */ + Oid nextOid; /* next free OID */ + MultiXactId nextMulti; /* next free MultiXactId */ + MultiXactOffset nextMultiOffset; /* next free MultiXact offset */ + TransactionId oldestXid; /* cluster-wide minimum datfrozenxid */ + Oid oldestXidDB; /* database with minimum datfrozenxid */ + MultiXactId oldestMulti; /* cluster-wide minimum datminmxid */ + Oid oldestMultiDB; /* database with minimum datminmxid */ + pg_time_t time; /* time stamp of checkpoint */ + TransactionId oldestCommitTsXid; /* oldest Xid with valid commit + * timestamp */ + TransactionId newestCommitTsXid; /* newest Xid with valid commit + * timestamp */ + + /* + * Oldest XID still running. This is only needed to initialize hot standby + * mode from an online checkpoint, so we only bother calculating this for + * online checkpoints and only when wal_level is replica. Otherwise it's + * set to InvalidTransactionId. + */ + TransactionId oldestActiveXid; +} CheckPoint; + +/* XLOG info values for XLOG rmgr */ +#define XLOG_CHECKPOINT_SHUTDOWN 0x00 +#define XLOG_CHECKPOINT_ONLINE 0x10 +#define XLOG_NOOP 0x20 +#define XLOG_NEXTOID 0x30 +#define XLOG_SWITCH 0x40 +#define XLOG_BACKUP_END 0x50 +#define XLOG_PARAMETER_CHANGE 0x60 +#define XLOG_RESTORE_POINT 0x70 +#define XLOG_FPW_CHANGE 0x80 +#define XLOG_END_OF_RECOVERY 0x90 +#define XLOG_FPI_FOR_HINT 0xA0 +#define XLOG_FPI 0xB0 +/* 0xC0 is used in Postgres 9.5-11 */ +#define XLOG_OVERWRITE_CONTRECORD 0xD0 + + +/* + * System status indicator. Note this is stored in pg_control; if you change + * it, you must bump PG_CONTROL_VERSION + */ +typedef enum DBState +{ + DB_STARTUP = 0, + DB_SHUTDOWNED, + DB_SHUTDOWNED_IN_RECOVERY, + DB_SHUTDOWNING, + DB_IN_CRASH_RECOVERY, + DB_IN_ARCHIVE_RECOVERY, + DB_IN_PRODUCTION +} DBState; + +/* + * Contents of pg_control. + */ + +typedef struct ControlFileData +{ + /* + * Unique system identifier --- to ensure we match up xlog files with the + * installation that produced them. + */ + uint64 system_identifier; + + /* + * Version identifier information. Keep these fields at the same offset, + * especially pg_control_version; they won't be real useful if they move + * around. (For historical reasons they must be 8 bytes into the file + * rather than immediately at the front.) + * + * pg_control_version identifies the format of pg_control itself. + * catalog_version_no identifies the format of the system catalogs. + * + * There are additional version identifiers in individual files; for + * example, WAL logs contain per-page magic numbers that can serve as + * version cues for the WAL log. + */ + uint32 pg_control_version; /* PG_CONTROL_VERSION */ + uint32 catalog_version_no; /* see catversion.h */ + + /* + * System status data + */ + DBState state; /* see enum above */ + pg_time_t time; /* time stamp of last pg_control update */ + XLogRecPtr checkPoint; /* last check point record ptr */ + + CheckPoint checkPointCopy; /* copy of last check point record */ + + XLogRecPtr unloggedLSN; /* current fake LSN value, for unlogged rels */ + + /* + * These two values determine the minimum point we must recover up to + * before starting up: + * + * minRecoveryPoint is updated to the latest replayed LSN whenever we + * flush a data change during archive recovery. That guards against + * starting archive recovery, aborting it, and restarting with an earlier + * stop location. If we've already flushed data changes from WAL record X + * to disk, we mustn't start up until we reach X again. Zero when not + * doing archive recovery. + * + * backupStartPoint is the redo pointer of the backup start checkpoint, if + * we are recovering from an online backup and haven't reached the end of + * backup yet. It is reset to zero when the end of backup is reached, and + * we mustn't start up before that. A boolean would suffice otherwise, but + * we use the redo pointer as a cross-check when we see an end-of-backup + * record, to make sure the end-of-backup record corresponds the base + * backup we're recovering from. + * + * backupEndPoint is the backup end location, if we are recovering from an + * online backup which was taken from the standby and haven't reached the + * end of backup yet. It is initialized to the minimum recovery point in + * pg_control which was backed up last. It is reset to zero when the end + * of backup is reached, and we mustn't start up before that. + * + * If backupEndRequired is true, we know for sure that we're restoring + * from a backup, and must see a backup-end record before we can safely + * start up. If it's false, but backupStartPoint is set, a backup_label + * file was found at startup but it may have been a leftover from a stray + * pg_start_backup() call, not accompanied by pg_stop_backup(). + */ + XLogRecPtr minRecoveryPoint; + TimeLineID minRecoveryPointTLI; + XLogRecPtr backupStartPoint; + XLogRecPtr backupEndPoint; + bool backupEndRequired; + + /* + * Parameter settings that determine if the WAL can be used for archival + * or hot standby. + */ + int wal_level; + bool wal_log_hints; + int MaxConnections; + int max_worker_processes; + int max_wal_senders; + int max_prepared_xacts; + int max_locks_per_xact; + bool track_commit_timestamp; + + /* + * This data is used to check for hardware-architecture compatibility of + * the database and the backend executable. We need not check endianness + * explicitly, since the pg_control version will surely look wrong to a + * machine of different endianness, but we do need to worry about MAXALIGN + * and floating-point format. (Note: storage layout nominally also + * depends on SHORTALIGN and INTALIGN, but in practice these are the same + * on all architectures of interest.) + * + * Testing just one double value is not a very bulletproof test for + * floating-point compatibility, but it will catch most cases. + */ + uint32 maxAlign; /* alignment requirement for tuples */ + double floatFormat; /* constant 1234567.0 */ +#define FLOATFORMAT_VALUE 1234567.0 + + /* + * This data is used to make sure that configuration of this database is + * compatible with the backend executable. + */ + uint32 blcksz; /* data block size for this DB */ + uint32 relseg_size; /* blocks per segment of large relation */ + + uint32 xlog_blcksz; /* block size within WAL files */ + uint32 xlog_seg_size; /* size of each WAL segment */ + + uint32 nameDataLen; /* catalog name field width */ + uint32 indexMaxKeys; /* max number of columns in an index */ + + uint32 toast_max_chunk_size; /* chunk size in TOAST tables */ + uint32 loblksize; /* chunk size in pg_largeobject */ + + bool float8ByVal; /* float8, int8, etc pass-by-value? */ + + /* Are data pages protected by checksums? Zero if no checksum version */ + uint32 data_checksum_version; + + /* + * Random nonce, used in authentication requests that need to proceed + * based on values that are cluster-unique, like a SASL exchange that + * failed at an early stage. + */ + char mock_authentication_nonce[MOCK_AUTH_NONCE_LEN]; + + /* CRC of all above ... MUST BE LAST! */ + pg_crc32c crc; +} ControlFileData; + +/* + * Maximum safe value of sizeof(ControlFileData). For reliability's sake, + * it's critical that pg_control updates be atomic writes. That generally + * means the active data can't be more than one disk sector, which is 512 + * bytes on common hardware. Be very careful about raising this limit. + */ +#define PG_CONTROL_MAX_SAFE_SIZE 512 + +/* + * Physical size of the pg_control file. Note that this is considerably + * bigger than the actually used size (ie, sizeof(ControlFileData)). + * The idea is to keep the physical size constant independent of format + * changes, so that ReadControlFile will deliver a suitable wrong-version + * message instead of a read error if it's looking at an incompatible file. + */ +#define PG_CONTROL_FILE_SIZE 8192 + +#endif /* PG_CONTROL_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_conversion.dat b/contrib/libs/postgresql/src/include/catalog/pg_conversion.dat new file mode 100644 index 0000000000..d7120f2fb0 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_conversion.dat @@ -0,0 +1,405 @@ +#---------------------------------------------------------------------- +# +# pg_conversion.dat +# Initial contents of the pg_conversion system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_conversion.dat +# +#---------------------------------------------------------------------- + +# Note: conforencoding and contoencoding must match the spelling of +# the labels used in the enum pg_enc in mb/pg_wchar.h. + +[ + +{ oid => '4402', descr => 'conversion for KOI8R to MULE_INTERNAL', + conname => 'koi8_r_to_mic', conforencoding => 'PG_KOI8R', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'koi8r_to_mic' }, +{ oid => '4403', descr => 'conversion for MULE_INTERNAL to KOI8R', + conname => 'mic_to_koi8_r', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_KOI8R', conproc => 'mic_to_koi8r' }, +{ oid => '4404', descr => 'conversion for ISO-8859-5 to MULE_INTERNAL', + conname => 'iso_8859_5_to_mic', conforencoding => 'PG_ISO_8859_5', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'iso_to_mic' }, +{ oid => '4405', descr => 'conversion for MULE_INTERNAL to ISO-8859-5', + conname => 'mic_to_iso_8859_5', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_ISO_8859_5', conproc => 'mic_to_iso' }, +{ oid => '4406', descr => 'conversion for WIN1251 to MULE_INTERNAL', + conname => 'windows_1251_to_mic', conforencoding => 'PG_WIN1251', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'win1251_to_mic' }, +{ oid => '4407', descr => 'conversion for MULE_INTERNAL to WIN1251', + conname => 'mic_to_windows_1251', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_WIN1251', conproc => 'mic_to_win1251' }, +{ oid => '4408', descr => 'conversion for WIN866 to MULE_INTERNAL', + conname => 'windows_866_to_mic', conforencoding => 'PG_WIN866', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'win866_to_mic' }, +{ oid => '4409', descr => 'conversion for MULE_INTERNAL to WIN866', + conname => 'mic_to_windows_866', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_WIN866', conproc => 'mic_to_win866' }, +{ oid => '4410', descr => 'conversion for KOI8R to WIN1251', + conname => 'koi8_r_to_windows_1251', conforencoding => 'PG_KOI8R', + contoencoding => 'PG_WIN1251', conproc => 'koi8r_to_win1251' }, +{ oid => '4411', descr => 'conversion for WIN1251 to KOI8R', + conname => 'windows_1251_to_koi8_r', conforencoding => 'PG_WIN1251', + contoencoding => 'PG_KOI8R', conproc => 'win1251_to_koi8r' }, +{ oid => '4412', descr => 'conversion for KOI8R to WIN866', + conname => 'koi8_r_to_windows_866', conforencoding => 'PG_KOI8R', + contoencoding => 'PG_WIN866', conproc => 'koi8r_to_win866' }, +{ oid => '4413', descr => 'conversion for WIN866 to KOI8R', + conname => 'windows_866_to_koi8_r', conforencoding => 'PG_WIN866', + contoencoding => 'PG_KOI8R', conproc => 'win866_to_koi8r' }, +{ oid => '4414', descr => 'conversion for WIN866 to WIN1251', + conname => 'windows_866_to_windows_1251', conforencoding => 'PG_WIN866', + contoencoding => 'PG_WIN1251', conproc => 'win866_to_win1251' }, +{ oid => '4415', descr => 'conversion for WIN1251 to WIN866', + conname => 'windows_1251_to_windows_866', conforencoding => 'PG_WIN1251', + contoencoding => 'PG_WIN866', conproc => 'win1251_to_win866' }, +{ oid => '4416', descr => 'conversion for ISO-8859-5 to KOI8R', + conname => 'iso_8859_5_to_koi8_r', conforencoding => 'PG_ISO_8859_5', + contoencoding => 'PG_KOI8R', conproc => 'iso_to_koi8r' }, +{ oid => '4417', descr => 'conversion for KOI8R to ISO-8859-5', + conname => 'koi8_r_to_iso_8859_5', conforencoding => 'PG_KOI8R', + contoencoding => 'PG_ISO_8859_5', conproc => 'koi8r_to_iso' }, +{ oid => '4418', descr => 'conversion for ISO-8859-5 to WIN1251', + conname => 'iso_8859_5_to_windows_1251', conforencoding => 'PG_ISO_8859_5', + contoencoding => 'PG_WIN1251', conproc => 'iso_to_win1251' }, +{ oid => '4419', descr => 'conversion for WIN1251 to ISO-8859-5', + conname => 'windows_1251_to_iso_8859_5', conforencoding => 'PG_WIN1251', + contoencoding => 'PG_ISO_8859_5', conproc => 'win1251_to_iso' }, +{ oid => '4420', descr => 'conversion for ISO-8859-5 to WIN866', + conname => 'iso_8859_5_to_windows_866', conforencoding => 'PG_ISO_8859_5', + contoencoding => 'PG_WIN866', conproc => 'iso_to_win866' }, +{ oid => '4421', descr => 'conversion for WIN866 to ISO-8859-5', + conname => 'windows_866_to_iso_8859_5', conforencoding => 'PG_WIN866', + contoencoding => 'PG_ISO_8859_5', conproc => 'win866_to_iso' }, +{ oid => '4422', descr => 'conversion for EUC_CN to MULE_INTERNAL', + conname => 'euc_cn_to_mic', conforencoding => 'PG_EUC_CN', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'euc_cn_to_mic' }, +{ oid => '4423', descr => 'conversion for MULE_INTERNAL to EUC_CN', + conname => 'mic_to_euc_cn', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_EUC_CN', conproc => 'mic_to_euc_cn' }, +{ oid => '4424', descr => 'conversion for EUC_JP to SJIS', + conname => 'euc_jp_to_sjis', conforencoding => 'PG_EUC_JP', + contoencoding => 'PG_SJIS', conproc => 'euc_jp_to_sjis' }, +{ oid => '4425', descr => 'conversion for SJIS to EUC_JP', + conname => 'sjis_to_euc_jp', conforencoding => 'PG_SJIS', + contoencoding => 'PG_EUC_JP', conproc => 'sjis_to_euc_jp' }, +{ oid => '4426', descr => 'conversion for EUC_JP to MULE_INTERNAL', + conname => 'euc_jp_to_mic', conforencoding => 'PG_EUC_JP', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'euc_jp_to_mic' }, +{ oid => '4427', descr => 'conversion for SJIS to MULE_INTERNAL', + conname => 'sjis_to_mic', conforencoding => 'PG_SJIS', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'sjis_to_mic' }, +{ oid => '4428', descr => 'conversion for MULE_INTERNAL to EUC_JP', + conname => 'mic_to_euc_jp', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_EUC_JP', conproc => 'mic_to_euc_jp' }, +{ oid => '4429', descr => 'conversion for MULE_INTERNAL to SJIS', + conname => 'mic_to_sjis', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_SJIS', conproc => 'mic_to_sjis' }, +{ oid => '4430', descr => 'conversion for EUC_KR to MULE_INTERNAL', + conname => 'euc_kr_to_mic', conforencoding => 'PG_EUC_KR', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'euc_kr_to_mic' }, +{ oid => '4431', descr => 'conversion for MULE_INTERNAL to EUC_KR', + conname => 'mic_to_euc_kr', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_EUC_KR', conproc => 'mic_to_euc_kr' }, +{ oid => '4432', descr => 'conversion for EUC_TW to BIG5', + conname => 'euc_tw_to_big5', conforencoding => 'PG_EUC_TW', + contoencoding => 'PG_BIG5', conproc => 'euc_tw_to_big5' }, +{ oid => '4433', descr => 'conversion for BIG5 to EUC_TW', + conname => 'big5_to_euc_tw', conforencoding => 'PG_BIG5', + contoencoding => 'PG_EUC_TW', conproc => 'big5_to_euc_tw' }, +{ oid => '4434', descr => 'conversion for EUC_TW to MULE_INTERNAL', + conname => 'euc_tw_to_mic', conforencoding => 'PG_EUC_TW', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'euc_tw_to_mic' }, +{ oid => '4435', descr => 'conversion for BIG5 to MULE_INTERNAL', + conname => 'big5_to_mic', conforencoding => 'PG_BIG5', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'big5_to_mic' }, +{ oid => '4436', descr => 'conversion for MULE_INTERNAL to EUC_TW', + conname => 'mic_to_euc_tw', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_EUC_TW', conproc => 'mic_to_euc_tw' }, +{ oid => '4437', descr => 'conversion for MULE_INTERNAL to BIG5', + conname => 'mic_to_big5', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_BIG5', conproc => 'mic_to_big5' }, +{ oid => '4438', descr => 'conversion for LATIN2 to MULE_INTERNAL', + conname => 'iso_8859_2_to_mic', conforencoding => 'PG_LATIN2', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'latin2_to_mic' }, +{ oid => '4439', descr => 'conversion for MULE_INTERNAL to LATIN2', + conname => 'mic_to_iso_8859_2', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_LATIN2', conproc => 'mic_to_latin2' }, +{ oid => '4440', descr => 'conversion for WIN1250 to MULE_INTERNAL', + conname => 'windows_1250_to_mic', conforencoding => 'PG_WIN1250', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'win1250_to_mic' }, +{ oid => '4441', descr => 'conversion for MULE_INTERNAL to WIN1250', + conname => 'mic_to_windows_1250', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_WIN1250', conproc => 'mic_to_win1250' }, +{ oid => '4442', descr => 'conversion for LATIN2 to WIN1250', + conname => 'iso_8859_2_to_windows_1250', conforencoding => 'PG_LATIN2', + contoencoding => 'PG_WIN1250', conproc => 'latin2_to_win1250' }, +{ oid => '4443', descr => 'conversion for WIN1250 to LATIN2', + conname => 'windows_1250_to_iso_8859_2', conforencoding => 'PG_WIN1250', + contoencoding => 'PG_LATIN2', conproc => 'win1250_to_latin2' }, +{ oid => '4444', descr => 'conversion for LATIN1 to MULE_INTERNAL', + conname => 'iso_8859_1_to_mic', conforencoding => 'PG_LATIN1', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'latin1_to_mic' }, +{ oid => '4445', descr => 'conversion for MULE_INTERNAL to LATIN1', + conname => 'mic_to_iso_8859_1', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_LATIN1', conproc => 'mic_to_latin1' }, +{ oid => '4446', descr => 'conversion for LATIN3 to MULE_INTERNAL', + conname => 'iso_8859_3_to_mic', conforencoding => 'PG_LATIN3', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'latin3_to_mic' }, +{ oid => '4447', descr => 'conversion for MULE_INTERNAL to LATIN3', + conname => 'mic_to_iso_8859_3', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_LATIN3', conproc => 'mic_to_latin3' }, +{ oid => '4448', descr => 'conversion for LATIN4 to MULE_INTERNAL', + conname => 'iso_8859_4_to_mic', conforencoding => 'PG_LATIN4', + contoencoding => 'PG_MULE_INTERNAL', conproc => 'latin4_to_mic' }, +{ oid => '4449', descr => 'conversion for MULE_INTERNAL to LATIN4', + conname => 'mic_to_iso_8859_4', conforencoding => 'PG_MULE_INTERNAL', + contoencoding => 'PG_LATIN4', conproc => 'mic_to_latin4' }, +{ oid => '4452', descr => 'conversion for BIG5 to UTF8', + conname => 'big5_to_utf8', conforencoding => 'PG_BIG5', + contoencoding => 'PG_UTF8', conproc => 'big5_to_utf8' }, +{ oid => '4453', descr => 'conversion for UTF8 to BIG5', + conname => 'utf8_to_big5', conforencoding => 'PG_UTF8', + contoencoding => 'PG_BIG5', conproc => 'utf8_to_big5' }, +{ oid => '4454', descr => 'conversion for UTF8 to KOI8R', + conname => 'utf8_to_koi8_r', conforencoding => 'PG_UTF8', + contoencoding => 'PG_KOI8R', conproc => 'utf8_to_koi8r' }, +{ oid => '4455', descr => 'conversion for KOI8R to UTF8', + conname => 'koi8_r_to_utf8', conforencoding => 'PG_KOI8R', + contoencoding => 'PG_UTF8', conproc => 'koi8r_to_utf8' }, +{ oid => '4456', descr => 'conversion for UTF8 to KOI8U', + conname => 'utf8_to_koi8_u', conforencoding => 'PG_UTF8', + contoencoding => 'PG_KOI8U', conproc => 'utf8_to_koi8u' }, +{ oid => '4457', descr => 'conversion for KOI8U to UTF8', + conname => 'koi8_u_to_utf8', conforencoding => 'PG_KOI8U', + contoencoding => 'PG_UTF8', conproc => 'koi8u_to_utf8' }, +{ oid => '4458', descr => 'conversion for UTF8 to WIN866', + conname => 'utf8_to_windows_866', conforencoding => 'PG_UTF8', + contoencoding => 'PG_WIN866', conproc => 'utf8_to_win' }, +{ oid => '4459', descr => 'conversion for WIN866 to UTF8', + conname => 'windows_866_to_utf8', conforencoding => 'PG_WIN866', + contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' }, +{ oid => '4460', descr => 'conversion for UTF8 to WIN874', + conname => 'utf8_to_windows_874', conforencoding => 'PG_UTF8', + contoencoding => 'PG_WIN874', conproc => 'utf8_to_win' }, +{ oid => '4461', descr => 'conversion for WIN874 to UTF8', + conname => 'windows_874_to_utf8', conforencoding => 'PG_WIN874', + contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' }, +{ oid => '4462', descr => 'conversion for UTF8 to WIN1250', + conname => 'utf8_to_windows_1250', conforencoding => 'PG_UTF8', + contoencoding => 'PG_WIN1250', conproc => 'utf8_to_win' }, +{ oid => '4463', descr => 'conversion for WIN1250 to UTF8', + conname => 'windows_1250_to_utf8', conforencoding => 'PG_WIN1250', + contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' }, +{ oid => '4464', descr => 'conversion for UTF8 to WIN1251', + conname => 'utf8_to_windows_1251', conforencoding => 'PG_UTF8', + contoencoding => 'PG_WIN1251', conproc => 'utf8_to_win' }, +{ oid => '4465', descr => 'conversion for WIN1251 to UTF8', + conname => 'windows_1251_to_utf8', conforencoding => 'PG_WIN1251', + contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' }, +{ oid => '4466', descr => 'conversion for UTF8 to WIN1252', + conname => 'utf8_to_windows_1252', conforencoding => 'PG_UTF8', + contoencoding => 'PG_WIN1252', conproc => 'utf8_to_win' }, +{ oid => '4467', descr => 'conversion for WIN1252 to UTF8', + conname => 'windows_1252_to_utf8', conforencoding => 'PG_WIN1252', + contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' }, +{ oid => '4468', descr => 'conversion for UTF8 to WIN1253', + conname => 'utf8_to_windows_1253', conforencoding => 'PG_UTF8', + contoencoding => 'PG_WIN1253', conproc => 'utf8_to_win' }, +{ oid => '4469', descr => 'conversion for WIN1253 to UTF8', + conname => 'windows_1253_to_utf8', conforencoding => 'PG_WIN1253', + contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' }, +{ oid => '4470', descr => 'conversion for UTF8 to WIN1254', + conname => 'utf8_to_windows_1254', conforencoding => 'PG_UTF8', + contoencoding => 'PG_WIN1254', conproc => 'utf8_to_win' }, +{ oid => '4471', descr => 'conversion for WIN1254 to UTF8', + conname => 'windows_1254_to_utf8', conforencoding => 'PG_WIN1254', + contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' }, +{ oid => '4472', descr => 'conversion for UTF8 to WIN1255', + conname => 'utf8_to_windows_1255', conforencoding => 'PG_UTF8', + contoencoding => 'PG_WIN1255', conproc => 'utf8_to_win' }, +{ oid => '4473', descr => 'conversion for WIN1255 to UTF8', + conname => 'windows_1255_to_utf8', conforencoding => 'PG_WIN1255', + contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' }, +{ oid => '4474', descr => 'conversion for UTF8 to WIN1256', + conname => 'utf8_to_windows_1256', conforencoding => 'PG_UTF8', + contoencoding => 'PG_WIN1256', conproc => 'utf8_to_win' }, +{ oid => '4475', descr => 'conversion for WIN1256 to UTF8', + conname => 'windows_1256_to_utf8', conforencoding => 'PG_WIN1256', + contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' }, +{ oid => '4476', descr => 'conversion for UTF8 to WIN1257', + conname => 'utf8_to_windows_1257', conforencoding => 'PG_UTF8', + contoencoding => 'PG_WIN1257', conproc => 'utf8_to_win' }, +{ oid => '4477', descr => 'conversion for WIN1257 to UTF8', + conname => 'windows_1257_to_utf8', conforencoding => 'PG_WIN1257', + contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' }, +{ oid => '4478', descr => 'conversion for UTF8 to WIN1258', + conname => 'utf8_to_windows_1258', conforencoding => 'PG_UTF8', + contoencoding => 'PG_WIN1258', conproc => 'utf8_to_win' }, +{ oid => '4479', descr => 'conversion for WIN1258 to UTF8', + conname => 'windows_1258_to_utf8', conforencoding => 'PG_WIN1258', + contoencoding => 'PG_UTF8', conproc => 'win_to_utf8' }, +{ oid => '4480', descr => 'conversion for EUC_CN to UTF8', + conname => 'euc_cn_to_utf8', conforencoding => 'PG_EUC_CN', + contoencoding => 'PG_UTF8', conproc => 'euc_cn_to_utf8' }, +{ oid => '4481', descr => 'conversion for UTF8 to EUC_CN', + conname => 'utf8_to_euc_cn', conforencoding => 'PG_UTF8', + contoencoding => 'PG_EUC_CN', conproc => 'utf8_to_euc_cn' }, +{ oid => '4482', descr => 'conversion for EUC_JP to UTF8', + conname => 'euc_jp_to_utf8', conforencoding => 'PG_EUC_JP', + contoencoding => 'PG_UTF8', conproc => 'euc_jp_to_utf8' }, +{ oid => '4483', descr => 'conversion for UTF8 to EUC_JP', + conname => 'utf8_to_euc_jp', conforencoding => 'PG_UTF8', + contoencoding => 'PG_EUC_JP', conproc => 'utf8_to_euc_jp' }, +{ oid => '4484', descr => 'conversion for EUC_KR to UTF8', + conname => 'euc_kr_to_utf8', conforencoding => 'PG_EUC_KR', + contoencoding => 'PG_UTF8', conproc => 'euc_kr_to_utf8' }, +{ oid => '4485', descr => 'conversion for UTF8 to EUC_KR', + conname => 'utf8_to_euc_kr', conforencoding => 'PG_UTF8', + contoencoding => 'PG_EUC_KR', conproc => 'utf8_to_euc_kr' }, +{ oid => '4486', descr => 'conversion for EUC_TW to UTF8', + conname => 'euc_tw_to_utf8', conforencoding => 'PG_EUC_TW', + contoencoding => 'PG_UTF8', conproc => 'euc_tw_to_utf8' }, +{ oid => '4487', descr => 'conversion for UTF8 to EUC_TW', + conname => 'utf8_to_euc_tw', conforencoding => 'PG_UTF8', + contoencoding => 'PG_EUC_TW', conproc => 'utf8_to_euc_tw' }, +{ oid => '4488', descr => 'conversion for GB18030 to UTF8', + conname => 'gb18030_to_utf8', conforencoding => 'PG_GB18030', + contoencoding => 'PG_UTF8', conproc => 'gb18030_to_utf8' }, +{ oid => '4489', descr => 'conversion for UTF8 to GB18030', + conname => 'utf8_to_gb18030', conforencoding => 'PG_UTF8', + contoencoding => 'PG_GB18030', conproc => 'utf8_to_gb18030' }, +{ oid => '4490', descr => 'conversion for GBK to UTF8', + conname => 'gbk_to_utf8', conforencoding => 'PG_GBK', + contoencoding => 'PG_UTF8', conproc => 'gbk_to_utf8' }, +{ oid => '4491', descr => 'conversion for UTF8 to GBK', + conname => 'utf8_to_gbk', conforencoding => 'PG_UTF8', + contoencoding => 'PG_GBK', conproc => 'utf8_to_gbk' }, +{ oid => '4492', descr => 'conversion for UTF8 to LATIN2', + conname => 'utf8_to_iso_8859_2', conforencoding => 'PG_UTF8', + contoencoding => 'PG_LATIN2', conproc => 'utf8_to_iso8859' }, +{ oid => '4493', descr => 'conversion for LATIN2 to UTF8', + conname => 'iso_8859_2_to_utf8', conforencoding => 'PG_LATIN2', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4494', descr => 'conversion for UTF8 to LATIN3', + conname => 'utf8_to_iso_8859_3', conforencoding => 'PG_UTF8', + contoencoding => 'PG_LATIN3', conproc => 'utf8_to_iso8859' }, +{ oid => '4495', descr => 'conversion for LATIN3 to UTF8', + conname => 'iso_8859_3_to_utf8', conforencoding => 'PG_LATIN3', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4496', descr => 'conversion for UTF8 to LATIN4', + conname => 'utf8_to_iso_8859_4', conforencoding => 'PG_UTF8', + contoencoding => 'PG_LATIN4', conproc => 'utf8_to_iso8859' }, +{ oid => '4497', descr => 'conversion for LATIN4 to UTF8', + conname => 'iso_8859_4_to_utf8', conforencoding => 'PG_LATIN4', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4498', descr => 'conversion for UTF8 to LATIN5', + conname => 'utf8_to_iso_8859_9', conforencoding => 'PG_UTF8', + contoencoding => 'PG_LATIN5', conproc => 'utf8_to_iso8859' }, +{ oid => '4499', descr => 'conversion for LATIN5 to UTF8', + conname => 'iso_8859_9_to_utf8', conforencoding => 'PG_LATIN5', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4500', descr => 'conversion for UTF8 to LATIN6', + conname => 'utf8_to_iso_8859_10', conforencoding => 'PG_UTF8', + contoencoding => 'PG_LATIN6', conproc => 'utf8_to_iso8859' }, +{ oid => '4501', descr => 'conversion for LATIN6 to UTF8', + conname => 'iso_8859_10_to_utf8', conforencoding => 'PG_LATIN6', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4502', descr => 'conversion for UTF8 to LATIN7', + conname => 'utf8_to_iso_8859_13', conforencoding => 'PG_UTF8', + contoencoding => 'PG_LATIN7', conproc => 'utf8_to_iso8859' }, +{ oid => '4503', descr => 'conversion for LATIN7 to UTF8', + conname => 'iso_8859_13_to_utf8', conforencoding => 'PG_LATIN7', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4504', descr => 'conversion for UTF8 to LATIN8', + conname => 'utf8_to_iso_8859_14', conforencoding => 'PG_UTF8', + contoencoding => 'PG_LATIN8', conproc => 'utf8_to_iso8859' }, +{ oid => '4505', descr => 'conversion for LATIN8 to UTF8', + conname => 'iso_8859_14_to_utf8', conforencoding => 'PG_LATIN8', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4506', descr => 'conversion for UTF8 to LATIN9', + conname => 'utf8_to_iso_8859_15', conforencoding => 'PG_UTF8', + contoencoding => 'PG_LATIN9', conproc => 'utf8_to_iso8859' }, +{ oid => '4507', descr => 'conversion for LATIN9 to UTF8', + conname => 'iso_8859_15_to_utf8', conforencoding => 'PG_LATIN9', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4508', descr => 'conversion for UTF8 to LATIN10', + conname => 'utf8_to_iso_8859_16', conforencoding => 'PG_UTF8', + contoencoding => 'PG_LATIN10', conproc => 'utf8_to_iso8859' }, +{ oid => '4509', descr => 'conversion for LATIN10 to UTF8', + conname => 'iso_8859_16_to_utf8', conforencoding => 'PG_LATIN10', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4510', descr => 'conversion for UTF8 to ISO-8859-5', + conname => 'utf8_to_iso_8859_5', conforencoding => 'PG_UTF8', + contoencoding => 'PG_ISO_8859_5', conproc => 'utf8_to_iso8859' }, +{ oid => '4511', descr => 'conversion for ISO-8859-5 to UTF8', + conname => 'iso_8859_5_to_utf8', conforencoding => 'PG_ISO_8859_5', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4512', descr => 'conversion for UTF8 to ISO-8859-6', + conname => 'utf8_to_iso_8859_6', conforencoding => 'PG_UTF8', + contoencoding => 'PG_ISO_8859_6', conproc => 'utf8_to_iso8859' }, +{ oid => '4513', descr => 'conversion for ISO-8859-6 to UTF8', + conname => 'iso_8859_6_to_utf8', conforencoding => 'PG_ISO_8859_6', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4514', descr => 'conversion for UTF8 to ISO-8859-7', + conname => 'utf8_to_iso_8859_7', conforencoding => 'PG_UTF8', + contoencoding => 'PG_ISO_8859_7', conproc => 'utf8_to_iso8859' }, +{ oid => '4515', descr => 'conversion for ISO-8859-7 to UTF8', + conname => 'iso_8859_7_to_utf8', conforencoding => 'PG_ISO_8859_7', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4516', descr => 'conversion for UTF8 to ISO-8859-8', + conname => 'utf8_to_iso_8859_8', conforencoding => 'PG_UTF8', + contoencoding => 'PG_ISO_8859_8', conproc => 'utf8_to_iso8859' }, +{ oid => '4517', descr => 'conversion for ISO-8859-8 to UTF8', + conname => 'iso_8859_8_to_utf8', conforencoding => 'PG_ISO_8859_8', + contoencoding => 'PG_UTF8', conproc => 'iso8859_to_utf8' }, +{ oid => '4518', descr => 'conversion for LATIN1 to UTF8', + conname => 'iso_8859_1_to_utf8', conforencoding => 'PG_LATIN1', + contoencoding => 'PG_UTF8', conproc => 'iso8859_1_to_utf8' }, +{ oid => '4519', descr => 'conversion for UTF8 to LATIN1', + conname => 'utf8_to_iso_8859_1', conforencoding => 'PG_UTF8', + contoencoding => 'PG_LATIN1', conproc => 'utf8_to_iso8859_1' }, +{ oid => '4520', descr => 'conversion for JOHAB to UTF8', + conname => 'johab_to_utf8', conforencoding => 'PG_JOHAB', + contoencoding => 'PG_UTF8', conproc => 'johab_to_utf8' }, +{ oid => '4521', descr => 'conversion for UTF8 to JOHAB', + conname => 'utf8_to_johab', conforencoding => 'PG_UTF8', + contoencoding => 'PG_JOHAB', conproc => 'utf8_to_johab' }, +{ oid => '4522', descr => 'conversion for SJIS to UTF8', + conname => 'sjis_to_utf8', conforencoding => 'PG_SJIS', + contoencoding => 'PG_UTF8', conproc => 'sjis_to_utf8' }, +{ oid => '4523', descr => 'conversion for UTF8 to SJIS', + conname => 'utf8_to_sjis', conforencoding => 'PG_UTF8', + contoencoding => 'PG_SJIS', conproc => 'utf8_to_sjis' }, +{ oid => '4524', descr => 'conversion for UHC to UTF8', + conname => 'uhc_to_utf8', conforencoding => 'PG_UHC', + contoencoding => 'PG_UTF8', conproc => 'uhc_to_utf8' }, +{ oid => '4525', descr => 'conversion for UTF8 to UHC', + conname => 'utf8_to_uhc', conforencoding => 'PG_UTF8', + contoencoding => 'PG_UHC', conproc => 'utf8_to_uhc' }, +{ oid => '4526', descr => 'conversion for EUC_JIS_2004 to UTF8', + conname => 'euc_jis_2004_to_utf8', conforencoding => 'PG_EUC_JIS_2004', + contoencoding => 'PG_UTF8', conproc => 'euc_jis_2004_to_utf8' }, +{ oid => '4527', descr => 'conversion for UTF8 to EUC_JIS_2004', + conname => 'utf8_to_euc_jis_2004', conforencoding => 'PG_UTF8', + contoencoding => 'PG_EUC_JIS_2004', conproc => 'utf8_to_euc_jis_2004' }, +{ oid => '4528', descr => 'conversion for SHIFT_JIS_2004 to UTF8', + conname => 'shift_jis_2004_to_utf8', conforencoding => 'PG_SHIFT_JIS_2004', + contoencoding => 'PG_UTF8', conproc => 'shift_jis_2004_to_utf8' }, +{ oid => '4529', descr => 'conversion for UTF8 to SHIFT_JIS_2004', + conname => 'utf8_to_shift_jis_2004', conforencoding => 'PG_UTF8', + contoencoding => 'PG_SHIFT_JIS_2004', conproc => 'utf8_to_shift_jis_2004' }, +{ oid => '4530', descr => 'conversion for EUC_JIS_2004 to SHIFT_JIS_2004', + conname => 'euc_jis_2004_to_shift_jis_2004', + conforencoding => 'PG_EUC_JIS_2004', contoencoding => 'PG_SHIFT_JIS_2004', + conproc => 'euc_jis_2004_to_shift_jis_2004' }, +{ oid => '4531', descr => 'conversion for SHIFT_JIS_2004 to EUC_JIS_2004', + conname => 'shift_jis_2004_to_euc_jis_2004', + conforencoding => 'PG_SHIFT_JIS_2004', contoencoding => 'PG_EUC_JIS_2004', + conproc => 'shift_jis_2004_to_euc_jis_2004' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_conversion.h b/contrib/libs/postgresql/src/include/catalog/pg_conversion.h new file mode 100644 index 0000000000..0e7f13e1b6 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_conversion.h @@ -0,0 +1,72 @@ +/*------------------------------------------------------------------------- + * + * pg_conversion.h + * definition of the "conversion" system catalog (pg_conversion) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_conversion.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_CONVERSION_H +#define PG_CONVERSION_H + +#include "catalog/genbki.h" +#include "catalog/objectaddress.h" +#include "catalog/pg_conversion_d.h" + +/* ---------------- + * pg_conversion definition. cpp turns this into + * typedef struct FormData_pg_conversion + * ---------------- + */ +CATALOG(pg_conversion,2607,ConversionRelationId) +{ + /* oid */ + Oid oid; + + /* name of the conversion */ + NameData conname; + + /* namespace that the conversion belongs to */ + Oid connamespace BKI_DEFAULT(PGNSP); + + /* owner of the conversion */ + Oid conowner BKI_DEFAULT(PGUID); + + /* FOR encoding id */ + int32 conforencoding BKI_LOOKUP(encoding); + + /* TO encoding id */ + int32 contoencoding BKI_LOOKUP(encoding); + + /* OID of the conversion proc */ + regproc conproc BKI_LOOKUP(pg_proc); + + /* true if this is a default conversion */ + bool condefault BKI_DEFAULT(t); +} FormData_pg_conversion; + +/* ---------------- + * Form_pg_conversion corresponds to a pointer to a tuple with + * the format of pg_conversion relation. + * ---------------- + */ +typedef FormData_pg_conversion *Form_pg_conversion; + + +extern ObjectAddress ConversionCreate(const char *conname, Oid connamespace, + Oid conowner, + int32 conforencoding, int32 contoencoding, + Oid conproc, bool def); +extern void RemoveConversionById(Oid conversionOid); +extern Oid FindDefaultConversion(Oid connamespace, int32 for_encoding, + int32 to_encoding); + +#endif /* PG_CONVERSION_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_conversion_d.h b/contrib/libs/postgresql/src/include/catalog/pg_conversion_d.h new file mode 100644 index 0000000000..b8457ea209 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_conversion_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_conversion_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_database.dat b/contrib/libs/postgresql/src/include/catalog/pg_database.dat new file mode 100644 index 0000000000..21cd6604f3 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_database.dat @@ -0,0 +1,22 @@ +#---------------------------------------------------------------------- +# +# pg_database.dat +# Initial contents of the pg_database system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_database.dat +# +#---------------------------------------------------------------------- + +[ + +{ oid => '1', oid_symbol => 'TemplateDbOid', + descr => 'default template for new databases', + datname => 'template1', encoding => 'ENCODING', datcollate => 'LC_COLLATE', + datctype => 'LC_CTYPE', datistemplate => 't', datallowconn => 't', + datconnlimit => '-1', datlastsysoid => '0', datfrozenxid => '0', + datminmxid => '1', dattablespace => 'pg_default', datacl => '_null_' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_database.h b/contrib/libs/postgresql/src/include/catalog/pg_database.h new file mode 100644 index 0000000000..f623ee81b7 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_database.h @@ -0,0 +1,83 @@ +/*------------------------------------------------------------------------- + * + * pg_database.h + * definition of the "database" system catalog (pg_database) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_database.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_DATABASE_H +#define PG_DATABASE_H + +#include "catalog/genbki.h" +#include "catalog/pg_database_d.h" + +/* ---------------- + * pg_database definition. cpp turns this into + * typedef struct FormData_pg_database + * ---------------- + */ +CATALOG(pg_database,1262,DatabaseRelationId) BKI_SHARED_RELATION BKI_ROWTYPE_OID(1248,DatabaseRelation_Rowtype_Id) BKI_SCHEMA_MACRO +{ + /* oid */ + Oid oid; + + /* database name */ + NameData datname; + + /* owner of database */ + Oid datdba BKI_DEFAULT(PGUID); + + /* character encoding */ + int32 encoding; + + /* LC_COLLATE setting */ + NameData datcollate; + + /* LC_CTYPE setting */ + NameData datctype; + + /* allowed as CREATE DATABASE template? */ + bool datistemplate; + + /* new connections allowed? */ + bool datallowconn; + + /* max connections allowed (-1=no limit) */ + int32 datconnlimit; + + /* highest OID to consider a system OID */ + Oid datlastsysoid; + + /* all Xids < this are frozen in this DB */ + TransactionId datfrozenxid; + + /* all multixacts in the DB are >= this */ + TransactionId datminmxid; + + /* default table space for this DB */ + Oid dattablespace BKI_LOOKUP(pg_tablespace); + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + /* access permissions */ + aclitem datacl[1]; +#endif +} FormData_pg_database; + +/* ---------------- + * Form_pg_database corresponds to a pointer to a tuple with + * the format of pg_database relation. + * ---------------- + */ +typedef FormData_pg_database *Form_pg_database; + +#endif /* PG_DATABASE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_database_d.h b/contrib/libs/postgresql/src/include/catalog/pg_database_d.h new file mode 100644 index 0000000000..7c5ca52aa8 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_database_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_database_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_db_role_setting.h b/contrib/libs/postgresql/src/include/catalog/pg_db_role_setting.h new file mode 100644 index 0000000000..5713fa2315 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_db_role_setting.h @@ -0,0 +1,54 @@ +/*------------------------------------------------------------------------- + * + * pg_db_role_setting.h + * definition of the system catalog for per-database/per-user + * configuration settings (pg_db_role_setting) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_db_role_setting.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_DB_ROLE_SETTING_H +#define PG_DB_ROLE_SETTING_H + +#include "catalog/genbki.h" +#include "catalog/pg_db_role_setting_d.h" + +#include "utils/guc.h" +#include "utils/relcache.h" +#include "utils/snapshot.h" + +/* ---------------- + * pg_db_role_setting definition. cpp turns this into + * typedef struct FormData_pg_db_role_setting + * ---------------- + */ +CATALOG(pg_db_role_setting,2964,DbRoleSettingRelationId) BKI_SHARED_RELATION +{ + Oid setdatabase; /* database */ + Oid setrole; /* role */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + text setconfig[1]; /* GUC settings to apply at login */ +#endif +} FormData_pg_db_role_setting; + +typedef FormData_pg_db_role_setting * Form_pg_db_role_setting; + +/* + * prototypes for functions in pg_db_role_setting.h + */ +extern void AlterSetting(Oid databaseid, Oid roleid, VariableSetStmt *setstmt); +extern void DropSetting(Oid databaseid, Oid roleid); +extern void ApplySetting(Snapshot snapshot, Oid databaseid, Oid roleid, + Relation relsetting, GucSource source); + +#endif /* PG_DB_ROLE_SETTING_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_db_role_setting_d.h b/contrib/libs/postgresql/src/include/catalog/pg_db_role_setting_d.h new file mode 100644 index 0000000000..5128cb7133 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_db_role_setting_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_db_role_setting_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_default_acl.h b/contrib/libs/postgresql/src/include/catalog/pg_default_acl.h new file mode 100644 index 0000000000..2bac5e23e1 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_default_acl.h @@ -0,0 +1,65 @@ +/*------------------------------------------------------------------------- + * + * pg_default_acl.h + * definition of the system catalog for default ACLs of new objects + * (pg_default_acl) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_default_acl.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_DEFAULT_ACL_H +#define PG_DEFAULT_ACL_H + +#include "catalog/genbki.h" +#include "catalog/pg_default_acl_d.h" + +/* ---------------- + * pg_default_acl definition. cpp turns this into + * typedef struct FormData_pg_default_acl + * ---------------- + */ +CATALOG(pg_default_acl,826,DefaultAclRelationId) +{ + Oid oid; /* oid */ + Oid defaclrole; /* OID of role owning this ACL */ + Oid defaclnamespace; /* OID of namespace, or 0 for all */ + char defaclobjtype; /* see DEFACLOBJ_xxx constants below */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + aclitem defaclacl[1] BKI_FORCE_NOT_NULL; /* permissions to add at + * CREATE time */ +#endif +} FormData_pg_default_acl; + +/* ---------------- + * Form_pg_default_acl corresponds to a pointer to a tuple with + * the format of pg_default_acl relation. + * ---------------- + */ +typedef FormData_pg_default_acl *Form_pg_default_acl; + +#ifdef EXPOSE_TO_CLIENT_CODE + +/* + * Types of objects for which the user is allowed to specify default + * permissions through pg_default_acl. These codes are used in the + * defaclobjtype column. + */ +#define DEFACLOBJ_RELATION 'r' /* table, view */ +#define DEFACLOBJ_SEQUENCE 'S' /* sequence */ +#define DEFACLOBJ_FUNCTION 'f' /* function */ +#define DEFACLOBJ_TYPE 'T' /* type */ +#define DEFACLOBJ_NAMESPACE 'n' /* namespace */ + +#endif /* EXPOSE_TO_CLIENT_CODE */ + +#endif /* PG_DEFAULT_ACL_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_default_acl_d.h b/contrib/libs/postgresql/src/include/catalog/pg_default_acl_d.h new file mode 100644 index 0000000000..c67a7f8e97 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_default_acl_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_default_acl_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_depend.h b/contrib/libs/postgresql/src/include/catalog/pg_depend.h new file mode 100644 index 0000000000..ccf0a98330 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_depend.h @@ -0,0 +1,73 @@ +/*------------------------------------------------------------------------- + * + * pg_depend.h + * definition of the "dependency" system catalog (pg_depend) + * + * pg_depend has no preloaded contents, so there is no pg_depend.dat + * file; system-defined dependencies are loaded into it during a late stage + * of the initdb process. + * + * NOTE: we do not represent all possible dependency pairs in pg_depend; + * for example, there's not much value in creating an explicit dependency + * from an attribute to its relation. Usually we make a dependency for + * cases where the relationship is conditional rather than essential + * (for example, not all triggers are dependent on constraints, but all + * attributes are dependent on relations) or where the dependency is not + * convenient to find from the contents of other catalogs. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_depend.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_DEPEND_H +#define PG_DEPEND_H + +#include "catalog/genbki.h" +#include "catalog/pg_depend_d.h" + +/* ---------------- + * pg_depend definition. cpp turns this into + * typedef struct FormData_pg_depend + * ---------------- + */ +CATALOG(pg_depend,2608,DependRelationId) +{ + /* + * Identification of the dependent (referencing) object. + * + * These fields are all zeroes for a DEPENDENCY_PIN entry. + */ + Oid classid; /* OID of table containing object */ + Oid objid; /* OID of object itself */ + int32 objsubid; /* column number, or 0 if not used */ + + /* + * Identification of the independent (referenced) object. + */ + Oid refclassid; /* OID of table containing object */ + Oid refobjid; /* OID of object itself */ + int32 refobjsubid; /* column number, or 0 if not used */ + + /* + * Precise semantics of the relationship are specified by the deptype + * field. See DependencyType in catalog/dependency.h. + */ + char deptype; /* see codes in dependency.h */ +} FormData_pg_depend; + +/* ---------------- + * Form_pg_depend corresponds to a pointer to a row with + * the format of pg_depend relation. + * ---------------- + */ +typedef FormData_pg_depend *Form_pg_depend; + +#endif /* PG_DEPEND_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_depend_d.h b/contrib/libs/postgresql/src/include/catalog/pg_depend_d.h new file mode 100644 index 0000000000..a25be9e0ab --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_depend_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_depend_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_description.h b/contrib/libs/postgresql/src/include/catalog/pg_description.h new file mode 100644 index 0000000000..c40e8b7373 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_description.h @@ -0,0 +1,66 @@ +/*------------------------------------------------------------------------- + * + * pg_description.h + * definition of the "description" system catalog (pg_description) + * + * Because the contents of this table are taken from the *.dat files + * of other catalogs, there is no pg_description.dat file. The initial + * contents are assembled by genbki.pl and loaded during initdb. + * + * NOTE: an object is identified by the OID of the row that primarily + * defines the object, plus the OID of the table that that row appears in. + * For example, a function is identified by the OID of its pg_proc row + * plus the pg_class OID of table pg_proc. This allows unique identification + * of objects without assuming that OIDs are unique across tables. + * + * Since attributes don't have OIDs of their own, we identify an attribute + * comment by the objoid+classoid of its parent table, plus an "objsubid" + * giving the attribute column number. "objsubid" must be zero in a comment + * for a table itself, so that it is distinct from any column comment. + * Currently, objsubid is unused and zero for all other kinds of objects, + * but perhaps it might be useful someday to associate comments with + * constituent elements of other kinds of objects (arguments of a function, + * for example). + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_description.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_DESCRIPTION_H +#define PG_DESCRIPTION_H + +#include "catalog/genbki.h" +#include "catalog/pg_description_d.h" + +/* ---------------- + * pg_description definition. cpp turns this into + * typedef struct FormData_pg_description + * ---------------- + */ +CATALOG(pg_description,2609,DescriptionRelationId) +{ + Oid objoid; /* OID of object itself */ + Oid classoid; /* OID of table containing object */ + int32 objsubid; /* column number, or 0 if not used */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + text description BKI_FORCE_NOT_NULL; /* description of object */ +#endif +} FormData_pg_description; + +/* ---------------- + * Form_pg_description corresponds to a pointer to a tuple with + * the format of pg_description relation. + * ---------------- + */ +typedef FormData_pg_description * Form_pg_description; + +#endif /* PG_DESCRIPTION_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_description_d.h b/contrib/libs/postgresql/src/include/catalog/pg_description_d.h new file mode 100644 index 0000000000..72f10e1b92 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_description_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_description_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_enum.h b/contrib/libs/postgresql/src/include/catalog/pg_enum.h new file mode 100644 index 0000000000..b28d441ba7 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_enum.h @@ -0,0 +1,62 @@ +/*------------------------------------------------------------------------- + * + * pg_enum.h + * definition of the "enum" system catalog (pg_enum) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_enum.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_ENUM_H +#define PG_ENUM_H + +#include "catalog/genbki.h" +#include "catalog/pg_enum_d.h" + +#include "nodes/pg_list.h" + +/* ---------------- + * pg_enum definition. cpp turns this into + * typedef struct FormData_pg_enum + * ---------------- + */ +CATALOG(pg_enum,3501,EnumRelationId) +{ + Oid oid; /* oid */ + Oid enumtypid; /* OID of owning enum type */ + float4 enumsortorder; /* sort position of this enum value */ + NameData enumlabel; /* text representation of enum value */ +} FormData_pg_enum; + +/* ---------------- + * Form_pg_enum corresponds to a pointer to a tuple with + * the format of pg_enum relation. + * ---------------- + */ +typedef FormData_pg_enum *Form_pg_enum; + +/* + * prototypes for functions in pg_enum.c + */ +extern void EnumValuesCreate(Oid enumTypeOid, List *vals); +extern void EnumValuesDelete(Oid enumTypeOid); +extern void AddEnumLabel(Oid enumTypeOid, const char *newVal, + const char *neighbor, bool newValIsAfter, + bool skipIfExists); +extern void RenameEnumLabel(Oid enumTypeOid, + const char *oldVal, const char *newVal); +extern bool EnumBlacklisted(Oid enum_id); +extern Size EstimateEnumBlacklistSpace(void); +extern void SerializeEnumBlacklist(void *space, Size size); +extern void RestoreEnumBlacklist(void *space); +extern void AtEOXact_Enum(void); + +#endif /* PG_ENUM_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_enum_d.h b/contrib/libs/postgresql/src/include/catalog/pg_enum_d.h new file mode 100644 index 0000000000..5a10069294 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_enum_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_enum_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_event_trigger.h b/contrib/libs/postgresql/src/include/catalog/pg_event_trigger.h new file mode 100644 index 0000000000..24e4b1a181 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_event_trigger.h @@ -0,0 +1,51 @@ +/*------------------------------------------------------------------------- + * + * pg_event_trigger.h + * definition of the "event trigger" system catalog (pg_event_trigger) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_event_trigger.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_EVENT_TRIGGER_H +#define PG_EVENT_TRIGGER_H + +#include "catalog/genbki.h" +#include "catalog/pg_event_trigger_d.h" + +/* ---------------- + * pg_event_trigger definition. cpp turns this into + * typedef struct FormData_pg_event_trigger + * ---------------- + */ +CATALOG(pg_event_trigger,3466,EventTriggerRelationId) +{ + Oid oid; /* oid */ + NameData evtname; /* trigger's name */ + NameData evtevent; /* trigger's event */ + Oid evtowner; /* trigger's owner */ + Oid evtfoid; /* OID of function to be called */ + char evtenabled; /* trigger's firing configuration WRT + * session_replication_role */ + +#ifdef CATALOG_VARLEN + text evttags[1]; /* command TAGs this event trigger targets */ +#endif +} FormData_pg_event_trigger; + +/* ---------------- + * Form_pg_event_trigger corresponds to a pointer to a tuple with + * the format of pg_event_trigger relation. + * ---------------- + */ +typedef FormData_pg_event_trigger *Form_pg_event_trigger; + +#endif /* PG_EVENT_TRIGGER_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_event_trigger_d.h b/contrib/libs/postgresql/src/include/catalog/pg_event_trigger_d.h new file mode 100644 index 0000000000..20d5bf4845 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_event_trigger_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_event_trigger_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_extension.h b/contrib/libs/postgresql/src/include/catalog/pg_extension.h new file mode 100644 index 0000000000..b6f4128cf3 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_extension.h @@ -0,0 +1,52 @@ +/*------------------------------------------------------------------------- + * + * pg_extension.h + * definition of the "extension" system catalog (pg_extension) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_extension.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_EXTENSION_H +#define PG_EXTENSION_H + +#include "catalog/genbki.h" +#include "catalog/pg_extension_d.h" + +/* ---------------- + * pg_extension definition. cpp turns this into + * typedef struct FormData_pg_extension + * ---------------- + */ +CATALOG(pg_extension,3079,ExtensionRelationId) +{ + Oid oid; /* oid */ + NameData extname; /* extension name */ + Oid extowner; /* extension owner */ + Oid extnamespace; /* namespace of contained objects */ + bool extrelocatable; /* if true, allow ALTER EXTENSION SET SCHEMA */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + /* extversion may never be null, but the others can be. */ + text extversion BKI_FORCE_NOT_NULL; /* extension version name */ + Oid extconfig[1]; /* dumpable configuration tables */ + text extcondition[1]; /* WHERE clauses for config tables */ +#endif +} FormData_pg_extension; + +/* ---------------- + * Form_pg_extension corresponds to a pointer to a tuple with + * the format of pg_extension relation. + * ---------------- + */ +typedef FormData_pg_extension *Form_pg_extension; + +#endif /* PG_EXTENSION_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_extension_d.h b/contrib/libs/postgresql/src/include/catalog/pg_extension_d.h new file mode 100644 index 0000000000..be632265be --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_extension_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_extension_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_foreign_data_wrapper.h b/contrib/libs/postgresql/src/include/catalog/pg_foreign_data_wrapper.h new file mode 100644 index 0000000000..44d8558c41 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_foreign_data_wrapper.h @@ -0,0 +1,50 @@ +/*------------------------------------------------------------------------- + * + * pg_foreign_data_wrapper.h + * definition of the "foreign-data wrapper" system catalog (pg_foreign_data_wrapper) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_foreign_data_wrapper.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_FOREIGN_DATA_WRAPPER_H +#define PG_FOREIGN_DATA_WRAPPER_H + +#include "catalog/genbki.h" +#include "catalog/pg_foreign_data_wrapper_d.h" + +/* ---------------- + * pg_foreign_data_wrapper definition. cpp turns this into + * typedef struct FormData_pg_foreign_data_wrapper + * ---------------- + */ +CATALOG(pg_foreign_data_wrapper,2328,ForeignDataWrapperRelationId) +{ + Oid oid; /* oid */ + NameData fdwname; /* foreign-data wrapper name */ + Oid fdwowner; /* FDW owner */ + Oid fdwhandler; /* handler function, or 0 if none */ + Oid fdwvalidator; /* option validation function, or 0 if none */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + aclitem fdwacl[1]; /* access permissions */ + text fdwoptions[1]; /* FDW options */ +#endif +} FormData_pg_foreign_data_wrapper; + +/* ---------------- + * Form_pg_foreign_data_wrapper corresponds to a pointer to a tuple with + * the format of pg_foreign_data_wrapper relation. + * ---------------- + */ +typedef FormData_pg_foreign_data_wrapper *Form_pg_foreign_data_wrapper; + +#endif /* PG_FOREIGN_DATA_WRAPPER_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_foreign_data_wrapper_d.h b/contrib/libs/postgresql/src/include/catalog/pg_foreign_data_wrapper_d.h new file mode 100644 index 0000000000..7098c77d41 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_foreign_data_wrapper_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_foreign_data_wrapper_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_foreign_server.h b/contrib/libs/postgresql/src/include/catalog/pg_foreign_server.h new file mode 100644 index 0000000000..5c17004151 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_foreign_server.h @@ -0,0 +1,50 @@ +/*------------------------------------------------------------------------- + * + * pg_foreign_server.h + * definition of the "foreign server" system catalog (pg_foreign_server) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_foreign_server.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_FOREIGN_SERVER_H +#define PG_FOREIGN_SERVER_H + +#include "catalog/genbki.h" +#include "catalog/pg_foreign_server_d.h" + +/* ---------------- + * pg_foreign_server definition. cpp turns this into + * typedef struct FormData_pg_foreign_server + * ---------------- + */ +CATALOG(pg_foreign_server,1417,ForeignServerRelationId) +{ + Oid oid; /* oid */ + NameData srvname; /* foreign server name */ + Oid srvowner; /* server owner */ + Oid srvfdw; /* server FDW */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + text srvtype; + text srvversion; + aclitem srvacl[1]; /* access permissions */ + text srvoptions[1]; /* FDW-specific options */ +#endif +} FormData_pg_foreign_server; + +/* ---------------- + * Form_pg_foreign_server corresponds to a pointer to a tuple with + * the format of pg_foreign_server relation. + * ---------------- + */ +typedef FormData_pg_foreign_server *Form_pg_foreign_server; + +#endif /* PG_FOREIGN_SERVER_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_foreign_server_d.h b/contrib/libs/postgresql/src/include/catalog/pg_foreign_server_d.h new file mode 100644 index 0000000000..baddc2a76d --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_foreign_server_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_foreign_server_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_foreign_table.h b/contrib/libs/postgresql/src/include/catalog/pg_foreign_table.h new file mode 100644 index 0000000000..31c1faed03 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_foreign_table.h @@ -0,0 +1,45 @@ +/*------------------------------------------------------------------------- + * + * pg_foreign_table.h + * definition of the "foreign table" system catalog (pg_foreign_table) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_foreign_table.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_FOREIGN_TABLE_H +#define PG_FOREIGN_TABLE_H + +#include "catalog/genbki.h" +#include "catalog/pg_foreign_table_d.h" + +/* ---------------- + * pg_foreign_table definition. cpp turns this into + * typedef struct FormData_pg_foreign_table + * ---------------- + */ +CATALOG(pg_foreign_table,3118,ForeignTableRelationId) +{ + Oid ftrelid; /* OID of foreign table */ + Oid ftserver; /* OID of foreign server */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + text ftoptions[1]; /* FDW-specific options */ +#endif +} FormData_pg_foreign_table; + +/* ---------------- + * Form_pg_foreign_table corresponds to a pointer to a tuple with + * the format of pg_foreign_table relation. + * ---------------- + */ +typedef FormData_pg_foreign_table *Form_pg_foreign_table; + +#endif /* PG_FOREIGN_TABLE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_foreign_table_d.h b/contrib/libs/postgresql/src/include/catalog/pg_foreign_table_d.h new file mode 100644 index 0000000000..a8822cbf34 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_foreign_table_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_foreign_table_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_index.h b/contrib/libs/postgresql/src/include/catalog/pg_index.h new file mode 100644 index 0000000000..d3d7ea77fb --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_index.h @@ -0,0 +1,80 @@ +/*------------------------------------------------------------------------- + * + * pg_index.h + * definition of the "index" system catalog (pg_index) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_index.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_INDEX_H +#define PG_INDEX_H + +#include "catalog/genbki.h" +#include "catalog/pg_index_d.h" + +/* ---------------- + * pg_index definition. cpp turns this into + * typedef struct FormData_pg_index. + * ---------------- + */ +CATALOG(pg_index,2610,IndexRelationId) BKI_SCHEMA_MACRO +{ + Oid indexrelid; /* OID of the index */ + Oid indrelid; /* OID of the relation it indexes */ + int16 indnatts; /* total number of columns in index */ + int16 indnkeyatts; /* number of key columns in index */ + bool indisunique; /* is this a unique index? */ + bool indisprimary; /* is this index for primary key? */ + bool indisexclusion; /* is this index for exclusion constraint? */ + bool indimmediate; /* is uniqueness enforced immediately? */ + bool indisclustered; /* is this the index last clustered by? */ + bool indisvalid; /* is this index valid for use by queries? */ + bool indcheckxmin; /* must we wait for xmin to be old? */ + bool indisready; /* is this index ready for inserts? */ + bool indislive; /* is this index alive at all? */ + bool indisreplident; /* is this index the identity for replication? */ + + /* variable-length fields start here, but we allow direct access to indkey */ + int2vector indkey; /* column numbers of indexed cols, or 0 */ + +#ifdef CATALOG_VARLEN + oidvector indcollation; /* collation identifiers */ + oidvector indclass; /* opclass identifiers */ + int2vector indoption; /* per-column flags (AM-specific meanings) */ + pg_node_tree indexprs; /* expression trees for index attributes that + * are not simple column references; one for + * each zero entry in indkey[] */ + pg_node_tree indpred; /* expression tree for predicate, if a partial + * index; else NULL */ +#endif +} FormData_pg_index; + +/* ---------------- + * Form_pg_index corresponds to a pointer to a tuple with + * the format of pg_index relation. + * ---------------- + */ +typedef FormData_pg_index *Form_pg_index; + +#ifdef EXPOSE_TO_CLIENT_CODE + +/* + * Index AMs that support ordered scans must support these two indoption + * bits. Otherwise, the content of the per-column indoption fields is + * open for future definition. + */ +#define INDOPTION_DESC 0x0001 /* values are in reverse order */ +#define INDOPTION_NULLS_FIRST 0x0002 /* NULLs are first instead of last */ + +#endif /* EXPOSE_TO_CLIENT_CODE */ + +#endif /* PG_INDEX_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_index_d.h b/contrib/libs/postgresql/src/include/catalog/pg_index_d.h new file mode 100644 index 0000000000..f503f4f562 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_index_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_index_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_inherits.h b/contrib/libs/postgresql/src/include/catalog/pg_inherits.h new file mode 100644 index 0000000000..0432c3ab88 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_inherits.h @@ -0,0 +1,57 @@ +/*------------------------------------------------------------------------- + * + * pg_inherits.h + * definition of the "inherits" system catalog (pg_inherits) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_inherits.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_INHERITS_H +#define PG_INHERITS_H + +#include "catalog/genbki.h" +#include "catalog/pg_inherits_d.h" + +#include "nodes/pg_list.h" +#include "storage/lock.h" + +/* ---------------- + * pg_inherits definition. cpp turns this into + * typedef struct FormData_pg_inherits + * ---------------- + */ +CATALOG(pg_inherits,2611,InheritsRelationId) +{ + Oid inhrelid; + Oid inhparent; + int32 inhseqno; +} FormData_pg_inherits; + +/* ---------------- + * Form_pg_inherits corresponds to a pointer to a tuple with + * the format of pg_inherits relation. + * ---------------- + */ +typedef FormData_pg_inherits *Form_pg_inherits; + + +extern List *find_inheritance_children(Oid parentrelId, LOCKMODE lockmode); +extern List *find_all_inheritors(Oid parentrelId, LOCKMODE lockmode, + List **parents); +extern bool has_subclass(Oid relationId); +extern bool has_superclass(Oid relationId); +extern bool typeInheritsFrom(Oid subclassTypeId, Oid superclassTypeId); +extern void StoreSingleInheritance(Oid relationId, Oid parentOid, + int32 seqNumber); +extern bool DeleteInheritsTuple(Oid inhrelid, Oid inhparent); + +#endif /* PG_INHERITS_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_inherits_d.h b/contrib/libs/postgresql/src/include/catalog/pg_inherits_d.h new file mode 100644 index 0000000000..ce95d9c904 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_inherits_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_inherits_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_init_privs.h b/contrib/libs/postgresql/src/include/catalog/pg_init_privs.h new file mode 100644 index 0000000000..7734b72c04 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_init_privs.h @@ -0,0 +1,78 @@ +/*------------------------------------------------------------------------- + * + * pg_init_privs.h + * definition of the "initial privileges" system catalog (pg_init_privs) + * + * NOTE: an object is identified by the OID of the row that primarily + * defines the object, plus the OID of the table that that row appears in. + * For example, a function is identified by the OID of its pg_proc row + * plus the pg_class OID of table pg_proc. This allows unique identification + * of objects without assuming that OIDs are unique across tables. + * + * Since attributes don't have OIDs of their own, we identify an attribute + * privilege by the objoid+classoid of its parent table, plus an "objsubid" + * giving the attribute column number. "objsubid" must be zero in a privilege + * for a table itself, so that it is distinct from any column privilege. + * Currently, objsubid is unused and zero for all other kinds of objects. + * + * Because the contents of this table depend on what is done with the other + * objects in the system (and, in particular, may change due to changes in + * system_views.sql), there is no pg_init_privs.dat file. The initial contents + * are loaded near the end of initdb. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_init_privs.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_INIT_PRIVS_H +#define PG_INIT_PRIVS_H + +#include "catalog/genbki.h" +#include "catalog/pg_init_privs_d.h" + +/* ---------------- + * pg_init_privs definition. cpp turns this into + * typedef struct FormData_pg_init_privs + * ---------------- + */ +CATALOG(pg_init_privs,3394,InitPrivsRelationId) +{ + Oid objoid; /* OID of object itself */ + Oid classoid; /* OID of table containing object */ + int32 objsubid; /* column number, or 0 if not used */ + char privtype; /* from initdb or extension? */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + aclitem initprivs[1] BKI_FORCE_NOT_NULL; /* initial privs on object */ +#endif +} FormData_pg_init_privs; + +/* ---------------- + * Form_pg_init_privs corresponds to a pointer to a tuple with + * the format of pg_init_privs relation. + * ---------------- + */ +typedef FormData_pg_init_privs * Form_pg_init_privs; + +/* + * It is important to know if the initial privileges are from initdb or from an + * extension. This enum is used to provide that differentiation and the two + * places which populate this table (initdb and during CREATE EXTENSION, see + * recordExtensionInitPriv()) know to use the correct values. + */ + +typedef enum InitPrivsType +{ + INITPRIVS_INITDB = 'i', + INITPRIVS_EXTENSION = 'e' +} InitPrivsType; + +#endif /* PG_INIT_PRIVS_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_init_privs_d.h b/contrib/libs/postgresql/src/include/catalog/pg_init_privs_d.h new file mode 100644 index 0000000000..267e64e304 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_init_privs_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_init_privs_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_language.dat b/contrib/libs/postgresql/src/include/catalog/pg_language.dat new file mode 100644 index 0000000000..2e44a2730d --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_language.dat @@ -0,0 +1,25 @@ +#---------------------------------------------------------------------- +# +# pg_language.dat +# Initial contents of the pg_language system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_language.dat +# +#---------------------------------------------------------------------- + +[ + +{ oid => '12', oid_symbol => 'INTERNALlanguageId', + descr => 'built-in functions', + lanname => 'internal', lanvalidator => 'fmgr_internal_validator' }, +{ oid => '13', oid_symbol => 'ClanguageId', + descr => 'dynamically-loaded C functions', + lanname => 'c', lanvalidator => 'fmgr_c_validator' }, +{ oid => '14', oid_symbol => 'SQLlanguageId', + descr => 'SQL-language functions', + lanname => 'sql', lanpltrusted => 't', lanvalidator => 'fmgr_sql_validator' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_language.h b/contrib/libs/postgresql/src/include/catalog/pg_language.h new file mode 100644 index 0000000000..937bacbf98 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_language.h @@ -0,0 +1,67 @@ +/*------------------------------------------------------------------------- + * + * pg_language.h + * definition of the "language" system catalog (pg_language) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_language.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_LANGUAGE_H +#define PG_LANGUAGE_H + +#include "catalog/genbki.h" +#include "catalog/pg_language_d.h" + +/* ---------------- + * pg_language definition. cpp turns this into + * typedef struct FormData_pg_language + * ---------------- + */ +CATALOG(pg_language,2612,LanguageRelationId) +{ + Oid oid; /* oid */ + + /* Language name */ + NameData lanname; + + /* Language's owner */ + Oid lanowner BKI_DEFAULT(PGUID); + + /* Is a procedural language */ + bool lanispl BKI_DEFAULT(f); + + /* PL is trusted */ + bool lanpltrusted BKI_DEFAULT(f); + + /* Call handler, if it's a PL */ + Oid lanplcallfoid BKI_DEFAULT(0) BKI_LOOKUP(pg_proc); + + /* Optional anonymous-block handler function */ + Oid laninline BKI_DEFAULT(0) BKI_LOOKUP(pg_proc); + + /* Optional validation function */ + Oid lanvalidator BKI_DEFAULT(0) BKI_LOOKUP(pg_proc); + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + /* Access privileges */ + aclitem lanacl[1] BKI_DEFAULT(_null_); +#endif +} FormData_pg_language; + +/* ---------------- + * Form_pg_language corresponds to a pointer to a tuple with + * the format of pg_language relation. + * ---------------- + */ +typedef FormData_pg_language *Form_pg_language; + +#endif /* PG_LANGUAGE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_language_d.h b/contrib/libs/postgresql/src/include/catalog/pg_language_d.h new file mode 100644 index 0000000000..4cb0a127ed --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_language_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_language_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_largeobject.h b/contrib/libs/postgresql/src/include/catalog/pg_largeobject.h new file mode 100644 index 0000000000..f64703ff8d --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_largeobject.h @@ -0,0 +1,50 @@ +/*------------------------------------------------------------------------- + * + * pg_largeobject.h + * definition of the "large object" system catalog (pg_largeobject) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_largeobject.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_LARGEOBJECT_H +#define PG_LARGEOBJECT_H + +#include "catalog/genbki.h" +#include "catalog/pg_largeobject_d.h" + +/* ---------------- + * pg_largeobject definition. cpp turns this into + * typedef struct FormData_pg_largeobject + * ---------------- + */ +CATALOG(pg_largeobject,2613,LargeObjectRelationId) +{ + Oid loid; /* Identifier of large object */ + int32 pageno; /* Page number (starting from 0) */ + + /* data has variable length, but we allow direct access; see inv_api.c */ + bytea data BKI_FORCE_NOT_NULL; /* Data for page (may be + * zero-length) */ +} FormData_pg_largeobject; + +/* ---------------- + * Form_pg_largeobject corresponds to a pointer to a tuple with + * the format of pg_largeobject relation. + * ---------------- + */ +typedef FormData_pg_largeobject *Form_pg_largeobject; + +extern Oid LargeObjectCreate(Oid loid); +extern void LargeObjectDrop(Oid loid); +extern bool LargeObjectExists(Oid loid); + +#endif /* PG_LARGEOBJECT_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_largeobject_d.h b/contrib/libs/postgresql/src/include/catalog/pg_largeobject_d.h new file mode 100644 index 0000000000..15d990ad91 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_largeobject_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_largeobject_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_largeobject_metadata.h b/contrib/libs/postgresql/src/include/catalog/pg_largeobject_metadata.h new file mode 100644 index 0000000000..8f6b4720d4 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_largeobject_metadata.h @@ -0,0 +1,48 @@ +/*------------------------------------------------------------------------- + * + * pg_largeobject_metadata.h + * definition of the "large object metadata" system catalog + * (pg_largeobject_metadata) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_largeobject_metadata.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_LARGEOBJECT_METADATA_H +#define PG_LARGEOBJECT_METADATA_H + +#include "catalog/genbki.h" +#include "catalog/pg_largeobject_metadata_d.h" + +/* ---------------- + * pg_largeobject_metadata definition. cpp turns this into + * typedef struct FormData_pg_largeobject_metadata + * ---------------- + */ +CATALOG(pg_largeobject_metadata,2995,LargeObjectMetadataRelationId) +{ + Oid oid; /* oid */ + + Oid lomowner; /* OID of the largeobject owner */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + aclitem lomacl[1]; /* access permissions */ +#endif +} FormData_pg_largeobject_metadata; + +/* ---------------- + * Form_pg_largeobject_metadata corresponds to a pointer to a tuple + * with the format of pg_largeobject_metadata relation. + * ---------------- + */ +typedef FormData_pg_largeobject_metadata *Form_pg_largeobject_metadata; + +#endif /* PG_LARGEOBJECT_METADATA_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_largeobject_metadata_d.h b/contrib/libs/postgresql/src/include/catalog/pg_largeobject_metadata_d.h new file mode 100644 index 0000000000..b7fea19e57 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_largeobject_metadata_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_largeobject_metadata_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_namespace.dat b/contrib/libs/postgresql/src/include/catalog/pg_namespace.dat new file mode 100644 index 0000000000..63a61022ce --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_namespace.dat @@ -0,0 +1,25 @@ +#---------------------------------------------------------------------- +# +# pg_namespace.dat +# Initial contents of the pg_namespace system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_namespace.dat +# +#---------------------------------------------------------------------- + +[ + +{ oid => '11', oid_symbol => 'PG_CATALOG_NAMESPACE', + descr => 'system catalog schema', + nspname => 'pg_catalog', nspowner => 'PGUID', nspacl => '_null_' }, +{ oid => '99', oid_symbol => 'PG_TOAST_NAMESPACE', + descr => 'reserved schema for TOAST tables', + nspname => 'pg_toast', nspowner => 'PGUID', nspacl => '_null_' }, +{ oid => '2200', oid_symbol => 'PG_PUBLIC_NAMESPACE', + descr => 'standard public schema', + nspname => 'public', nspowner => 'PGUID', nspacl => '_null_' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_namespace.h b/contrib/libs/postgresql/src/include/catalog/pg_namespace.h new file mode 100644 index 0000000000..db93b27015 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_namespace.h @@ -0,0 +1,59 @@ +/*------------------------------------------------------------------------- + * + * pg_namespace.h + * definition of the "namespace" system catalog (pg_namespace) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_namespace.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_NAMESPACE_H +#define PG_NAMESPACE_H + +#include "catalog/genbki.h" +#include "catalog/pg_namespace_d.h" +#include "utils/acl.h" + +/* ---------------------------------------------------------------- + * pg_namespace definition. + * + * cpp turns this into typedef struct FormData_pg_namespace + * + * nspname name of the namespace + * nspowner owner (creator) of the namespace + * nspacl access privilege list + * ---------------------------------------------------------------- + */ +CATALOG(pg_namespace,2615,NamespaceRelationId) +{ + Oid oid; /* oid */ + + NameData nspname; + Oid nspowner; + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + aclitem nspacl[1]; +#endif +} FormData_pg_namespace; + +/* ---------------- + * Form_pg_namespace corresponds to a pointer to a tuple with + * the format of pg_namespace relation. + * ---------------- + */ +typedef FormData_pg_namespace *Form_pg_namespace; + +/* + * prototypes for functions in pg_namespace.c + */ +extern Oid NamespaceCreate(const char *nspName, Oid ownerId, bool isTemp); + +#endif /* PG_NAMESPACE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_namespace_d.h b/contrib/libs/postgresql/src/include/catalog/pg_namespace_d.h new file mode 100644 index 0000000000..a6ec80c6b0 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_namespace_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_namespace_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_opclass.dat b/contrib/libs/postgresql/src/include/catalog/pg_opclass.dat new file mode 100644 index 0000000000..f2342bb328 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_opclass.dat @@ -0,0 +1,350 @@ +#---------------------------------------------------------------------- +# +# pg_opclass.dat +# Initial contents of the pg_opclass system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_opclass.dat +# +#---------------------------------------------------------------------- + +[ + +# Note: we hard-wire an OID only for a few entries that have to be explicitly +# referenced in the C code or in built-in catalog entries. The rest get OIDs +# assigned on-the-fly during initdb. + +{ opcmethod => 'btree', opcname => 'array_ops', opcfamily => 'btree/array_ops', + opcintype => 'anyarray' }, +{ opcmethod => 'hash', opcname => 'array_ops', opcfamily => 'hash/array_ops', + opcintype => 'anyarray' }, +{ opcmethod => 'btree', opcname => 'bit_ops', opcfamily => 'btree/bit_ops', + opcintype => 'bit' }, +{ opcmethod => 'btree', opcname => 'bool_ops', opcfamily => 'btree/bool_ops', + opcintype => 'bool' }, +{ opcmethod => 'btree', opcname => 'bpchar_ops', + opcfamily => 'btree/bpchar_ops', opcintype => 'bpchar' }, +{ opcmethod => 'hash', opcname => 'bpchar_ops', opcfamily => 'hash/bpchar_ops', + opcintype => 'bpchar' }, +{ opcmethod => 'btree', opcname => 'bytea_ops', opcfamily => 'btree/bytea_ops', + opcintype => 'bytea' }, +{ opcmethod => 'btree', opcname => 'char_ops', opcfamily => 'btree/char_ops', + opcintype => 'char' }, +{ opcmethod => 'hash', opcname => 'char_ops', opcfamily => 'hash/char_ops', + opcintype => 'char' }, +{ opcmethod => 'btree', opcname => 'cidr_ops', opcfamily => 'btree/network_ops', + opcintype => 'inet', opcdefault => 'f' }, +{ opcmethod => 'hash', opcname => 'cidr_ops', opcfamily => 'hash/network_ops', + opcintype => 'inet', opcdefault => 'f' }, +{ oid => '3122', oid_symbol => 'DATE_BTREE_OPS_OID', + opcmethod => 'btree', opcname => 'date_ops', + opcfamily => 'btree/datetime_ops', opcintype => 'date' }, +{ opcmethod => 'hash', opcname => 'date_ops', opcfamily => 'hash/date_ops', + opcintype => 'date' }, +{ opcmethod => 'btree', opcname => 'float4_ops', opcfamily => 'btree/float_ops', + opcintype => 'float4' }, +{ opcmethod => 'hash', opcname => 'float4_ops', opcfamily => 'hash/float_ops', + opcintype => 'float4' }, +{ oid => '3123', oid_symbol => 'FLOAT8_BTREE_OPS_OID', + opcmethod => 'btree', opcname => 'float8_ops', opcfamily => 'btree/float_ops', + opcintype => 'float8' }, +{ opcmethod => 'hash', opcname => 'float8_ops', opcfamily => 'hash/float_ops', + opcintype => 'float8' }, +{ opcmethod => 'btree', opcname => 'inet_ops', opcfamily => 'btree/network_ops', + opcintype => 'inet' }, +{ opcmethod => 'hash', opcname => 'inet_ops', opcfamily => 'hash/network_ops', + opcintype => 'inet' }, +{ opcmethod => 'gist', opcname => 'inet_ops', opcfamily => 'gist/network_ops', + opcintype => 'inet', opcdefault => 'f' }, +{ opcmethod => 'spgist', opcname => 'inet_ops', + opcfamily => 'spgist/network_ops', opcintype => 'inet' }, +{ oid => '1979', oid_symbol => 'INT2_BTREE_OPS_OID', + opcmethod => 'btree', opcname => 'int2_ops', opcfamily => 'btree/integer_ops', + opcintype => 'int2' }, +{ opcmethod => 'hash', opcname => 'int2_ops', opcfamily => 'hash/integer_ops', + opcintype => 'int2' }, +{ oid => '1978', oid_symbol => 'INT4_BTREE_OPS_OID', + opcmethod => 'btree', opcname => 'int4_ops', opcfamily => 'btree/integer_ops', + opcintype => 'int4' }, +{ opcmethod => 'hash', opcname => 'int4_ops', opcfamily => 'hash/integer_ops', + opcintype => 'int4' }, +{ oid => '3124', oid_symbol => 'INT8_BTREE_OPS_OID', + opcmethod => 'btree', opcname => 'int8_ops', opcfamily => 'btree/integer_ops', + opcintype => 'int8' }, +{ opcmethod => 'hash', opcname => 'int8_ops', opcfamily => 'hash/integer_ops', + opcintype => 'int8' }, +{ opcmethod => 'btree', opcname => 'interval_ops', + opcfamily => 'btree/interval_ops', opcintype => 'interval' }, +{ opcmethod => 'hash', opcname => 'interval_ops', + opcfamily => 'hash/interval_ops', opcintype => 'interval' }, +{ opcmethod => 'btree', opcname => 'macaddr_ops', + opcfamily => 'btree/macaddr_ops', opcintype => 'macaddr' }, +{ opcmethod => 'hash', opcname => 'macaddr_ops', + opcfamily => 'hash/macaddr_ops', opcintype => 'macaddr' }, +{ opcmethod => 'btree', opcname => 'macaddr8_ops', + opcfamily => 'btree/macaddr8_ops', opcintype => 'macaddr8' }, +{ opcmethod => 'hash', opcname => 'macaddr8_ops', + opcfamily => 'hash/macaddr8_ops', opcintype => 'macaddr8' }, + +# Here's an ugly little hack to save space in the system catalog indexes. +# btree doesn't ordinarily allow a storage type different from input type; +# but cstring and name are the same thing except for trailing padding, +# and we can safely omit that within an index entry. So we declare the +# btree opclass for name as using cstring storage type. +{ opcmethod => 'btree', opcname => 'name_ops', opcfamily => 'btree/text_ops', + opcintype => 'name', opckeytype => 'cstring' }, + +{ opcmethod => 'hash', opcname => 'name_ops', opcfamily => 'hash/text_ops', + opcintype => 'name' }, +{ oid => '3125', oid_symbol => 'NUMERIC_BTREE_OPS_OID', + opcmethod => 'btree', opcname => 'numeric_ops', + opcfamily => 'btree/numeric_ops', opcintype => 'numeric' }, +{ opcmethod => 'hash', opcname => 'numeric_ops', + opcfamily => 'hash/numeric_ops', opcintype => 'numeric' }, +{ oid => '1981', oid_symbol => 'OID_BTREE_OPS_OID', + opcmethod => 'btree', opcname => 'oid_ops', opcfamily => 'btree/oid_ops', + opcintype => 'oid' }, +{ opcmethod => 'hash', opcname => 'oid_ops', opcfamily => 'hash/oid_ops', + opcintype => 'oid' }, +{ opcmethod => 'btree', opcname => 'oidvector_ops', + opcfamily => 'btree/oidvector_ops', opcintype => 'oidvector' }, +{ opcmethod => 'hash', opcname => 'oidvector_ops', + opcfamily => 'hash/oidvector_ops', opcintype => 'oidvector' }, +{ opcmethod => 'btree', opcname => 'record_ops', + opcfamily => 'btree/record_ops', opcintype => 'record' }, +{ opcmethod => 'btree', opcname => 'record_image_ops', + opcfamily => 'btree/record_image_ops', opcintype => 'record', + opcdefault => 'f' }, +{ oid => '3126', oid_symbol => 'TEXT_BTREE_OPS_OID', + opcmethod => 'btree', opcname => 'text_ops', opcfamily => 'btree/text_ops', + opcintype => 'text' }, +{ opcmethod => 'hash', opcname => 'text_ops', opcfamily => 'hash/text_ops', + opcintype => 'text' }, +{ opcmethod => 'btree', opcname => 'time_ops', opcfamily => 'btree/time_ops', + opcintype => 'time' }, +{ opcmethod => 'hash', opcname => 'time_ops', opcfamily => 'hash/time_ops', + opcintype => 'time' }, +{ oid => '3127', oid_symbol => 'TIMESTAMPTZ_BTREE_OPS_OID', + opcmethod => 'btree', opcname => 'timestamptz_ops', + opcfamily => 'btree/datetime_ops', opcintype => 'timestamptz' }, +{ opcmethod => 'hash', opcname => 'timestamptz_ops', + opcfamily => 'hash/timestamptz_ops', opcintype => 'timestamptz' }, +{ opcmethod => 'btree', opcname => 'timetz_ops', + opcfamily => 'btree/timetz_ops', opcintype => 'timetz' }, +{ opcmethod => 'hash', opcname => 'timetz_ops', opcfamily => 'hash/timetz_ops', + opcintype => 'timetz' }, +{ opcmethod => 'btree', opcname => 'varbit_ops', + opcfamily => 'btree/varbit_ops', opcintype => 'varbit' }, +{ opcmethod => 'btree', opcname => 'varchar_ops', opcfamily => 'btree/text_ops', + opcintype => 'text', opcdefault => 'f' }, +{ opcmethod => 'hash', opcname => 'varchar_ops', opcfamily => 'hash/text_ops', + opcintype => 'text', opcdefault => 'f' }, +{ oid => '3128', oid_symbol => 'TIMESTAMP_BTREE_OPS_OID', + opcmethod => 'btree', opcname => 'timestamp_ops', + opcfamily => 'btree/datetime_ops', opcintype => 'timestamp' }, +{ opcmethod => 'hash', opcname => 'timestamp_ops', + opcfamily => 'hash/timestamp_ops', opcintype => 'timestamp' }, +{ oid => '4217', oid_symbol => 'TEXT_BTREE_PATTERN_OPS_OID', + opcmethod => 'btree', opcname => 'text_pattern_ops', + opcfamily => 'btree/text_pattern_ops', opcintype => 'text', + opcdefault => 'f' }, +{ oid => '4218', oid_symbol => 'VARCHAR_BTREE_PATTERN_OPS_OID', + opcmethod => 'btree', opcname => 'varchar_pattern_ops', + opcfamily => 'btree/text_pattern_ops', opcintype => 'text', + opcdefault => 'f' }, +{ oid => '4219', oid_symbol => 'BPCHAR_BTREE_PATTERN_OPS_OID', + opcmethod => 'btree', opcname => 'bpchar_pattern_ops', + opcfamily => 'btree/bpchar_pattern_ops', opcintype => 'bpchar', + opcdefault => 'f' }, +{ opcmethod => 'btree', opcname => 'money_ops', opcfamily => 'btree/money_ops', + opcintype => 'money' }, +{ opcmethod => 'hash', opcname => 'bool_ops', opcfamily => 'hash/bool_ops', + opcintype => 'bool' }, +{ opcmethod => 'hash', opcname => 'bytea_ops', opcfamily => 'hash/bytea_ops', + opcintype => 'bytea' }, +{ opcmethod => 'btree', opcname => 'tid_ops', opcfamily => 'btree/tid_ops', + opcintype => 'tid' }, +{ opcmethod => 'hash', opcname => 'xid_ops', opcfamily => 'hash/xid_ops', + opcintype => 'xid' }, +{ opcmethod => 'hash', opcname => 'xid8_ops', opcfamily => 'hash/xid8_ops', + opcintype => 'xid8' }, +{ opcmethod => 'btree', opcname => 'xid8_ops', opcfamily => 'btree/xid8_ops', + opcintype => 'xid8' }, +{ opcmethod => 'hash', opcname => 'cid_ops', opcfamily => 'hash/cid_ops', + opcintype => 'cid' }, +{ opcmethod => 'hash', opcname => 'tid_ops', opcfamily => 'hash/tid_ops', + opcintype => 'tid' }, +{ opcmethod => 'hash', opcname => 'text_pattern_ops', + opcfamily => 'hash/text_pattern_ops', opcintype => 'text', + opcdefault => 'f' }, +{ opcmethod => 'hash', opcname => 'varchar_pattern_ops', + opcfamily => 'hash/text_pattern_ops', opcintype => 'text', + opcdefault => 'f' }, +{ opcmethod => 'hash', opcname => 'bpchar_pattern_ops', + opcfamily => 'hash/bpchar_pattern_ops', opcintype => 'bpchar', + opcdefault => 'f' }, +{ opcmethod => 'hash', opcname => 'aclitem_ops', + opcfamily => 'hash/aclitem_ops', opcintype => 'aclitem' }, +{ opcmethod => 'gist', opcname => 'box_ops', opcfamily => 'gist/box_ops', + opcintype => 'box' }, +{ opcmethod => 'gist', opcname => 'point_ops', opcfamily => 'gist/point_ops', + opcintype => 'point', opckeytype => 'box' }, +{ opcmethod => 'gist', opcname => 'poly_ops', opcfamily => 'gist/poly_ops', + opcintype => 'polygon', opckeytype => 'box' }, +{ opcmethod => 'gist', opcname => 'circle_ops', opcfamily => 'gist/circle_ops', + opcintype => 'circle', opckeytype => 'box' }, +{ opcmethod => 'gin', opcname => 'array_ops', opcfamily => 'gin/array_ops', + opcintype => 'anyarray', opckeytype => 'anyelement' }, +{ opcmethod => 'btree', opcname => 'uuid_ops', opcfamily => 'btree/uuid_ops', + opcintype => 'uuid' }, +{ opcmethod => 'hash', opcname => 'uuid_ops', opcfamily => 'hash/uuid_ops', + opcintype => 'uuid' }, +{ opcmethod => 'btree', opcname => 'pg_lsn_ops', + opcfamily => 'btree/pg_lsn_ops', opcintype => 'pg_lsn' }, +{ opcmethod => 'hash', opcname => 'pg_lsn_ops', opcfamily => 'hash/pg_lsn_ops', + opcintype => 'pg_lsn' }, +{ opcmethod => 'btree', opcname => 'enum_ops', opcfamily => 'btree/enum_ops', + opcintype => 'anyenum' }, +{ opcmethod => 'hash', opcname => 'enum_ops', opcfamily => 'hash/enum_ops', + opcintype => 'anyenum' }, +{ opcmethod => 'btree', opcname => 'tsvector_ops', + opcfamily => 'btree/tsvector_ops', opcintype => 'tsvector' }, +{ opcmethod => 'gist', opcname => 'tsvector_ops', + opcfamily => 'gist/tsvector_ops', opcintype => 'tsvector', + opckeytype => 'gtsvector' }, +{ opcmethod => 'gin', opcname => 'tsvector_ops', + opcfamily => 'gin/tsvector_ops', opcintype => 'tsvector', + opckeytype => 'text' }, +{ opcmethod => 'btree', opcname => 'tsquery_ops', + opcfamily => 'btree/tsquery_ops', opcintype => 'tsquery' }, +{ opcmethod => 'gist', opcname => 'tsquery_ops', + opcfamily => 'gist/tsquery_ops', opcintype => 'tsquery', + opckeytype => 'int8' }, +{ opcmethod => 'btree', opcname => 'range_ops', opcfamily => 'btree/range_ops', + opcintype => 'anyrange' }, +{ opcmethod => 'hash', opcname => 'range_ops', opcfamily => 'hash/range_ops', + opcintype => 'anyrange' }, +{ opcmethod => 'gist', opcname => 'range_ops', opcfamily => 'gist/range_ops', + opcintype => 'anyrange' }, +{ opcmethod => 'spgist', opcname => 'range_ops', + opcfamily => 'spgist/range_ops', opcintype => 'anyrange' }, +{ opcmethod => 'spgist', opcname => 'box_ops', opcfamily => 'spgist/box_ops', + opcintype => 'box' }, +{ opcmethod => 'spgist', opcname => 'quad_point_ops', + opcfamily => 'spgist/quad_point_ops', opcintype => 'point' }, +{ opcmethod => 'spgist', opcname => 'kd_point_ops', + opcfamily => 'spgist/kd_point_ops', opcintype => 'point', opcdefault => 'f' }, +{ opcmethod => 'spgist', opcname => 'text_ops', opcfamily => 'spgist/text_ops', + opcintype => 'text' }, +{ opcmethod => 'spgist', opcname => 'poly_ops', opcfamily => 'spgist/poly_ops', + opcintype => 'polygon', opckeytype => 'box' }, +{ opcmethod => 'btree', opcname => 'jsonb_ops', opcfamily => 'btree/jsonb_ops', + opcintype => 'jsonb' }, +{ opcmethod => 'hash', opcname => 'jsonb_ops', opcfamily => 'hash/jsonb_ops', + opcintype => 'jsonb' }, +{ opcmethod => 'gin', opcname => 'jsonb_ops', opcfamily => 'gin/jsonb_ops', + opcintype => 'jsonb', opckeytype => 'text' }, +{ opcmethod => 'gin', opcname => 'jsonb_path_ops', + opcfamily => 'gin/jsonb_path_ops', opcintype => 'jsonb', opcdefault => 'f', + opckeytype => 'int4' }, + +# BRIN operator classes + +# no brin opclass for bool + +{ opcmethod => 'brin', opcname => 'bytea_minmax_ops', + opcfamily => 'brin/bytea_minmax_ops', opcintype => 'bytea', + opckeytype => 'bytea' }, +{ opcmethod => 'brin', opcname => 'char_minmax_ops', + opcfamily => 'brin/char_minmax_ops', opcintype => 'char', + opckeytype => 'char' }, +{ opcmethod => 'brin', opcname => 'name_minmax_ops', + opcfamily => 'brin/name_minmax_ops', opcintype => 'name', + opckeytype => 'name' }, +{ opcmethod => 'brin', opcname => 'int8_minmax_ops', + opcfamily => 'brin/integer_minmax_ops', opcintype => 'int8', + opckeytype => 'int8' }, +{ opcmethod => 'brin', opcname => 'int2_minmax_ops', + opcfamily => 'brin/integer_minmax_ops', opcintype => 'int2', + opckeytype => 'int2' }, +{ opcmethod => 'brin', opcname => 'int4_minmax_ops', + opcfamily => 'brin/integer_minmax_ops', opcintype => 'int4', + opckeytype => 'int4' }, +{ opcmethod => 'brin', opcname => 'text_minmax_ops', + opcfamily => 'brin/text_minmax_ops', opcintype => 'text', + opckeytype => 'text' }, +{ opcmethod => 'brin', opcname => 'oid_minmax_ops', + opcfamily => 'brin/oid_minmax_ops', opcintype => 'oid', opckeytype => 'oid' }, +{ opcmethod => 'brin', opcname => 'tid_minmax_ops', + opcfamily => 'brin/tid_minmax_ops', opcintype => 'tid', opckeytype => 'tid' }, +{ opcmethod => 'brin', opcname => 'float4_minmax_ops', + opcfamily => 'brin/float_minmax_ops', opcintype => 'float4', + opckeytype => 'float4' }, +{ opcmethod => 'brin', opcname => 'float8_minmax_ops', + opcfamily => 'brin/float_minmax_ops', opcintype => 'float8', + opckeytype => 'float8' }, +{ opcmethod => 'brin', opcname => 'macaddr_minmax_ops', + opcfamily => 'brin/macaddr_minmax_ops', opcintype => 'macaddr', + opckeytype => 'macaddr' }, +{ opcmethod => 'brin', opcname => 'macaddr8_minmax_ops', + opcfamily => 'brin/macaddr8_minmax_ops', opcintype => 'macaddr8', + opckeytype => 'macaddr8' }, +{ opcmethod => 'brin', opcname => 'inet_minmax_ops', + opcfamily => 'brin/network_minmax_ops', opcintype => 'inet', + opcdefault => 'f', opckeytype => 'inet' }, +{ opcmethod => 'brin', opcname => 'inet_inclusion_ops', + opcfamily => 'brin/network_inclusion_ops', opcintype => 'inet', + opckeytype => 'inet' }, +{ opcmethod => 'brin', opcname => 'bpchar_minmax_ops', + opcfamily => 'brin/bpchar_minmax_ops', opcintype => 'bpchar', + opckeytype => 'bpchar' }, +{ opcmethod => 'brin', opcname => 'time_minmax_ops', + opcfamily => 'brin/time_minmax_ops', opcintype => 'time', + opckeytype => 'time' }, +{ opcmethod => 'brin', opcname => 'date_minmax_ops', + opcfamily => 'brin/datetime_minmax_ops', opcintype => 'date', + opckeytype => 'date' }, +{ opcmethod => 'brin', opcname => 'timestamp_minmax_ops', + opcfamily => 'brin/datetime_minmax_ops', opcintype => 'timestamp', + opckeytype => 'timestamp' }, +{ opcmethod => 'brin', opcname => 'timestamptz_minmax_ops', + opcfamily => 'brin/datetime_minmax_ops', opcintype => 'timestamptz', + opckeytype => 'timestamptz' }, +{ opcmethod => 'brin', opcname => 'interval_minmax_ops', + opcfamily => 'brin/interval_minmax_ops', opcintype => 'interval', + opckeytype => 'interval' }, +{ opcmethod => 'brin', opcname => 'timetz_minmax_ops', + opcfamily => 'brin/timetz_minmax_ops', opcintype => 'timetz', + opckeytype => 'timetz' }, +{ opcmethod => 'brin', opcname => 'bit_minmax_ops', + opcfamily => 'brin/bit_minmax_ops', opcintype => 'bit', opckeytype => 'bit' }, +{ opcmethod => 'brin', opcname => 'varbit_minmax_ops', + opcfamily => 'brin/varbit_minmax_ops', opcintype => 'varbit', + opckeytype => 'varbit' }, +{ opcmethod => 'brin', opcname => 'numeric_minmax_ops', + opcfamily => 'brin/numeric_minmax_ops', opcintype => 'numeric', + opckeytype => 'numeric' }, + +# no brin opclass for record, anyarray + +{ opcmethod => 'brin', opcname => 'uuid_minmax_ops', + opcfamily => 'brin/uuid_minmax_ops', opcintype => 'uuid', + opckeytype => 'uuid' }, +{ opcmethod => 'brin', opcname => 'range_inclusion_ops', + opcfamily => 'brin/range_inclusion_ops', opcintype => 'anyrange', + opckeytype => 'anyrange' }, +{ opcmethod => 'brin', opcname => 'pg_lsn_minmax_ops', + opcfamily => 'brin/pg_lsn_minmax_ops', opcintype => 'pg_lsn', + opckeytype => 'pg_lsn' }, + +# no brin opclass for enum, tsvector, tsquery, jsonb + +{ opcmethod => 'brin', opcname => 'box_inclusion_ops', + opcfamily => 'brin/box_inclusion_ops', opcintype => 'box', + opckeytype => 'box' }, + +# no brin opclass for the geometric types except box + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_opclass.h b/contrib/libs/postgresql/src/include/catalog/pg_opclass.h new file mode 100644 index 0000000000..963ab3eae8 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_opclass.h @@ -0,0 +1,85 @@ +/*------------------------------------------------------------------------- + * + * pg_opclass.h + * definition of the "operator class" system catalog (pg_opclass) + * + * The primary key for this table is <opcmethod, opcname, opcnamespace> --- + * that is, there is a row for each valid combination of opclass name and + * index access method type. This row specifies the expected input data type + * for the opclass (the type of the heap column, or the expression output type + * in the case of an index expression). Note that types binary-coercible to + * the specified type will be accepted too. + * + * For a given <opcmethod, opcintype> pair, there can be at most one row that + * has opcdefault = true; this row is the default opclass for such data in + * such an index. (This is not currently enforced by an index, because we + * don't support partial indexes on system catalogs.) + * + * Normally opckeytype = InvalidOid (zero), indicating that the data stored + * in the index is the same as the data in the indexed column. If opckeytype + * is nonzero then it indicates that a conversion step is needed to produce + * the stored index data, which will be of type opckeytype (which might be + * the same or different from the input datatype). Performing such a + * conversion is the responsibility of the index access method --- not all + * AMs support this. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_opclass.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_OPCLASS_H +#define PG_OPCLASS_H + +#include "catalog/genbki.h" +#include "catalog/pg_opclass_d.h" + +/* ---------------- + * pg_opclass definition. cpp turns this into + * typedef struct FormData_pg_opclass + * ---------------- + */ +CATALOG(pg_opclass,2616,OperatorClassRelationId) +{ + Oid oid; /* oid */ + + /* index access method opclass is for */ + Oid opcmethod BKI_LOOKUP(pg_am); + + /* name of this opclass */ + NameData opcname; + + /* namespace of this opclass */ + Oid opcnamespace BKI_DEFAULT(PGNSP); + + /* opclass owner */ + Oid opcowner BKI_DEFAULT(PGUID); + + /* containing operator family */ + Oid opcfamily BKI_LOOKUP(pg_opfamily); + + /* type of data indexed by opclass */ + Oid opcintype BKI_LOOKUP(pg_type); + + /* T if opclass is default for opcintype */ + bool opcdefault BKI_DEFAULT(t); + + /* type of data in index, or InvalidOid */ + Oid opckeytype BKI_DEFAULT(0) BKI_LOOKUP(pg_type); +} FormData_pg_opclass; + +/* ---------------- + * Form_pg_opclass corresponds to a pointer to a tuple with + * the format of pg_opclass relation. + * ---------------- + */ +typedef FormData_pg_opclass *Form_pg_opclass; + +#endif /* PG_OPCLASS_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_opclass_d.h b/contrib/libs/postgresql/src/include/catalog/pg_opclass_d.h new file mode 100644 index 0000000000..113547a25a --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_opclass_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_opclass_d.h" /* inclink generated by yamaker */ diff --git a/ydb/library/yql/parser/pg_catalog/pg_operator.dat b/contrib/libs/postgresql/src/include/catalog/pg_operator.dat index 3b3eb955d4..3b3eb955d4 100644 --- a/ydb/library/yql/parser/pg_catalog/pg_operator.dat +++ b/contrib/libs/postgresql/src/include/catalog/pg_operator.dat diff --git a/contrib/libs/postgresql/src/include/catalog/pg_operator.h b/contrib/libs/postgresql/src/include/catalog/pg_operator.h new file mode 100644 index 0000000000..5aaa02e8a9 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_operator.h @@ -0,0 +1,104 @@ +/*------------------------------------------------------------------------- + * + * pg_operator.h + * definition of the "operator" system catalog (pg_operator) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_operator.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_OPERATOR_H +#define PG_OPERATOR_H + +#include "catalog/genbki.h" +#include "catalog/objectaddress.h" +#include "catalog/pg_operator_d.h" +#include "nodes/pg_list.h" + +/* ---------------- + * pg_operator definition. cpp turns this into + * typedef struct FormData_pg_operator + * ---------------- + */ +CATALOG(pg_operator,2617,OperatorRelationId) +{ + Oid oid; /* oid */ + + /* name of operator */ + NameData oprname; + + /* OID of namespace containing this oper */ + Oid oprnamespace BKI_DEFAULT(PGNSP); + + /* operator owner */ + Oid oprowner BKI_DEFAULT(PGUID); + + /* 'l', 'r', or 'b' */ + char oprkind BKI_DEFAULT(b); + + /* can be used in merge join? */ + bool oprcanmerge BKI_DEFAULT(f); + + /* can be used in hash join? */ + bool oprcanhash BKI_DEFAULT(f); + + /* left arg type, or 0 if 'l' oprkind */ + Oid oprleft BKI_LOOKUP(pg_type); + + /* right arg type, or 0 if 'r' oprkind */ + Oid oprright BKI_LOOKUP(pg_type); + + /* result datatype */ + Oid oprresult BKI_LOOKUP(pg_type); + + /* OID of commutator oper, or 0 if none */ + Oid oprcom BKI_DEFAULT(0) BKI_LOOKUP(pg_operator); + + /* OID of negator oper, or 0 if none */ + Oid oprnegate BKI_DEFAULT(0) BKI_LOOKUP(pg_operator); + + /* OID of underlying function */ + regproc oprcode BKI_LOOKUP(pg_proc); + + /* OID of restriction estimator, or 0 */ + regproc oprrest BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); + + /* OID of join estimator, or 0 */ + regproc oprjoin BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); +} FormData_pg_operator; + +/* ---------------- + * Form_pg_operator corresponds to a pointer to a tuple with + * the format of pg_operator relation. + * ---------------- + */ +typedef FormData_pg_operator *Form_pg_operator; + + +extern ObjectAddress OperatorCreate(const char *operatorName, + Oid operatorNamespace, + Oid leftTypeId, + Oid rightTypeId, + Oid procedureId, + List *commutatorName, + List *negatorName, + Oid restrictionId, + Oid joinId, + bool canMerge, + bool canHash); + +extern ObjectAddress makeOperatorDependencies(HeapTuple tuple, + bool makeExtensionDep, + bool isUpdate); + +extern void OperatorUpd(Oid baseId, Oid commId, Oid negId, bool isDelete); + +#endif /* PG_OPERATOR_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_operator_d.h b/contrib/libs/postgresql/src/include/catalog/pg_operator_d.h new file mode 100644 index 0000000000..a06e90b848 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_operator_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_operator_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_opfamily.dat b/contrib/libs/postgresql/src/include/catalog/pg_opfamily.dat new file mode 100644 index 0000000000..cf0fb325b3 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_opfamily.dat @@ -0,0 +1,234 @@ +#---------------------------------------------------------------------- +# +# pg_opfamily.dat +# Initial contents of the pg_opfamily system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_opfamily.dat +# +#---------------------------------------------------------------------- + +[ + +{ oid => '397', + opfmethod => 'btree', opfname => 'array_ops' }, +{ oid => '627', + opfmethod => 'hash', opfname => 'array_ops' }, +{ oid => '423', + opfmethod => 'btree', opfname => 'bit_ops' }, +{ oid => '424', oid_symbol => 'BOOL_BTREE_FAM_OID', + opfmethod => 'btree', opfname => 'bool_ops' }, +{ oid => '426', oid_symbol => 'BPCHAR_BTREE_FAM_OID', + opfmethod => 'btree', opfname => 'bpchar_ops' }, +{ oid => '427', + opfmethod => 'hash', opfname => 'bpchar_ops' }, +{ oid => '428', oid_symbol => 'BYTEA_BTREE_FAM_OID', + opfmethod => 'btree', opfname => 'bytea_ops' }, +{ oid => '429', + opfmethod => 'btree', opfname => 'char_ops' }, +{ oid => '431', + opfmethod => 'hash', opfname => 'char_ops' }, +{ oid => '434', + opfmethod => 'btree', opfname => 'datetime_ops' }, +{ oid => '435', + opfmethod => 'hash', opfname => 'date_ops' }, +{ oid => '1970', + opfmethod => 'btree', opfname => 'float_ops' }, +{ oid => '1971', + opfmethod => 'hash', opfname => 'float_ops' }, +{ oid => '1974', oid_symbol => 'NETWORK_BTREE_FAM_OID', + opfmethod => 'btree', opfname => 'network_ops' }, +{ oid => '1975', + opfmethod => 'hash', opfname => 'network_ops' }, +{ oid => '3550', + opfmethod => 'gist', opfname => 'network_ops' }, +{ oid => '3794', + opfmethod => 'spgist', opfname => 'network_ops' }, +{ oid => '1976', oid_symbol => 'INTEGER_BTREE_FAM_OID', + opfmethod => 'btree', opfname => 'integer_ops' }, +{ oid => '1977', + opfmethod => 'hash', opfname => 'integer_ops' }, +{ oid => '1982', + opfmethod => 'btree', opfname => 'interval_ops' }, +{ oid => '1983', + opfmethod => 'hash', opfname => 'interval_ops' }, +{ oid => '1984', + opfmethod => 'btree', opfname => 'macaddr_ops' }, +{ oid => '1985', + opfmethod => 'hash', opfname => 'macaddr_ops' }, +{ oid => '3371', + opfmethod => 'btree', opfname => 'macaddr8_ops' }, +{ oid => '3372', + opfmethod => 'hash', opfname => 'macaddr8_ops' }, +{ oid => '1988', + opfmethod => 'btree', opfname => 'numeric_ops' }, +{ oid => '1998', + opfmethod => 'hash', opfname => 'numeric_ops' }, +{ oid => '1989', oid_symbol => 'OID_BTREE_FAM_OID', + opfmethod => 'btree', opfname => 'oid_ops' }, +{ oid => '1990', + opfmethod => 'hash', opfname => 'oid_ops' }, +{ oid => '1991', + opfmethod => 'btree', opfname => 'oidvector_ops' }, +{ oid => '1992', + opfmethod => 'hash', opfname => 'oidvector_ops' }, +{ oid => '2994', + opfmethod => 'btree', opfname => 'record_ops' }, +{ oid => '3194', + opfmethod => 'btree', opfname => 'record_image_ops' }, +{ oid => '1994', oid_symbol => 'TEXT_BTREE_FAM_OID', + opfmethod => 'btree', opfname => 'text_ops' }, +{ oid => '1995', + opfmethod => 'hash', opfname => 'text_ops' }, +{ oid => '1996', + opfmethod => 'btree', opfname => 'time_ops' }, +{ oid => '1997', + opfmethod => 'hash', opfname => 'time_ops' }, +{ oid => '1999', + opfmethod => 'hash', opfname => 'timestamptz_ops' }, +{ oid => '2000', + opfmethod => 'btree', opfname => 'timetz_ops' }, +{ oid => '2001', + opfmethod => 'hash', opfname => 'timetz_ops' }, +{ oid => '2002', + opfmethod => 'btree', opfname => 'varbit_ops' }, +{ oid => '2040', + opfmethod => 'hash', opfname => 'timestamp_ops' }, +{ oid => '2095', oid_symbol => 'TEXT_PATTERN_BTREE_FAM_OID', + opfmethod => 'btree', opfname => 'text_pattern_ops' }, +{ oid => '2097', oid_symbol => 'BPCHAR_PATTERN_BTREE_FAM_OID', + opfmethod => 'btree', opfname => 'bpchar_pattern_ops' }, +{ oid => '2099', + opfmethod => 'btree', opfname => 'money_ops' }, +{ oid => '2222', oid_symbol => 'BOOL_HASH_FAM_OID', + opfmethod => 'hash', opfname => 'bool_ops' }, +{ oid => '2223', + opfmethod => 'hash', opfname => 'bytea_ops' }, +{ oid => '2789', + opfmethod => 'btree', opfname => 'tid_ops' }, +{ oid => '2225', + opfmethod => 'hash', opfname => 'xid_ops' }, +{ oid => '5032', + opfmethod => 'hash', opfname => 'xid8_ops' }, +{ oid => '5067', + opfmethod => 'btree', opfname => 'xid8_ops' }, +{ oid => '2226', + opfmethod => 'hash', opfname => 'cid_ops' }, +{ oid => '2227', + opfmethod => 'hash', opfname => 'tid_ops' }, +{ oid => '2229', + opfmethod => 'hash', opfname => 'text_pattern_ops' }, +{ oid => '2231', + opfmethod => 'hash', opfname => 'bpchar_pattern_ops' }, +{ oid => '2235', + opfmethod => 'hash', opfname => 'aclitem_ops' }, +{ oid => '2593', + opfmethod => 'gist', opfname => 'box_ops' }, +{ oid => '2594', + opfmethod => 'gist', opfname => 'poly_ops' }, +{ oid => '2595', + opfmethod => 'gist', opfname => 'circle_ops' }, +{ oid => '1029', + opfmethod => 'gist', opfname => 'point_ops' }, +{ oid => '2745', + opfmethod => 'gin', opfname => 'array_ops' }, +{ oid => '2968', + opfmethod => 'btree', opfname => 'uuid_ops' }, +{ oid => '2969', + opfmethod => 'hash', opfname => 'uuid_ops' }, +{ oid => '3253', + opfmethod => 'btree', opfname => 'pg_lsn_ops' }, +{ oid => '3254', + opfmethod => 'hash', opfname => 'pg_lsn_ops' }, +{ oid => '3522', + opfmethod => 'btree', opfname => 'enum_ops' }, +{ oid => '3523', + opfmethod => 'hash', opfname => 'enum_ops' }, +{ oid => '3626', + opfmethod => 'btree', opfname => 'tsvector_ops' }, +{ oid => '3655', + opfmethod => 'gist', opfname => 'tsvector_ops' }, +{ oid => '3659', + opfmethod => 'gin', opfname => 'tsvector_ops' }, +{ oid => '3683', + opfmethod => 'btree', opfname => 'tsquery_ops' }, +{ oid => '3702', + opfmethod => 'gist', opfname => 'tsquery_ops' }, +{ oid => '3901', + opfmethod => 'btree', opfname => 'range_ops' }, +{ oid => '3903', + opfmethod => 'hash', opfname => 'range_ops' }, +{ oid => '3919', + opfmethod => 'gist', opfname => 'range_ops' }, +{ oid => '3474', + opfmethod => 'spgist', opfname => 'range_ops' }, +{ oid => '4015', + opfmethod => 'spgist', opfname => 'quad_point_ops' }, +{ oid => '4016', + opfmethod => 'spgist', opfname => 'kd_point_ops' }, +{ oid => '4017', oid_symbol => 'TEXT_SPGIST_FAM_OID', + opfmethod => 'spgist', opfname => 'text_ops' }, +{ oid => '4033', + opfmethod => 'btree', opfname => 'jsonb_ops' }, +{ oid => '4034', + opfmethod => 'hash', opfname => 'jsonb_ops' }, +{ oid => '4036', + opfmethod => 'gin', opfname => 'jsonb_ops' }, +{ oid => '4037', + opfmethod => 'gin', opfname => 'jsonb_path_ops' }, +{ oid => '4054', + opfmethod => 'brin', opfname => 'integer_minmax_ops' }, +{ oid => '4055', + opfmethod => 'brin', opfname => 'numeric_minmax_ops' }, +{ oid => '4056', + opfmethod => 'brin', opfname => 'text_minmax_ops' }, +{ oid => '4058', + opfmethod => 'brin', opfname => 'timetz_minmax_ops' }, +{ oid => '4059', + opfmethod => 'brin', opfname => 'datetime_minmax_ops' }, +{ oid => '4062', + opfmethod => 'brin', opfname => 'char_minmax_ops' }, +{ oid => '4064', + opfmethod => 'brin', opfname => 'bytea_minmax_ops' }, +{ oid => '4065', + opfmethod => 'brin', opfname => 'name_minmax_ops' }, +{ oid => '4068', + opfmethod => 'brin', opfname => 'oid_minmax_ops' }, +{ oid => '4069', + opfmethod => 'brin', opfname => 'tid_minmax_ops' }, +{ oid => '4070', + opfmethod => 'brin', opfname => 'float_minmax_ops' }, +{ oid => '4074', + opfmethod => 'brin', opfname => 'macaddr_minmax_ops' }, +{ oid => '4109', + opfmethod => 'brin', opfname => 'macaddr8_minmax_ops' }, +{ oid => '4075', + opfmethod => 'brin', opfname => 'network_minmax_ops' }, +{ oid => '4102', + opfmethod => 'brin', opfname => 'network_inclusion_ops' }, +{ oid => '4076', + opfmethod => 'brin', opfname => 'bpchar_minmax_ops' }, +{ oid => '4077', + opfmethod => 'brin', opfname => 'time_minmax_ops' }, +{ oid => '4078', + opfmethod => 'brin', opfname => 'interval_minmax_ops' }, +{ oid => '4079', + opfmethod => 'brin', opfname => 'bit_minmax_ops' }, +{ oid => '4080', + opfmethod => 'brin', opfname => 'varbit_minmax_ops' }, +{ oid => '4081', + opfmethod => 'brin', opfname => 'uuid_minmax_ops' }, +{ oid => '4103', + opfmethod => 'brin', opfname => 'range_inclusion_ops' }, +{ oid => '4082', + opfmethod => 'brin', opfname => 'pg_lsn_minmax_ops' }, +{ oid => '4104', + opfmethod => 'brin', opfname => 'box_inclusion_ops' }, +{ oid => '5000', + opfmethod => 'spgist', opfname => 'box_ops' }, +{ oid => '5008', + opfmethod => 'spgist', opfname => 'poly_ops' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_opfamily.h b/contrib/libs/postgresql/src/include/catalog/pg_opfamily.h new file mode 100644 index 0000000000..503f0d2fd3 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_opfamily.h @@ -0,0 +1,60 @@ +/*------------------------------------------------------------------------- + * + * pg_opfamily.h + * definition of the "operator family" system catalog (pg_opfamily) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_opfamily.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_OPFAMILY_H +#define PG_OPFAMILY_H + +#include "catalog/genbki.h" +#include "catalog/pg_opfamily_d.h" + +/* ---------------- + * pg_opfamily definition. cpp turns this into + * typedef struct FormData_pg_opfamily + * ---------------- + */ +CATALOG(pg_opfamily,2753,OperatorFamilyRelationId) +{ + Oid oid; /* oid */ + + /* index access method opfamily is for */ + Oid opfmethod BKI_LOOKUP(pg_am); + + /* name of this opfamily */ + NameData opfname; + + /* namespace of this opfamily */ + Oid opfnamespace BKI_DEFAULT(PGNSP); + + /* opfamily owner */ + Oid opfowner BKI_DEFAULT(PGUID); +} FormData_pg_opfamily; + +/* ---------------- + * Form_pg_opfamily corresponds to a pointer to a tuple with + * the format of pg_opfamily relation. + * ---------------- + */ +typedef FormData_pg_opfamily *Form_pg_opfamily; + +#ifdef EXPOSE_TO_CLIENT_CODE + +#define IsBooleanOpfamily(opfamily) \ + ((opfamily) == BOOL_BTREE_FAM_OID || (opfamily) == BOOL_HASH_FAM_OID) + +#endif /* EXPOSE_TO_CLIENT_CODE */ + +#endif /* PG_OPFAMILY_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_opfamily_d.h b/contrib/libs/postgresql/src/include/catalog/pg_opfamily_d.h new file mode 100644 index 0000000000..5b36e673e8 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_opfamily_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_opfamily_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_partitioned_table.h b/contrib/libs/postgresql/src/include/catalog/pg_partitioned_table.h new file mode 100644 index 0000000000..a73cd0d3a4 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_partitioned_table.h @@ -0,0 +1,63 @@ +/*------------------------------------------------------------------------- + * + * pg_partitioned_table.h + * definition of the "partitioned table" system catalog + * (pg_partitioned_table) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_partitioned_table.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_PARTITIONED_TABLE_H +#define PG_PARTITIONED_TABLE_H + +#include "catalog/genbki.h" +#include "catalog/pg_partitioned_table_d.h" + +/* ---------------- + * pg_partitioned_table definition. cpp turns this into + * typedef struct FormData_pg_partitioned_table + * ---------------- + */ +CATALOG(pg_partitioned_table,3350,PartitionedRelationId) +{ + Oid partrelid; /* partitioned table oid */ + char partstrat; /* partitioning strategy */ + int16 partnatts; /* number of partition key columns */ + Oid partdefid; /* default partition oid; InvalidOid if there + * isn't one */ + + /* + * variable-length fields start here, but we allow direct access to + * partattrs via the C struct. That's because the first variable-length + * field of a heap tuple can be reliably accessed using its C struct + * offset, as previous fields are all non-nullable fixed-length fields. + */ + int2vector partattrs; /* each member of the array is the attribute + * number of a partition key column, or 0 if + * the column is actually an expression */ + +#ifdef CATALOG_VARLEN + oidvector partclass; /* operator class to compare keys */ + oidvector partcollation; /* user-specified collation for keys */ + pg_node_tree partexprs; /* list of expressions in the partition key; + * one item for each zero entry in partattrs[] */ +#endif +} FormData_pg_partitioned_table; + +/* ---------------- + * Form_pg_partitioned_table corresponds to a pointer to a tuple with + * the format of pg_partitioned_table relation. + * ---------------- + */ +typedef FormData_pg_partitioned_table *Form_pg_partitioned_table; + +#endif /* PG_PARTITIONED_TABLE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_partitioned_table_d.h b/contrib/libs/postgresql/src/include/catalog/pg_partitioned_table_d.h new file mode 100644 index 0000000000..41b48e7dfc --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_partitioned_table_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_partitioned_table_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_policy.h b/contrib/libs/postgresql/src/include/catalog/pg_policy.h new file mode 100644 index 0000000000..97954cdc8a --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_policy.h @@ -0,0 +1,52 @@ +/*------------------------------------------------------------------------- + * + * pg_policy.h + * definition of the "policy" system catalog (pg_policy) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_policy.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_POLICY_H +#define PG_POLICY_H + +#include "catalog/genbki.h" +#include "catalog/pg_policy_d.h" + +/* ---------------- + * pg_policy definition. cpp turns this into + * typedef struct FormData_pg_policy + * ---------------- + */ +CATALOG(pg_policy,3256,PolicyRelationId) +{ + Oid oid; /* oid */ + NameData polname; /* Policy name. */ + Oid polrelid; /* Oid of the relation with policy. */ + char polcmd; /* One of ACL_*_CHR, or '*' for all */ + bool polpermissive; /* restrictive or permissive policy */ + +#ifdef CATALOG_VARLEN + Oid polroles[1] BKI_FORCE_NOT_NULL; /* Roles associated with + * policy */ + pg_node_tree polqual; /* Policy quals. */ + pg_node_tree polwithcheck; /* WITH CHECK quals. */ +#endif +} FormData_pg_policy; + +/* ---------------- + * Form_pg_policy corresponds to a pointer to a row with + * the format of pg_policy relation. + * ---------------- + */ +typedef FormData_pg_policy *Form_pg_policy; + +#endif /* PG_POLICY_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_policy_d.h b/contrib/libs/postgresql/src/include/catalog/pg_policy_d.h new file mode 100644 index 0000000000..ea2594c794 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_policy_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_policy_d.h" /* inclink generated by yamaker */ diff --git a/ydb/library/yql/parser/pg_catalog/pg_proc.dat b/contrib/libs/postgresql/src/include/catalog/pg_proc.dat index c2287273a9..c2287273a9 100644 --- a/ydb/library/yql/parser/pg_catalog/pg_proc.dat +++ b/contrib/libs/postgresql/src/include/catalog/pg_proc.dat diff --git a/contrib/libs/postgresql/src/include/catalog/pg_proc.h b/contrib/libs/postgresql/src/include/catalog/pg_proc.h new file mode 100644 index 0000000000..ee3959da09 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_proc.h @@ -0,0 +1,211 @@ +/*------------------------------------------------------------------------- + * + * pg_proc.h + * definition of the "procedure" system catalog (pg_proc) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_proc.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_PROC_H +#define PG_PROC_H + +#include "catalog/genbki.h" +#include "catalog/objectaddress.h" +#include "catalog/pg_proc_d.h" +#include "nodes/pg_list.h" + +/* ---------------- + * pg_proc definition. cpp turns this into + * typedef struct FormData_pg_proc + * ---------------- + */ +CATALOG(pg_proc,1255,ProcedureRelationId) BKI_BOOTSTRAP BKI_ROWTYPE_OID(81,ProcedureRelation_Rowtype_Id) BKI_SCHEMA_MACRO +{ + Oid oid; /* oid */ + + /* procedure name */ + NameData proname; + + /* OID of namespace containing this proc */ + Oid pronamespace BKI_DEFAULT(PGNSP); + + /* procedure owner */ + Oid proowner BKI_DEFAULT(PGUID); + + /* OID of pg_language entry */ + Oid prolang BKI_DEFAULT(internal) BKI_LOOKUP(pg_language); + + /* estimated execution cost */ + float4 procost BKI_DEFAULT(1); + + /* estimated # of rows out (if proretset) */ + float4 prorows BKI_DEFAULT(0); + + /* element type of variadic array, or 0 */ + Oid provariadic BKI_DEFAULT(0) BKI_LOOKUP(pg_type); + + /* planner support function for this function, or 0 if none */ + regproc prosupport BKI_DEFAULT(0) BKI_LOOKUP(pg_proc); + + /* see PROKIND_ categories below */ + char prokind BKI_DEFAULT(f); + + /* security definer */ + bool prosecdef BKI_DEFAULT(f); + + /* is it a leak-proof function? */ + bool proleakproof BKI_DEFAULT(f); + + /* strict with respect to NULLs? */ + bool proisstrict BKI_DEFAULT(t); + + /* returns a set? */ + bool proretset BKI_DEFAULT(f); + + /* see PROVOLATILE_ categories below */ + char provolatile BKI_DEFAULT(i); + + /* see PROPARALLEL_ categories below */ + char proparallel BKI_DEFAULT(s); + + /* number of arguments */ + /* Note: need not be given in pg_proc.dat; genbki.pl will compute it */ + int16 pronargs; + + /* number of arguments with defaults */ + int16 pronargdefaults BKI_DEFAULT(0); + + /* OID of result type */ + Oid prorettype BKI_LOOKUP(pg_type); + + /* + * variable-length fields start here, but we allow direct access to + * proargtypes + */ + + /* parameter types (excludes OUT params) */ + oidvector proargtypes BKI_LOOKUP(pg_type); + +#ifdef CATALOG_VARLEN + + /* all param types (NULL if IN only) */ + Oid proallargtypes[1] BKI_DEFAULT(_null_) BKI_LOOKUP(pg_type); + + /* parameter modes (NULL if IN only) */ + char proargmodes[1] BKI_DEFAULT(_null_); + + /* parameter names (NULL if no names) */ + text proargnames[1] BKI_DEFAULT(_null_); + + /* list of expression trees for argument defaults (NULL if none) */ + pg_node_tree proargdefaults BKI_DEFAULT(_null_); + + /* types for which to apply transforms */ + Oid protrftypes[1] BKI_DEFAULT(_null_); + + /* procedure source text */ + text prosrc BKI_FORCE_NOT_NULL; + + /* secondary procedure info (can be NULL) */ + text probin BKI_DEFAULT(_null_); + + /* procedure-local GUC settings */ + text proconfig[1] BKI_DEFAULT(_null_); + + /* access permissions */ + aclitem proacl[1] BKI_DEFAULT(_null_); +#endif +} FormData_pg_proc; + +/* ---------------- + * Form_pg_proc corresponds to a pointer to a tuple with + * the format of pg_proc relation. + * ---------------- + */ +typedef FormData_pg_proc *Form_pg_proc; + +#ifdef EXPOSE_TO_CLIENT_CODE + +/* + * Symbolic values for prokind column + */ +#define PROKIND_FUNCTION 'f' +#define PROKIND_AGGREGATE 'a' +#define PROKIND_WINDOW 'w' +#define PROKIND_PROCEDURE 'p' + +/* + * Symbolic values for provolatile column: these indicate whether the result + * of a function is dependent *only* on the values of its explicit arguments, + * or can change due to outside factors (such as parameter variables or + * table contents). NOTE: functions having side-effects, such as setval(), + * must be labeled volatile to ensure they will not get optimized away, + * even if the actual return value is not changeable. + */ +#define PROVOLATILE_IMMUTABLE 'i' /* never changes for given input */ +#define PROVOLATILE_STABLE 's' /* does not change within a scan */ +#define PROVOLATILE_VOLATILE 'v' /* can change even within a scan */ + +/* + * Symbolic values for proparallel column: these indicate whether a function + * can be safely be run in a parallel backend, during parallelism but + * necessarily in the master, or only in non-parallel mode. + */ +#define PROPARALLEL_SAFE 's' /* can run in worker or master */ +#define PROPARALLEL_RESTRICTED 'r' /* can run in parallel master only */ +#define PROPARALLEL_UNSAFE 'u' /* banned while in parallel mode */ + +/* + * Symbolic values for proargmodes column. Note that these must agree with + * the FunctionParameterMode enum in parsenodes.h; we declare them here to + * be accessible from either header. + */ +#define PROARGMODE_IN 'i' +#define PROARGMODE_OUT 'o' +#define PROARGMODE_INOUT 'b' +#define PROARGMODE_VARIADIC 'v' +#define PROARGMODE_TABLE 't' + +#endif /* EXPOSE_TO_CLIENT_CODE */ + + +extern ObjectAddress ProcedureCreate(const char *procedureName, + Oid procNamespace, + bool replace, + bool returnsSet, + Oid returnType, + Oid proowner, + Oid languageObjectId, + Oid languageValidator, + const char *prosrc, + const char *probin, + char prokind, + bool security_definer, + bool isLeakProof, + bool isStrict, + char volatility, + char parallel, + oidvector *parameterTypes, + Datum allParameterTypes, + Datum parameterModes, + Datum parameterNames, + List *parameterDefaults, + Datum trftypes, + Datum proconfig, + Oid prosupport, + float4 procost, + float4 prorows); + +extern bool function_parse_error_transpose(const char *prosrc); + +extern List *oid_array_to_list(Datum datum); + +#endif /* PG_PROC_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_proc_d.h b/contrib/libs/postgresql/src/include/catalog/pg_proc_d.h new file mode 100644 index 0000000000..bf5d3d97ee --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_proc_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_proc_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_publication.h b/contrib/libs/postgresql/src/include/catalog/pg_publication.h new file mode 100644 index 0000000000..c876085a49 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_publication.h @@ -0,0 +1,118 @@ +/*------------------------------------------------------------------------- + * + * pg_publication.h + * definition of the "publication" system catalog (pg_publication) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_publication.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_PUBLICATION_H +#define PG_PUBLICATION_H + +#include "catalog/genbki.h" +#include "catalog/objectaddress.h" +#include "catalog/pg_publication_d.h" + +/* ---------------- + * pg_publication definition. cpp turns this into + * typedef struct FormData_pg_publication + * ---------------- + */ +CATALOG(pg_publication,6104,PublicationRelationId) +{ + Oid oid; /* oid */ + + NameData pubname; /* name of the publication */ + + Oid pubowner; /* publication owner */ + + /* + * indicates that this is special publication which should encompass all + * tables in the database (except for the unlogged and temp ones) + */ + bool puballtables; + + /* true if inserts are published */ + bool pubinsert; + + /* true if updates are published */ + bool pubupdate; + + /* true if deletes are published */ + bool pubdelete; + + /* true if truncates are published */ + bool pubtruncate; + + /* true if partition changes are published using root schema */ + bool pubviaroot; +} FormData_pg_publication; + +/* ---------------- + * Form_pg_publication corresponds to a pointer to a tuple with + * the format of pg_publication relation. + * ---------------- + */ +typedef FormData_pg_publication *Form_pg_publication; + +typedef struct PublicationActions +{ + bool pubinsert; + bool pubupdate; + bool pubdelete; + bool pubtruncate; +} PublicationActions; + +typedef struct Publication +{ + Oid oid; + char *name; + bool alltables; + bool pubviaroot; + PublicationActions pubactions; +} Publication; + +extern Publication *GetPublication(Oid pubid); +extern Publication *GetPublicationByName(const char *pubname, bool missing_ok); +extern List *GetRelationPublications(Oid relid); + +/*--------- + * Expected values for pub_partopt parameter of GetRelationPublications(), + * which allows callers to specify which partitions of partitioned tables + * mentioned in the publication they expect to see. + * + * ROOT: only the table explicitly mentioned in the publication + * LEAF: only leaf partitions in given tree + * ALL: all partitions in given tree + */ +typedef enum PublicationPartOpt +{ + PUBLICATION_PART_ROOT, + PUBLICATION_PART_LEAF, + PUBLICATION_PART_ALL, +} PublicationPartOpt; + +extern List *GetPublicationRelations(Oid pubid, PublicationPartOpt pub_partopt); +extern List *GetAllTablesPublications(void); +extern List *GetAllTablesPublicationRelations(bool pubviaroot); + +extern bool is_publishable_relation(Relation rel); +extern ObjectAddress publication_add_relation(Oid pubid, Relation targetrel, + bool if_not_exists); +extern List *GetPubPartitionOptionRelations(List *result, + PublicationPartOpt pub_partopt, + Oid relid); + +extern Oid get_publication_oid(const char *pubname, bool missing_ok); +extern char *get_publication_name(Oid pubid, bool missing_ok); + + +#endif /* PG_PUBLICATION_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_publication_d.h b/contrib/libs/postgresql/src/include/catalog/pg_publication_d.h new file mode 100644 index 0000000000..f78caa1ac2 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_publication_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_publication_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_publication_rel.h b/contrib/libs/postgresql/src/include/catalog/pg_publication_rel.h new file mode 100644 index 0000000000..8ab226e4c0 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_publication_rel.h @@ -0,0 +1,43 @@ +/*------------------------------------------------------------------------- + * + * pg_publication_rel.h + * definition of the system catalog for mappings between relations and + * publications (pg_publication_rel) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_publication_rel.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_PUBLICATION_REL_H +#define PG_PUBLICATION_REL_H + +#include "catalog/genbki.h" +#include "catalog/pg_publication_rel_d.h" + +/* ---------------- + * pg_publication_rel definition. cpp turns this into + * typedef struct FormData_pg_publication_rel + * ---------------- + */ +CATALOG(pg_publication_rel,6106,PublicationRelRelationId) +{ + Oid oid; /* oid */ + Oid prpubid; /* Oid of the publication */ + Oid prrelid; /* Oid of the relation */ +} FormData_pg_publication_rel; + +/* ---------------- + * Form_pg_publication_rel corresponds to a pointer to a tuple with + * the format of pg_publication_rel relation. + * ---------------- + */ +typedef FormData_pg_publication_rel *Form_pg_publication_rel; + +#endif /* PG_PUBLICATION_REL_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_publication_rel_d.h b/contrib/libs/postgresql/src/include/catalog/pg_publication_rel_d.h new file mode 100644 index 0000000000..0604b4b1a3 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_publication_rel_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_publication_rel_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_range.dat b/contrib/libs/postgresql/src/include/catalog/pg_range.dat new file mode 100644 index 0000000000..479754c245 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_range.dat @@ -0,0 +1,31 @@ +#---------------------------------------------------------------------- +# +# pg_range.dat +# Initial contents of the pg_range system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_range.dat +# +#---------------------------------------------------------------------- + +[ + +{ rngtypid => 'int4range', rngsubtype => 'int4', rngsubopc => 'btree/int4_ops', + rngcanonical => 'int4range_canonical', rngsubdiff => 'int4range_subdiff' }, +{ rngtypid => 'numrange', rngsubtype => 'numeric', + rngsubopc => 'btree/numeric_ops', rngcanonical => '-', + rngsubdiff => 'numrange_subdiff' }, +{ rngtypid => 'tsrange', rngsubtype => 'timestamp', + rngsubopc => 'btree/timestamp_ops', rngcanonical => '-', + rngsubdiff => 'tsrange_subdiff' }, +{ rngtypid => 'tstzrange', rngsubtype => 'timestamptz', + rngsubopc => 'btree/timestamptz_ops', rngcanonical => '-', + rngsubdiff => 'tstzrange_subdiff' }, +{ rngtypid => 'daterange', rngsubtype => 'date', rngsubopc => 'btree/date_ops', + rngcanonical => 'daterange_canonical', rngsubdiff => 'daterange_subdiff' }, +{ rngtypid => 'int8range', rngsubtype => 'int8', rngsubopc => 'btree/int8_ops', + rngcanonical => 'int8range_canonical', rngsubdiff => 'int8range_subdiff' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_range.h b/contrib/libs/postgresql/src/include/catalog/pg_range.h new file mode 100644 index 0000000000..98172bb1b6 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_range.h @@ -0,0 +1,66 @@ +/*------------------------------------------------------------------------- + * + * pg_range.h + * definition of the "range type" system catalog (pg_range) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_range.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_RANGE_H +#define PG_RANGE_H + +#include "catalog/genbki.h" +#include "catalog/pg_range_d.h" + +/* ---------------- + * pg_range definition. cpp turns this into + * typedef struct FormData_pg_range + * ---------------- + */ +CATALOG(pg_range,3541,RangeRelationId) +{ + /* OID of owning range type */ + Oid rngtypid BKI_LOOKUP(pg_type); + + /* OID of range's element type (subtype) */ + Oid rngsubtype BKI_LOOKUP(pg_type); + + /* collation for this range type, or 0 */ + Oid rngcollation BKI_DEFAULT(0); + + /* subtype's btree opclass */ + Oid rngsubopc BKI_LOOKUP(pg_opclass); + + /* canonicalize range, or 0 */ + regproc rngcanonical BKI_LOOKUP(pg_proc); + + /* subtype difference as a float8, or 0 */ + regproc rngsubdiff BKI_LOOKUP(pg_proc); +} FormData_pg_range; + +/* ---------------- + * Form_pg_range corresponds to a pointer to a tuple with + * the format of pg_range relation. + * ---------------- + */ +typedef FormData_pg_range *Form_pg_range; + +/* + * prototypes for functions in pg_range.c + */ + +extern void RangeCreate(Oid rangeTypeOid, Oid rangeSubType, Oid rangeCollation, + Oid rangeSubOpclass, RegProcedure rangeCanonical, + RegProcedure rangeSubDiff); +extern void RangeDelete(Oid rangeTypeOid); + +#endif /* PG_RANGE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_range_d.h b/contrib/libs/postgresql/src/include/catalog/pg_range_d.h new file mode 100644 index 0000000000..be0ad6f521 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_range_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_range_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_replication_origin.h b/contrib/libs/postgresql/src/include/catalog/pg_replication_origin.h new file mode 100644 index 0000000000..7477ce49cc --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_replication_origin.h @@ -0,0 +1,57 @@ +/*------------------------------------------------------------------------- + * + * pg_replication_origin.h + * definition of the "replication origin" system catalog + * (pg_replication_origin) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_replication_origin.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_REPLICATION_ORIGIN_H +#define PG_REPLICATION_ORIGIN_H + +#include "access/xlogdefs.h" +#include "catalog/genbki.h" +#include "catalog/pg_replication_origin_d.h" + +/* ---------------- + * pg_replication_origin. cpp turns this into + * typedef struct FormData_pg_replication_origin + * ---------------- + */ +CATALOG(pg_replication_origin,6000,ReplicationOriginRelationId) BKI_SHARED_RELATION +{ + /* + * Locally known id that get included into WAL. + * + * This should never leave the system. + * + * Needs to fit into an uint16, so we don't waste too much space in WAL + * records. For this reason we don't use a normal Oid column here, since + * we need to handle allocation of new values manually. + */ + Oid roident; + + /* + * Variable-length fields start here, but we allow direct access to + * roname. + */ + + /* external, free-format, name */ + text roname BKI_FORCE_NOT_NULL; + +#ifdef CATALOG_VARLEN /* further variable-length fields */ +#endif +} FormData_pg_replication_origin; + +typedef FormData_pg_replication_origin *Form_pg_replication_origin; + +#endif /* PG_REPLICATION_ORIGIN_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_replication_origin_d.h b/contrib/libs/postgresql/src/include/catalog/pg_replication_origin_d.h new file mode 100644 index 0000000000..f42fe89aac --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_replication_origin_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_replication_origin_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_rewrite.h b/contrib/libs/postgresql/src/include/catalog/pg_rewrite.h new file mode 100644 index 0000000000..4369fc87c6 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_rewrite.h @@ -0,0 +1,54 @@ +/*------------------------------------------------------------------------- + * + * pg_rewrite.h + * definition of the "rewrite rule" system catalog (pg_rewrite) + * + * As of Postgres 7.3, the primary key for this table is <ev_class, rulename> + * --- ie, rule names are only unique among the rules of a given table. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_rewrite.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_REWRITE_H +#define PG_REWRITE_H + +#include "catalog/genbki.h" +#include "catalog/pg_rewrite_d.h" + +/* ---------------- + * pg_rewrite definition. cpp turns this into + * typedef struct FormData_pg_rewrite + * ---------------- + */ +CATALOG(pg_rewrite,2618,RewriteRelationId) +{ + Oid oid; /* oid */ + NameData rulename; + Oid ev_class; + char ev_type; + char ev_enabled; + bool is_instead; + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + pg_node_tree ev_qual BKI_FORCE_NOT_NULL; + pg_node_tree ev_action BKI_FORCE_NOT_NULL; +#endif +} FormData_pg_rewrite; + +/* ---------------- + * Form_pg_rewrite corresponds to a pointer to a tuple with + * the format of pg_rewrite relation. + * ---------------- + */ +typedef FormData_pg_rewrite *Form_pg_rewrite; + +#endif /* PG_REWRITE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_rewrite_d.h b/contrib/libs/postgresql/src/include/catalog/pg_rewrite_d.h new file mode 100644 index 0000000000..633a69fd37 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_rewrite_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_rewrite_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_seclabel.h b/contrib/libs/postgresql/src/include/catalog/pg_seclabel.h new file mode 100644 index 0000000000..07d4bff119 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_seclabel.h @@ -0,0 +1,40 @@ +/* ------------------------------------------------------------------------- + * + * pg_seclabel.h + * definition of the "security label" system catalog (pg_seclabel) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_seclabel.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + * ------------------------------------------------------------------------- + */ +#ifndef PG_SECLABEL_H +#define PG_SECLABEL_H + +#include "catalog/genbki.h" +#include "catalog/pg_seclabel_d.h" + +/* ---------------- + * pg_seclabel definition. cpp turns this into + * typedef struct FormData_pg_seclabel + * ---------------- + */ +CATALOG(pg_seclabel,3596,SecLabelRelationId) +{ + Oid objoid; /* OID of the object itself */ + Oid classoid; /* OID of table containing the object */ + int32 objsubid; /* column number, or 0 if not used */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + text provider BKI_FORCE_NOT_NULL; /* name of label provider */ + text label BKI_FORCE_NOT_NULL; /* security label of the object */ +#endif +} FormData_pg_seclabel; + +#endif /* PG_SECLABEL_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_seclabel_d.h b/contrib/libs/postgresql/src/include/catalog/pg_seclabel_d.h new file mode 100644 index 0000000000..e8c167dfe1 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_seclabel_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_seclabel_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_sequence.h b/contrib/libs/postgresql/src/include/catalog/pg_sequence.h new file mode 100644 index 0000000000..9459edd95b --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_sequence.h @@ -0,0 +1,42 @@ +/* ------------------------------------------------------------------------- + * + * pg_sequence.h + * definition of the "sequence" system catalog (pg_sequence) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_sequence.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + * ------------------------------------------------------------------------- + */ +#ifndef PG_SEQUENCE_H +#define PG_SEQUENCE_H + +#include "catalog/genbki.h" +#include "catalog/pg_sequence_d.h" + +CATALOG(pg_sequence,2224,SequenceRelationId) +{ + Oid seqrelid; + Oid seqtypid; + int64 seqstart; + int64 seqincrement; + int64 seqmax; + int64 seqmin; + int64 seqcache; + bool seqcycle; +} FormData_pg_sequence; + +/* ---------------- + * Form_pg_sequence corresponds to a pointer to a tuple with + * the format of pg_sequence relation. + * ---------------- + */ +typedef FormData_pg_sequence *Form_pg_sequence; + +#endif /* PG_SEQUENCE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_sequence_d.h b/contrib/libs/postgresql/src/include/catalog/pg_sequence_d.h new file mode 100644 index 0000000000..70f7a70258 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_sequence_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_sequence_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_shdepend.h b/contrib/libs/postgresql/src/include/catalog/pg_shdepend.h new file mode 100644 index 0000000000..7c3fd5b08e --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_shdepend.h @@ -0,0 +1,72 @@ +/*------------------------------------------------------------------------- + * + * pg_shdepend.h + * definition of the "shared dependency" system catalog (pg_shdepend) + * + * pg_shdepend has no preloaded contents, so there is no pg_shdepend.dat + * file; system-defined dependencies are loaded into it during a late stage + * of the initdb process. + * + * NOTE: we do not represent all possible dependency pairs in pg_shdepend; + * for example, there's not much value in creating an explicit dependency + * from a relation to its database. Currently, only dependencies on roles + * are explicitly stored in pg_shdepend. + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_shdepend.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_SHDEPEND_H +#define PG_SHDEPEND_H + +#include "catalog/genbki.h" +#include "catalog/pg_shdepend_d.h" + +/* ---------------- + * pg_shdepend definition. cpp turns this into + * typedef struct FormData_pg_shdepend + * ---------------- + */ +CATALOG(pg_shdepend,1214,SharedDependRelationId) BKI_SHARED_RELATION +{ + /* + * Identification of the dependent (referencing) object. + * + * These fields are all zeroes for a DEPENDENCY_PIN entry. Also, dbid can + * be zero to denote a shared object. + */ + Oid dbid; /* OID of database containing object */ + Oid classid; /* OID of table containing object */ + Oid objid; /* OID of object itself */ + int32 objsubid; /* column number, or 0 if not used */ + + /* + * Identification of the independent (referenced) object. This is always + * a shared object, so we need no database ID field. We don't bother with + * a sub-object ID either. + */ + Oid refclassid; /* OID of table containing object */ + Oid refobjid; /* OID of object itself */ + + /* + * Precise semantics of the relationship are specified by the deptype + * field. See SharedDependencyType in catalog/dependency.h. + */ + char deptype; /* see codes in dependency.h */ +} FormData_pg_shdepend; + +/* ---------------- + * Form_pg_shdepend corresponds to a pointer to a row with + * the format of pg_shdepend relation. + * ---------------- + */ +typedef FormData_pg_shdepend *Form_pg_shdepend; + +#endif /* PG_SHDEPEND_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_shdepend_d.h b/contrib/libs/postgresql/src/include/catalog/pg_shdepend_d.h new file mode 100644 index 0000000000..b3b9f33f27 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_shdepend_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_shdepend_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_shdescription.h b/contrib/libs/postgresql/src/include/catalog/pg_shdescription.h new file mode 100644 index 0000000000..a8238aa793 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_shdescription.h @@ -0,0 +1,58 @@ +/*------------------------------------------------------------------------- + * + * pg_shdescription.h + * definition of the "shared description" system catalog + * (pg_shdescription) + * + * Because the contents of this table are taken from the *.dat files + * of other catalogs, there is no pg_shdescription.dat file. The initial + * contents are assembled by genbki.pl and loaded during initdb. + * + * NOTE: an object is identified by the OID of the row that primarily + * defines the object, plus the OID of the table that that row appears in. + * For example, a database is identified by the OID of its pg_database row + * plus the pg_class OID of table pg_database. This allows unique + * identification of objects without assuming that OIDs are unique + * across tables. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_shdescription.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_SHDESCRIPTION_H +#define PG_SHDESCRIPTION_H + +#include "catalog/genbki.h" +#include "catalog/pg_shdescription_d.h" + +/* ---------------- + * pg_shdescription definition. cpp turns this into + * typedef struct FormData_pg_shdescription + * ---------------- + */ +CATALOG(pg_shdescription,2396,SharedDescriptionRelationId) BKI_SHARED_RELATION +{ + Oid objoid; /* OID of object itself */ + Oid classoid; /* OID of table containing object */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + text description BKI_FORCE_NOT_NULL; /* description of object */ +#endif +} FormData_pg_shdescription; + +/* ---------------- + * Form_pg_shdescription corresponds to a pointer to a tuple with + * the format of pg_shdescription relation. + * ---------------- + */ +typedef FormData_pg_shdescription * Form_pg_shdescription; + +#endif /* PG_SHDESCRIPTION_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_shdescription_d.h b/contrib/libs/postgresql/src/include/catalog/pg_shdescription_d.h new file mode 100644 index 0000000000..4981c86b7c --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_shdescription_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_shdescription_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_shseclabel.h b/contrib/libs/postgresql/src/include/catalog/pg_shseclabel.h new file mode 100644 index 0000000000..331e066448 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_shseclabel.h @@ -0,0 +1,41 @@ +/* ------------------------------------------------------------------------- + * + * pg_shseclabel.h + * definition of the "shared security label" system catalog (pg_shseclabel) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_shseclabel.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + * ------------------------------------------------------------------------- + */ +#ifndef PG_SHSECLABEL_H +#define PG_SHSECLABEL_H + +#include "catalog/genbki.h" +#include "catalog/pg_shseclabel_d.h" + +/* ---------------- + * pg_shseclabel definition. cpp turns this into + * typedef struct FormData_pg_shseclabel + * ---------------- + */ +CATALOG(pg_shseclabel,3592,SharedSecLabelRelationId) BKI_SHARED_RELATION BKI_ROWTYPE_OID(4066,SharedSecLabelRelation_Rowtype_Id) BKI_SCHEMA_MACRO +{ + Oid objoid; /* OID of the shared object itself */ + Oid classoid; /* OID of table containing the shared object */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + text provider BKI_FORCE_NOT_NULL; /* name of label provider */ + text label BKI_FORCE_NOT_NULL; /* security label of the object */ +#endif +} FormData_pg_shseclabel; + +typedef FormData_pg_shseclabel * Form_pg_shseclabel; + +#endif /* PG_SHSECLABEL_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_shseclabel_d.h b/contrib/libs/postgresql/src/include/catalog/pg_shseclabel_d.h new file mode 100644 index 0000000000..56688085b5 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_shseclabel_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_shseclabel_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_statistic.h b/contrib/libs/postgresql/src/include/catalog/pg_statistic.h new file mode 100644 index 0000000000..40a7260165 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_statistic.h @@ -0,0 +1,275 @@ +/*------------------------------------------------------------------------- + * + * pg_statistic.h + * definition of the "statistics" system catalog (pg_statistic) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_statistic.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_STATISTIC_H +#define PG_STATISTIC_H + +#include "catalog/genbki.h" +#include "catalog/pg_statistic_d.h" + +/* ---------------- + * pg_statistic definition. cpp turns this into + * typedef struct FormData_pg_statistic + * ---------------- + */ +CATALOG(pg_statistic,2619,StatisticRelationId) +{ + /* These fields form the unique key for the entry: */ + Oid starelid; /* relation containing attribute */ + int16 staattnum; /* attribute (column) stats are for */ + bool stainherit; /* true if inheritance children are included */ + + /* the fraction of the column's entries that are NULL: */ + float4 stanullfrac; + + /* + * stawidth is the average width in bytes of non-null entries. For + * fixed-width datatypes this is of course the same as the typlen, but for + * var-width types it is more useful. Note that this is the average width + * of the data as actually stored, post-TOASTing (eg, for a + * moved-out-of-line value, only the size of the pointer object is + * counted). This is the appropriate definition for the primary use of + * the statistic, which is to estimate sizes of in-memory hash tables of + * tuples. + */ + int32 stawidth; + + /* ---------------- + * stadistinct indicates the (approximate) number of distinct non-null + * data values in the column. The interpretation is: + * 0 unknown or not computed + * > 0 actual number of distinct values + * < 0 negative of multiplier for number of rows + * The special negative case allows us to cope with columns that are + * unique (stadistinct = -1) or nearly so (for example, a column in which + * non-null values appear about twice on the average could be represented + * by stadistinct = -0.5 if there are no nulls, or -0.4 if 20% of the + * column is nulls). Because the number-of-rows statistic in pg_class may + * be updated more frequently than pg_statistic is, it's important to be + * able to describe such situations as a multiple of the number of rows, + * rather than a fixed number of distinct values. But in other cases a + * fixed number is correct (eg, a boolean column). + * ---------------- + */ + float4 stadistinct; + + /* ---------------- + * To allow keeping statistics on different kinds of datatypes, + * we do not hard-wire any particular meaning for the remaining + * statistical fields. Instead, we provide several "slots" in which + * statistical data can be placed. Each slot includes: + * kind integer code identifying kind of data (see below) + * op OID of associated operator, if needed + * coll OID of relevant collation, or 0 if none + * numbers float4 array (for statistical values) + * values anyarray (for representations of data values) + * The ID, operator, and collation fields are never NULL; they are zeroes + * in an unused slot. The numbers and values fields are NULL in an + * unused slot, and might also be NULL in a used slot if the slot kind + * has no need for one or the other. + * ---------------- + */ + + int16 stakind1; + int16 stakind2; + int16 stakind3; + int16 stakind4; + int16 stakind5; + + Oid staop1; + Oid staop2; + Oid staop3; + Oid staop4; + Oid staop5; + + Oid stacoll1; + Oid stacoll2; + Oid stacoll3; + Oid stacoll4; + Oid stacoll5; + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + float4 stanumbers1[1]; + float4 stanumbers2[1]; + float4 stanumbers3[1]; + float4 stanumbers4[1]; + float4 stanumbers5[1]; + + /* + * Values in these arrays are values of the column's data type, or of some + * related type such as an array element type. We presently have to cheat + * quite a bit to allow polymorphic arrays of this kind, but perhaps + * someday it'll be a less bogus facility. + */ + anyarray stavalues1; + anyarray stavalues2; + anyarray stavalues3; + anyarray stavalues4; + anyarray stavalues5; +#endif +} FormData_pg_statistic; + +#define STATISTIC_NUM_SLOTS 5 + + +/* ---------------- + * Form_pg_statistic corresponds to a pointer to a tuple with + * the format of pg_statistic relation. + * ---------------- + */ +typedef FormData_pg_statistic *Form_pg_statistic; + +#ifdef EXPOSE_TO_CLIENT_CODE + +/* + * Several statistical slot "kinds" are defined by core PostgreSQL, as + * documented below. Also, custom data types can define their own "kind" + * codes by mutual agreement between a custom typanalyze routine and the + * selectivity estimation functions of the type's operators. + * + * Code reading the pg_statistic relation should not assume that a particular + * data "kind" will appear in any particular slot. Instead, search the + * stakind fields to see if the desired data is available. (The standard + * function get_attstatsslot() may be used for this.) + */ + +/* + * The present allocation of "kind" codes is: + * + * 1-99: reserved for assignment by the core PostgreSQL project + * (values in this range will be documented in this file) + * 100-199: reserved for assignment by the PostGIS project + * (values to be documented in PostGIS documentation) + * 200-299: reserved for assignment by the ESRI ST_Geometry project + * (values to be documented in ESRI ST_Geometry documentation) + * 300-9999: reserved for future public assignments + * + * For private use you may choose a "kind" code at random in the range + * 10000-30000. However, for code that is to be widely disseminated it is + * better to obtain a publicly defined "kind" code by request from the + * PostgreSQL Global Development Group. + */ + +/* + * In a "most common values" slot, staop is the OID of the "=" operator + * used to decide whether values are the same or not, and stacoll is the + * collation used (same as column's collation). stavalues contains + * the K most common non-null values appearing in the column, and stanumbers + * contains their frequencies (fractions of total row count). The values + * shall be ordered in decreasing frequency. Note that since the arrays are + * variable-size, K may be chosen by the statistics collector. Values should + * not appear in MCV unless they have been observed to occur more than once; + * a unique column will have no MCV slot. + */ +#define STATISTIC_KIND_MCV 1 + +/* + * A "histogram" slot describes the distribution of scalar data. staop is + * the OID of the "<" operator that describes the sort ordering, and stacoll + * is the relevant collation. (In theory more than one histogram could appear, + * if a datatype has more than one useful sort operator or we care about more + * than one collation. Currently the collation will always be that of the + * underlying column.) stavalues contains M (>=2) non-null values that + * divide the non-null column data values into M-1 bins of approximately equal + * population. The first stavalues item is the MIN and the last is the MAX. + * stanumbers is not used and should be NULL. IMPORTANT POINT: if an MCV + * slot is also provided, then the histogram describes the data distribution + * *after removing the values listed in MCV* (thus, it's a "compressed + * histogram" in the technical parlance). This allows a more accurate + * representation of the distribution of a column with some very-common + * values. In a column with only a few distinct values, it's possible that + * the MCV list describes the entire data population; in this case the + * histogram reduces to empty and should be omitted. + */ +#define STATISTIC_KIND_HISTOGRAM 2 + +/* + * A "correlation" slot describes the correlation between the physical order + * of table tuples and the ordering of data values of this column, as seen + * by the "<" operator identified by staop with the collation identified by + * stacoll. (As with the histogram, more than one entry could theoretically + * appear.) stavalues is not used and should be NULL. stanumbers contains + * a single entry, the correlation coefficient between the sequence of data + * values and the sequence of their actual tuple positions. The coefficient + * ranges from +1 to -1. + */ +#define STATISTIC_KIND_CORRELATION 3 + +/* + * A "most common elements" slot is similar to a "most common values" slot, + * except that it stores the most common non-null *elements* of the column + * values. This is useful when the column datatype is an array or some other + * type with identifiable elements (for instance, tsvector). staop contains + * the equality operator appropriate to the element type, and stacoll + * contains the collation to use with it. stavalues contains + * the most common element values, and stanumbers their frequencies. Unlike + * MCV slots, frequencies are measured as the fraction of non-null rows the + * element value appears in, not the frequency of all rows. Also unlike + * MCV slots, the values are sorted into the element type's default order + * (to support binary search for a particular value). Since this puts the + * minimum and maximum frequencies at unpredictable spots in stanumbers, + * there are two extra members of stanumbers, holding copies of the minimum + * and maximum frequencies. Optionally, there can be a third extra member, + * which holds the frequency of null elements (expressed in the same terms: + * the fraction of non-null rows that contain at least one null element). If + * this member is omitted, the column is presumed to contain no null elements. + * + * Note: in current usage for tsvector columns, the stavalues elements are of + * type text, even though their representation within tsvector is not + * exactly text. + */ +#define STATISTIC_KIND_MCELEM 4 + +/* + * A "distinct elements count histogram" slot describes the distribution of + * the number of distinct element values present in each row of an array-type + * column. Only non-null rows are considered, and only non-null elements. + * staop contains the equality operator appropriate to the element type, + * and stacoll contains the collation to use with it. + * stavalues is not used and should be NULL. The last member of stanumbers is + * the average count of distinct element values over all non-null rows. The + * preceding M (>=2) members form a histogram that divides the population of + * distinct-elements counts into M-1 bins of approximately equal population. + * The first of these is the minimum observed count, and the last the maximum. + */ +#define STATISTIC_KIND_DECHIST 5 + +/* + * A "length histogram" slot describes the distribution of range lengths in + * rows of a range-type column. stanumbers contains a single entry, the + * fraction of empty ranges. stavalues is a histogram of non-empty lengths, in + * a format similar to STATISTIC_KIND_HISTOGRAM: it contains M (>=2) range + * values that divide the column data values into M-1 bins of approximately + * equal population. The lengths are stored as float8s, as measured by the + * range type's subdiff function. Only non-null rows are considered. + */ +#define STATISTIC_KIND_RANGE_LENGTH_HISTOGRAM 6 + +/* + * A "bounds histogram" slot is similar to STATISTIC_KIND_HISTOGRAM, but for + * a range-type column. stavalues contains M (>=2) range values that divide + * the column data values into M-1 bins of approximately equal population. + * Unlike a regular scalar histogram, this is actually two histograms combined + * into a single array, with the lower bounds of each value forming a + * histogram of lower bounds, and the upper bounds a histogram of upper + * bounds. Only non-NULL, non-empty ranges are included. + */ +#define STATISTIC_KIND_BOUNDS_HISTOGRAM 7 + +#endif /* EXPOSE_TO_CLIENT_CODE */ + +#endif /* PG_STATISTIC_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_statistic_d.h b/contrib/libs/postgresql/src/include/catalog/pg_statistic_d.h new file mode 100644 index 0000000000..25f8ba5d26 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_statistic_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_statistic_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext.h b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext.h new file mode 100644 index 0000000000..a8cb16997a --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext.h @@ -0,0 +1,74 @@ +/*------------------------------------------------------------------------- + * + * pg_statistic_ext.h + * definition of the "extended statistics" system catalog + * (pg_statistic_ext) + * + * Note that pg_statistic_ext contains the definitions of extended statistics + * objects, created by CREATE STATISTICS, but not the actual statistical data, + * created by running ANALYZE. + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_statistic_ext.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_STATISTIC_EXT_H +#define PG_STATISTIC_EXT_H + +#include "catalog/genbki.h" +#include "catalog/pg_statistic_ext_d.h" + +/* ---------------- + * pg_statistic_ext definition. cpp turns this into + * typedef struct FormData_pg_statistic_ext + * ---------------- + */ +CATALOG(pg_statistic_ext,3381,StatisticExtRelationId) +{ + Oid oid; /* oid */ + + Oid stxrelid; /* relation containing attributes */ + + /* These two fields form the unique key for the entry: */ + NameData stxname; /* statistics object name */ + Oid stxnamespace; /* OID of statistics object's namespace */ + + Oid stxowner; /* statistics object's owner */ + int32 stxstattarget BKI_DEFAULT(-1); /* statistics target */ + + /* + * variable-length fields start here, but we allow direct access to + * stxkeys + */ + int2vector stxkeys; /* array of column keys */ + +#ifdef CATALOG_VARLEN + char stxkind[1] BKI_FORCE_NOT_NULL; /* statistics kinds requested + * to build */ +#endif + +} FormData_pg_statistic_ext; + +/* ---------------- + * Form_pg_statistic_ext corresponds to a pointer to a tuple with + * the format of pg_statistic_ext relation. + * ---------------- + */ +typedef FormData_pg_statistic_ext *Form_pg_statistic_ext; + +#ifdef EXPOSE_TO_CLIENT_CODE + +#define STATS_EXT_NDISTINCT 'd' +#define STATS_EXT_DEPENDENCIES 'f' +#define STATS_EXT_MCV 'm' + +#endif /* EXPOSE_TO_CLIENT_CODE */ + +#endif /* PG_STATISTIC_EXT_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_d.h b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_d.h new file mode 100644 index 0000000000..e472ec19af --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_statistic_ext_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_data.h b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_data.h new file mode 100644 index 0000000000..0ef4ecb64a --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_data.h @@ -0,0 +1,52 @@ +/*------------------------------------------------------------------------- + * + * pg_statistic_ext_data.h + * definition of the "extended statistics data" system catalog + * (pg_statistic_ext_data) + * + * This catalog stores the statistical data for extended statistics objects. + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_statistic_ext_data.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_STATISTIC_EXT_DATA_H +#define PG_STATISTIC_EXT_DATA_H + +#include "catalog/genbki.h" +#include "catalog/pg_statistic_ext_data_d.h" + +/* ---------------- + * pg_statistic_ext_data definition. cpp turns this into + * typedef struct FormData_pg_statistic_ext_data + * ---------------- + */ +CATALOG(pg_statistic_ext_data,3429,StatisticExtDataRelationId) +{ + Oid stxoid; /* statistics object this data is for */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + + pg_ndistinct stxdndistinct; /* ndistinct coefficients (serialized) */ + pg_dependencies stxddependencies; /* dependencies (serialized) */ + pg_mcv_list stxdmcv; /* MCV (serialized) */ + +#endif + +} FormData_pg_statistic_ext_data; + +/* ---------------- + * Form_pg_statistic_ext_data corresponds to a pointer to a tuple with + * the format of pg_statistic_ext_data relation. + * ---------------- + */ +typedef FormData_pg_statistic_ext_data * Form_pg_statistic_ext_data; + +#endif /* PG_STATISTIC_EXT_DATA_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_data_d.h b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_data_d.h new file mode 100644 index 0000000000..7782f447fc --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_statistic_ext_data_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_statistic_ext_data_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_subscription.h b/contrib/libs/postgresql/src/include/catalog/pg_subscription.h new file mode 100644 index 0000000000..e3288ad76e --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_subscription.h @@ -0,0 +1,89 @@ +/* ------------------------------------------------------------------------- + * + * pg_subscription.h + * definition of the "subscription" system catalog (pg_subscription) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_subscription.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + * ------------------------------------------------------------------------- + */ +#ifndef PG_SUBSCRIPTION_H +#define PG_SUBSCRIPTION_H + +#include "catalog/genbki.h" +#include "catalog/pg_subscription_d.h" + +#include "nodes/pg_list.h" + +/* ---------------- + * pg_subscription definition. cpp turns this into + * typedef struct FormData_pg_subscription + * ---------------- + */ + +/* + * Technically, the subscriptions live inside the database, so a shared catalog + * seems weird, but the replication launcher process needs to access all of + * them to be able to start the workers, so we have to put them in a shared, + * nailed catalog. + * + * NOTE: When adding a column, also update system_views.sql. + */ +CATALOG(pg_subscription,6100,SubscriptionRelationId) BKI_SHARED_RELATION BKI_ROWTYPE_OID(6101,SubscriptionRelation_Rowtype_Id) BKI_SCHEMA_MACRO +{ + Oid oid; /* oid */ + + Oid subdbid; /* Database the subscription is in. */ + NameData subname; /* Name of the subscription */ + + Oid subowner; /* Owner of the subscription */ + + bool subenabled; /* True if the subscription is enabled (the + * worker should be running) */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + /* Connection string to the publisher */ + text subconninfo BKI_FORCE_NOT_NULL; + + /* Slot name on publisher */ + NameData subslotname BKI_FORCE_NULL; + + /* Synchronous commit setting for worker */ + text subsynccommit BKI_FORCE_NOT_NULL; + + /* List of publications subscribed to */ + text subpublications[1] BKI_FORCE_NOT_NULL; +#endif +} FormData_pg_subscription; + +typedef FormData_pg_subscription *Form_pg_subscription; + +typedef struct Subscription +{ + Oid oid; /* Oid of the subscription */ + Oid dbid; /* Oid of the database which subscription is + * in */ + char *name; /* Name of the subscription */ + Oid owner; /* Oid of the subscription owner */ + bool enabled; /* Indicates if the subscription is enabled */ + char *conninfo; /* Connection string to the publisher */ + char *slotname; /* Name of the replication slot */ + char *synccommit; /* Synchronous commit setting for worker */ + List *publications; /* List of publication names to subscribe to */ +} Subscription; + +extern Subscription *GetSubscription(Oid subid, bool missing_ok); +extern void FreeSubscription(Subscription *sub); +extern Oid get_subscription_oid(const char *subname, bool missing_ok); +extern char *get_subscription_name(Oid subid, bool missing_ok); + +extern int CountDBSubscriptions(Oid dbid); + +#endif /* PG_SUBSCRIPTION_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_subscription_d.h b/contrib/libs/postgresql/src/include/catalog/pg_subscription_d.h new file mode 100644 index 0000000000..2f0718c2d7 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_subscription_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_subscription_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_subscription_rel.h b/contrib/libs/postgresql/src/include/catalog/pg_subscription_rel.h new file mode 100644 index 0000000000..f384f4e7fa --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_subscription_rel.h @@ -0,0 +1,90 @@ +/* ------------------------------------------------------------------------- + * + * pg_subscription_rel.h + * definition of the system catalog containing the state for each + * replicated table in each subscription (pg_subscription_rel) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_subscription_rel.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + * ------------------------------------------------------------------------- + */ +#ifndef PG_SUBSCRIPTION_REL_H +#define PG_SUBSCRIPTION_REL_H + +#include "access/xlogdefs.h" +#include "catalog/genbki.h" +#include "catalog/pg_subscription_rel_d.h" +#include "nodes/pg_list.h" + +/* ---------------- + * pg_subscription_rel definition. cpp turns this into + * typedef struct FormData_pg_subscription_rel + * ---------------- + */ +CATALOG(pg_subscription_rel,6102,SubscriptionRelRelationId) +{ + Oid srsubid; /* Oid of subscription */ + Oid srrelid; /* Oid of relation */ + char srsubstate; /* state of the relation in subscription */ + + /* + * Although srsublsn is a fixed-width type, it is allowed to be NULL, so + * we prevent direct C code access to it just as for a varlena field. + */ +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + + XLogRecPtr srsublsn BKI_FORCE_NULL; /* remote LSN of the state change + * used for synchronization + * coordination, or NULL if not + * valid */ +#endif +} FormData_pg_subscription_rel; + +typedef FormData_pg_subscription_rel *Form_pg_subscription_rel; + +#ifdef EXPOSE_TO_CLIENT_CODE + +/* ---------------- + * substate constants + * ---------------- + */ +#define SUBREL_STATE_INIT 'i' /* initializing (sublsn NULL) */ +#define SUBREL_STATE_DATASYNC 'd' /* data is being synchronized (sublsn + * NULL) */ +#define SUBREL_STATE_SYNCDONE 's' /* synchronization finished in front of + * apply (sublsn set) */ +#define SUBREL_STATE_READY 'r' /* ready (sublsn set) */ + +/* These are never stored in the catalog, we only use them for IPC. */ +#define SUBREL_STATE_UNKNOWN '\0' /* unknown state */ +#define SUBREL_STATE_SYNCWAIT 'w' /* waiting for sync */ +#define SUBREL_STATE_CATCHUP 'c' /* catching up with apply */ + +#endif /* EXPOSE_TO_CLIENT_CODE */ + +typedef struct SubscriptionRelState +{ + Oid relid; + XLogRecPtr lsn; + char state; +} SubscriptionRelState; + +extern void AddSubscriptionRelState(Oid subid, Oid relid, char state, + XLogRecPtr sublsn); +extern void UpdateSubscriptionRelState(Oid subid, Oid relid, char state, + XLogRecPtr sublsn); +extern char GetSubscriptionRelState(Oid subid, Oid relid, + XLogRecPtr *sublsn, bool missing_ok); +extern void RemoveSubscriptionRel(Oid subid, Oid relid); + +extern List *GetSubscriptionRelations(Oid subid); +extern List *GetSubscriptionNotReadyRelations(Oid subid); + +#endif /* PG_SUBSCRIPTION_REL_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_subscription_rel_d.h b/contrib/libs/postgresql/src/include/catalog/pg_subscription_rel_d.h new file mode 100644 index 0000000000..d865437594 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_subscription_rel_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_subscription_rel_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_tablespace.dat b/contrib/libs/postgresql/src/include/catalog/pg_tablespace.dat new file mode 100644 index 0000000000..bb0dec08ef --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_tablespace.dat @@ -0,0 +1,22 @@ +#---------------------------------------------------------------------- +# +# pg_tablespace.dat +# Initial contents of the pg_tablespace system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_tablespace.dat +# +#---------------------------------------------------------------------- + +[ + +{ oid => '1663', oid_symbol => 'DEFAULTTABLESPACE_OID', + spcname => 'pg_default', spcowner => 'PGUID', spcacl => '_null_', + spcoptions => '_null_' }, +{ oid => '1664', oid_symbol => 'GLOBALTABLESPACE_OID', + spcname => 'pg_global', spcowner => 'PGUID', spcacl => '_null_', + spcoptions => '_null_' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_tablespace.h b/contrib/libs/postgresql/src/include/catalog/pg_tablespace.h new file mode 100644 index 0000000000..1daf2dd9c2 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_tablespace.h @@ -0,0 +1,48 @@ +/*------------------------------------------------------------------------- + * + * pg_tablespace.h + * definition of the "tablespace" system catalog (pg_tablespace) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_tablespace.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_TABLESPACE_H +#define PG_TABLESPACE_H + +#include "catalog/genbki.h" +#include "catalog/pg_tablespace_d.h" + +/* ---------------- + * pg_tablespace definition. cpp turns this into + * typedef struct FormData_pg_tablespace + * ---------------- + */ +CATALOG(pg_tablespace,1213,TableSpaceRelationId) BKI_SHARED_RELATION +{ + Oid oid; /* oid */ + NameData spcname; /* tablespace name */ + Oid spcowner; /* owner of tablespace */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + aclitem spcacl[1]; /* access permissions */ + text spcoptions[1]; /* per-tablespace options */ +#endif +} FormData_pg_tablespace; + +/* ---------------- + * Form_pg_tablespace corresponds to a pointer to a tuple with + * the format of pg_tablespace relation. + * ---------------- + */ +typedef FormData_pg_tablespace *Form_pg_tablespace; + +#endif /* PG_TABLESPACE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_tablespace_d.h b/contrib/libs/postgresql/src/include/catalog/pg_tablespace_d.h new file mode 100644 index 0000000000..b388ac1169 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_tablespace_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_tablespace_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_transform.h b/contrib/libs/postgresql/src/include/catalog/pg_transform.h new file mode 100644 index 0000000000..05f3e276fc --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_transform.h @@ -0,0 +1,45 @@ +/*------------------------------------------------------------------------- + * + * pg_transform.h + * definition of the "transform" system catalog (pg_transform) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_transform.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_TRANSFORM_H +#define PG_TRANSFORM_H + +#include "catalog/genbki.h" +#include "catalog/pg_transform_d.h" + +/* ---------------- + * pg_transform definition. cpp turns this into + * typedef struct FormData_pg_transform + * ---------------- + */ +CATALOG(pg_transform,3576,TransformRelationId) +{ + Oid oid; /* oid */ + Oid trftype; + Oid trflang; + regproc trffromsql; + regproc trftosql; +} FormData_pg_transform; + +/* ---------------- + * Form_pg_transform corresponds to a pointer to a tuple with + * the format of pg_transform relation. + * ---------------- + */ +typedef FormData_pg_transform *Form_pg_transform; + +#endif /* PG_TRANSFORM_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_transform_d.h b/contrib/libs/postgresql/src/include/catalog/pg_transform_d.h new file mode 100644 index 0000000000..e2d1984992 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_transform_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_transform_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_trigger.h b/contrib/libs/postgresql/src/include/catalog/pg_trigger.h new file mode 100644 index 0000000000..9612b9bdd6 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_trigger.h @@ -0,0 +1,137 @@ +/*------------------------------------------------------------------------- + * + * pg_trigger.h + * definition of the "trigger" system catalog (pg_trigger) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_trigger.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_TRIGGER_H +#define PG_TRIGGER_H + +#include "catalog/genbki.h" +#include "catalog/pg_trigger_d.h" + +/* ---------------- + * pg_trigger definition. cpp turns this into + * typedef struct FormData_pg_trigger + * + * Note: when tgconstraint is nonzero, tgconstrrelid, tgconstrindid, + * tgdeferrable, and tginitdeferred are largely redundant with the referenced + * pg_constraint entry. However, it is possible for a non-deferrable trigger + * to be associated with a deferrable constraint. + * ---------------- + */ +CATALOG(pg_trigger,2620,TriggerRelationId) +{ + Oid oid; /* oid */ + Oid tgrelid; /* relation trigger is attached to */ + Oid tgparentid; /* OID of parent trigger, if any */ + NameData tgname; /* trigger's name */ + Oid tgfoid; /* OID of function to be called */ + int16 tgtype; /* BEFORE/AFTER/INSTEAD, UPDATE/DELETE/INSERT, + * ROW/STATEMENT; see below */ + char tgenabled; /* trigger's firing configuration WRT + * session_replication_role */ + bool tgisinternal; /* trigger is system-generated */ + Oid tgconstrrelid; /* constraint's FROM table, if any */ + Oid tgconstrindid; /* constraint's supporting index, if any */ + Oid tgconstraint; /* associated pg_constraint entry, if any */ + bool tgdeferrable; /* constraint trigger is deferrable */ + bool tginitdeferred; /* constraint trigger is deferred initially */ + int16 tgnargs; /* # of extra arguments in tgargs */ + + /* + * Variable-length fields start here, but we allow direct access to + * tgattr. Note: tgattr and tgargs must not be null. + */ + int2vector tgattr; /* column numbers, if trigger is on columns */ + +#ifdef CATALOG_VARLEN + bytea tgargs BKI_FORCE_NOT_NULL; /* first\000second\000tgnargs\000 */ + pg_node_tree tgqual; /* WHEN expression, or NULL if none */ + NameData tgoldtable; /* old transition table, or NULL if none */ + NameData tgnewtable; /* new transition table, or NULL if none */ +#endif +} FormData_pg_trigger; + +/* ---------------- + * Form_pg_trigger corresponds to a pointer to a tuple with + * the format of pg_trigger relation. + * ---------------- + */ +typedef FormData_pg_trigger *Form_pg_trigger; + +#ifdef EXPOSE_TO_CLIENT_CODE + +/* Bits within tgtype */ +#define TRIGGER_TYPE_ROW (1 << 0) +#define TRIGGER_TYPE_BEFORE (1 << 1) +#define TRIGGER_TYPE_INSERT (1 << 2) +#define TRIGGER_TYPE_DELETE (1 << 3) +#define TRIGGER_TYPE_UPDATE (1 << 4) +#define TRIGGER_TYPE_TRUNCATE (1 << 5) +#define TRIGGER_TYPE_INSTEAD (1 << 6) + +#define TRIGGER_TYPE_LEVEL_MASK (TRIGGER_TYPE_ROW) +#define TRIGGER_TYPE_STATEMENT 0 + +/* Note bits within TRIGGER_TYPE_TIMING_MASK aren't adjacent */ +#define TRIGGER_TYPE_TIMING_MASK \ + (TRIGGER_TYPE_BEFORE | TRIGGER_TYPE_INSTEAD) +#define TRIGGER_TYPE_AFTER 0 + +#define TRIGGER_TYPE_EVENT_MASK \ + (TRIGGER_TYPE_INSERT | TRIGGER_TYPE_DELETE | TRIGGER_TYPE_UPDATE | TRIGGER_TYPE_TRUNCATE) + +/* Macros for manipulating tgtype */ +#define TRIGGER_CLEAR_TYPE(type) ((type) = 0) + +#define TRIGGER_SETT_ROW(type) ((type) |= TRIGGER_TYPE_ROW) +#define TRIGGER_SETT_STATEMENT(type) ((type) |= TRIGGER_TYPE_STATEMENT) +#define TRIGGER_SETT_BEFORE(type) ((type) |= TRIGGER_TYPE_BEFORE) +#define TRIGGER_SETT_AFTER(type) ((type) |= TRIGGER_TYPE_AFTER) +#define TRIGGER_SETT_INSTEAD(type) ((type) |= TRIGGER_TYPE_INSTEAD) +#define TRIGGER_SETT_INSERT(type) ((type) |= TRIGGER_TYPE_INSERT) +#define TRIGGER_SETT_DELETE(type) ((type) |= TRIGGER_TYPE_DELETE) +#define TRIGGER_SETT_UPDATE(type) ((type) |= TRIGGER_TYPE_UPDATE) +#define TRIGGER_SETT_TRUNCATE(type) ((type) |= TRIGGER_TYPE_TRUNCATE) + +#define TRIGGER_FOR_ROW(type) ((type) & TRIGGER_TYPE_ROW) +#define TRIGGER_FOR_BEFORE(type) (((type) & TRIGGER_TYPE_TIMING_MASK) == TRIGGER_TYPE_BEFORE) +#define TRIGGER_FOR_AFTER(type) (((type) & TRIGGER_TYPE_TIMING_MASK) == TRIGGER_TYPE_AFTER) +#define TRIGGER_FOR_INSTEAD(type) (((type) & TRIGGER_TYPE_TIMING_MASK) == TRIGGER_TYPE_INSTEAD) +#define TRIGGER_FOR_INSERT(type) ((type) & TRIGGER_TYPE_INSERT) +#define TRIGGER_FOR_DELETE(type) ((type) & TRIGGER_TYPE_DELETE) +#define TRIGGER_FOR_UPDATE(type) ((type) & TRIGGER_TYPE_UPDATE) +#define TRIGGER_FOR_TRUNCATE(type) ((type) & TRIGGER_TYPE_TRUNCATE) + +/* + * Efficient macro for checking if tgtype matches a particular level + * (TRIGGER_TYPE_ROW or TRIGGER_TYPE_STATEMENT), timing (TRIGGER_TYPE_BEFORE, + * TRIGGER_TYPE_AFTER or TRIGGER_TYPE_INSTEAD), and event (TRIGGER_TYPE_INSERT, + * TRIGGER_TYPE_DELETE, TRIGGER_TYPE_UPDATE, or TRIGGER_TYPE_TRUNCATE). Note + * that a tgtype can match more than one event, but only one level or timing. + */ +#define TRIGGER_TYPE_MATCHES(type, level, timing, event) \ + (((type) & (TRIGGER_TYPE_LEVEL_MASK | TRIGGER_TYPE_TIMING_MASK | (event))) == ((level) | (timing) | (event))) + +/* + * Macro to determine whether tgnewtable or tgoldtable has been specified for + * a trigger. + */ +#define TRIGGER_USES_TRANSITION_TABLE(namepointer) \ + ((namepointer) != (char *) NULL) + +#endif /* EXPOSE_TO_CLIENT_CODE */ + +#endif /* PG_TRIGGER_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_trigger_d.h b/contrib/libs/postgresql/src/include/catalog/pg_trigger_d.h new file mode 100644 index 0000000000..0b1c9e3bee --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_trigger_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_trigger_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_config.dat b/contrib/libs/postgresql/src/include/catalog/pg_ts_config.dat new file mode 100644 index 0000000000..44281675db --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_config.dat @@ -0,0 +1,18 @@ +#---------------------------------------------------------------------- +# +# pg_ts_config.dat +# Initial contents of the pg_ts_config system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_ts_config.dat +# +#---------------------------------------------------------------------- + +[ + +{ oid => '3748', descr => 'simple configuration', + cfgname => 'simple', cfgparser => 'default' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_config.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_config.h new file mode 100644 index 0000000000..0d9c5e3590 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_config.h @@ -0,0 +1,50 @@ +/*------------------------------------------------------------------------- + * + * pg_ts_config.h + * definition of the "text search configuration" system catalog + * (pg_ts_config) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_ts_config.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_TS_CONFIG_H +#define PG_TS_CONFIG_H + +#include "catalog/genbki.h" +#include "catalog/pg_ts_config_d.h" + +/* ---------------- + * pg_ts_config definition. cpp turns this into + * typedef struct FormData_pg_ts_config + * ---------------- + */ +CATALOG(pg_ts_config,3602,TSConfigRelationId) +{ + /* oid */ + Oid oid; + + /* name of configuration */ + NameData cfgname; + + /* name space */ + Oid cfgnamespace BKI_DEFAULT(PGNSP); + + /* owner */ + Oid cfgowner BKI_DEFAULT(PGUID); + + /* OID of parser */ + Oid cfgparser BKI_LOOKUP(pg_ts_parser); +} FormData_pg_ts_config; + +typedef FormData_pg_ts_config *Form_pg_ts_config; + +#endif /* PG_TS_CONFIG_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_config_d.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_d.h new file mode 100644 index 0000000000..9fe42b01ae --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_ts_config_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map.dat b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map.dat new file mode 100644 index 0000000000..f3a593326e --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map.dat @@ -0,0 +1,54 @@ +#---------------------------------------------------------------------- +# +# pg_ts_config_map.dat +# Initial contents of the pg_ts_config_map system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_ts_config_map.dat +# +#---------------------------------------------------------------------- + +[ + +{ mapcfg => 'simple', maptokentype => '1', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '2', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '3', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '4', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '5', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '6', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '7', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '8', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '9', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '10', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '11', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '15', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '16', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '17', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '18', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '19', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '20', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '21', mapseqno => '1', + mapdict => 'simple' }, +{ mapcfg => 'simple', maptokentype => '22', mapseqno => '1', + mapdict => 'simple' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map.h new file mode 100644 index 0000000000..46aef63faa --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map.h @@ -0,0 +1,47 @@ +/*------------------------------------------------------------------------- + * + * pg_ts_config_map.h + * definition of the system catalog for text search token mappings + * (pg_ts_config_map) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_ts_config_map.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_TS_CONFIG_MAP_H +#define PG_TS_CONFIG_MAP_H + +#include "catalog/genbki.h" +#include "catalog/pg_ts_config_map_d.h" + +/* ---------------- + * pg_ts_config_map definition. cpp turns this into + * typedef struct FormData_pg_ts_config_map + * ---------------- + */ +CATALOG(pg_ts_config_map,3603,TSConfigMapRelationId) +{ + /* OID of configuration owning this entry */ + Oid mapcfg BKI_LOOKUP(pg_ts_config); + + /* token type from parser */ + int32 maptokentype; + + /* order in which to consult dictionaries */ + int32 mapseqno; + + /* dictionary to consult */ + Oid mapdict BKI_LOOKUP(pg_ts_dict); +} FormData_pg_ts_config_map; + +typedef FormData_pg_ts_config_map *Form_pg_ts_config_map; + +#endif /* PG_TS_CONFIG_MAP_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map_d.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map_d.h new file mode 100644 index 0000000000..5d32856d67 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_config_map_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_ts_config_map_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_dict.dat b/contrib/libs/postgresql/src/include/catalog/pg_ts_dict.dat new file mode 100644 index 0000000000..abeec0ccae --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_dict.dat @@ -0,0 +1,19 @@ +#---------------------------------------------------------------------- +# +# pg_ts_dict.dat +# Initial contents of the pg_ts_dict system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_ts_dict.dat +# +#---------------------------------------------------------------------- + +[ + +{ oid => '3765', + descr => 'simple dictionary: just lower case and check for stopword', + dictname => 'simple', dicttemplate => 'simple', dictinitoption => '_null_' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_dict.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_dict.h new file mode 100644 index 0000000000..38128a313f --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_dict.h @@ -0,0 +1,54 @@ +/*------------------------------------------------------------------------- + * + * pg_ts_dict.h + * definition of the "text search dictionary" system catalog (pg_ts_dict) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_ts_dict.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_TS_DICT_H +#define PG_TS_DICT_H + +#include "catalog/genbki.h" +#include "catalog/pg_ts_dict_d.h" + +/* ---------------- + * pg_ts_dict definition. cpp turns this into + * typedef struct FormData_pg_ts_dict + * ---------------- + */ +CATALOG(pg_ts_dict,3600,TSDictionaryRelationId) +{ + /* oid */ + Oid oid; + + /* dictionary name */ + NameData dictname; + + /* name space */ + Oid dictnamespace BKI_DEFAULT(PGNSP); + + /* owner */ + Oid dictowner BKI_DEFAULT(PGUID); + + /* dictionary's template */ + Oid dicttemplate BKI_LOOKUP(pg_ts_template); + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + /* options passed to dict_init() */ + text dictinitoption; +#endif +} FormData_pg_ts_dict; + +typedef FormData_pg_ts_dict *Form_pg_ts_dict; + +#endif /* PG_TS_DICT_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_dict_d.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_dict_d.h new file mode 100644 index 0000000000..131abf7c93 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_dict_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_ts_dict_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_parser.dat b/contrib/libs/postgresql/src/include/catalog/pg_ts_parser.dat new file mode 100644 index 0000000000..f23aa8c541 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_parser.dat @@ -0,0 +1,20 @@ +#---------------------------------------------------------------------- +# +# pg_ts_parser.dat +# Initial contents of the pg_ts_parser system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_ts_parser.dat +# +#---------------------------------------------------------------------- + +[ + +{ oid => '3722', descr => 'default word parser', + prsname => 'default', prsstart => 'prsd_start', prstoken => 'prsd_nexttoken', + prsend => 'prsd_end', prsheadline => 'prsd_headline', + prslextype => 'prsd_lextype' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_parser.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_parser.h new file mode 100644 index 0000000000..641c6b6cb1 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_parser.h @@ -0,0 +1,57 @@ +/*------------------------------------------------------------------------- + * + * pg_ts_parser.h + * definition of the "text search parser" system catalog (pg_ts_parser) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_ts_parser.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_TS_PARSER_H +#define PG_TS_PARSER_H + +#include "catalog/genbki.h" +#include "catalog/pg_ts_parser_d.h" + +/* ---------------- + * pg_ts_parser definition. cpp turns this into + * typedef struct FormData_pg_ts_parser + * ---------------- + */ +CATALOG(pg_ts_parser,3601,TSParserRelationId) +{ + Oid oid; /* oid */ + + /* parser's name */ + NameData prsname; + + /* name space */ + Oid prsnamespace BKI_DEFAULT(PGNSP); + + /* init parsing session */ + regproc prsstart BKI_LOOKUP(pg_proc); + + /* return next token */ + regproc prstoken BKI_LOOKUP(pg_proc); + + /* finalize parsing session */ + regproc prsend BKI_LOOKUP(pg_proc); + + /* return data for headline creation */ + regproc prsheadline BKI_LOOKUP(pg_proc); + + /* return descriptions of lexeme's types */ + regproc prslextype BKI_LOOKUP(pg_proc); +} FormData_pg_ts_parser; + +typedef FormData_pg_ts_parser *Form_pg_ts_parser; + +#endif /* PG_TS_PARSER_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_parser_d.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_parser_d.h new file mode 100644 index 0000000000..0bbdd2d357 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_parser_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_ts_parser_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_template.dat b/contrib/libs/postgresql/src/include/catalog/pg_ts_template.dat new file mode 100644 index 0000000000..297a8b38fc --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_template.dat @@ -0,0 +1,30 @@ +#---------------------------------------------------------------------- +# +# pg_ts_template.dat +# Initial contents of the pg_ts_template system catalog. +# +# Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group +# Portions Copyright (c) 1994, Regents of the University of California +# +# src/include/catalog/pg_ts_template.dat +# +#---------------------------------------------------------------------- + +[ + +{ oid => '3727', + descr => 'simple dictionary: just lower case and check for stopword', + tmplname => 'simple', tmplinit => 'dsimple_init', + tmpllexize => 'dsimple_lexize' }, +{ oid => '3730', descr => 'synonym dictionary: replace word by its synonym', + tmplname => 'synonym', tmplinit => 'dsynonym_init', + tmpllexize => 'dsynonym_lexize' }, +{ oid => '3733', descr => 'ispell dictionary', + tmplname => 'ispell', tmplinit => 'dispell_init', + tmpllexize => 'dispell_lexize' }, +{ oid => '3742', + descr => 'thesaurus dictionary: phrase by phrase substitution', + tmplname => 'thesaurus', tmplinit => 'thesaurus_init', + tmpllexize => 'thesaurus_lexize' }, + +] diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_template.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_template.h new file mode 100644 index 0000000000..f610225ba2 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_template.h @@ -0,0 +1,48 @@ +/*------------------------------------------------------------------------- + * + * pg_ts_template.h + * definition of the "text search template" system catalog (pg_ts_template) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_ts_template.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_TS_TEMPLATE_H +#define PG_TS_TEMPLATE_H + +#include "catalog/genbki.h" +#include "catalog/pg_ts_template_d.h" + +/* ---------------- + * pg_ts_template definition. cpp turns this into + * typedef struct FormData_pg_ts_template + * ---------------- + */ +CATALOG(pg_ts_template,3764,TSTemplateRelationId) +{ + Oid oid; /* oid */ + + /* template name */ + NameData tmplname; + + /* name space */ + Oid tmplnamespace BKI_DEFAULT(PGNSP); + + /* initialization method of dict (may be 0) */ + regproc tmplinit BKI_LOOKUP(pg_proc); + + /* base method of dictionary */ + regproc tmpllexize BKI_LOOKUP(pg_proc); +} FormData_pg_ts_template; + +typedef FormData_pg_ts_template *Form_pg_ts_template; + +#endif /* PG_TS_TEMPLATE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_ts_template_d.h b/contrib/libs/postgresql/src/include/catalog/pg_ts_template_d.h new file mode 100644 index 0000000000..b539cd72d8 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_ts_template_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_ts_template_d.h" /* inclink generated by yamaker */ diff --git a/ydb/library/yql/parser/pg_catalog/pg_type.dat b/contrib/libs/postgresql/src/include/catalog/pg_type.dat index e8be000835..e8be000835 100644 --- a/ydb/library/yql/parser/pg_catalog/pg_type.dat +++ b/contrib/libs/postgresql/src/include/catalog/pg_type.dat diff --git a/contrib/libs/postgresql/src/include/catalog/pg_type.h b/contrib/libs/postgresql/src/include/catalog/pg_type.h new file mode 100644 index 0000000000..ebde49dafb --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_type.h @@ -0,0 +1,373 @@ +/*------------------------------------------------------------------------- + * + * pg_type.h + * definition of the "type" system catalog (pg_type) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_type.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_TYPE_H +#define PG_TYPE_H + +#include "catalog/genbki.h" +#include "catalog/objectaddress.h" +#include "catalog/pg_type_d.h" +#include "nodes/nodes.h" + +/* ---------------- + * pg_type definition. cpp turns this into + * typedef struct FormData_pg_type + * + * Some of the values in a pg_type instance are copied into + * pg_attribute instances. Some parts of Postgres use the pg_type copy, + * while others use the pg_attribute copy, so they must match. + * See struct FormData_pg_attribute for details. + * ---------------- + */ +CATALOG(pg_type,1247,TypeRelationId) BKI_BOOTSTRAP BKI_ROWTYPE_OID(71,TypeRelation_Rowtype_Id) BKI_SCHEMA_MACRO +{ + Oid oid; /* oid */ + + /* type name */ + NameData typname; + + /* OID of namespace containing this type */ + Oid typnamespace BKI_DEFAULT(PGNSP); + + /* type owner */ + Oid typowner BKI_DEFAULT(PGUID); + + /* + * For a fixed-size type, typlen is the number of bytes we use to + * represent a value of this type, e.g. 4 for an int4. But for a + * variable-length type, typlen is negative. We use -1 to indicate a + * "varlena" type (one that has a length word), -2 to indicate a + * null-terminated C string. + */ + int16 typlen BKI_ARRAY_DEFAULT(-1); + + /* + * typbyval determines whether internal Postgres routines pass a value of + * this type by value or by reference. typbyval had better be false if + * the length is not 1, 2, or 4 (or 8 on 8-byte-Datum machines). + * Variable-length types are always passed by reference. Note that + * typbyval can be false even if the length would allow pass-by-value; for + * example, type macaddr8 is pass-by-ref even when Datum is 8 bytes. + */ + bool typbyval BKI_ARRAY_DEFAULT(f); + + /* + * typtype is 'b' for a base type, 'c' for a composite type (e.g., a + * table's rowtype), 'd' for a domain, 'e' for an enum type, 'p' for a + * pseudo-type, or 'r' for a range type. (Use the TYPTYPE macros below.) + * + * If typtype is 'c', typrelid is the OID of the class' entry in pg_class. + */ + char typtype BKI_DEFAULT(b) BKI_ARRAY_DEFAULT(b); + + /* + * typcategory and typispreferred help the parser distinguish preferred + * and non-preferred coercions. The category can be any single ASCII + * character (but not \0). The categories used for built-in types are + * identified by the TYPCATEGORY macros below. + */ + + /* arbitrary type classification */ + char typcategory BKI_ARRAY_DEFAULT(A); + + /* is type "preferred" within its category? */ + bool typispreferred BKI_DEFAULT(f) BKI_ARRAY_DEFAULT(f); + + /* + * If typisdefined is false, the entry is only a placeholder (forward + * reference). We know the type's name and owner, but not yet anything + * else about it. + */ + bool typisdefined BKI_DEFAULT(t); + + /* delimiter for arrays of this type */ + char typdelim BKI_DEFAULT(','); + + /* associated pg_class OID if a composite type, else 0 */ + Oid typrelid BKI_DEFAULT(0) BKI_ARRAY_DEFAULT(0) BKI_LOOKUP(pg_class); + + /* + * If typelem is not 0 then it identifies another row in pg_type. The + * current type can then be subscripted like an array yielding values of + * type typelem. A non-zero typelem does not guarantee this type to be a + * "real" array type; some ordinary fixed-length types can also be + * subscripted (e.g., name, point). Variable-length types can *not* be + * turned into pseudo-arrays like that. Hence, the way to determine + * whether a type is a "true" array type is if: + * + * typelem != 0 and typlen == -1. + */ + Oid typelem BKI_DEFAULT(0) BKI_LOOKUP(pg_type); + + /* + * If there is a "true" array type having this type as element type, + * typarray links to it. Zero if no associated "true" array type. + */ + Oid typarray BKI_DEFAULT(0) BKI_ARRAY_DEFAULT(0) BKI_LOOKUP(pg_type); + + /* + * I/O conversion procedures for the datatype. + */ + + /* text format (required) */ + regproc typinput BKI_ARRAY_DEFAULT(array_in) BKI_LOOKUP(pg_proc); + regproc typoutput BKI_ARRAY_DEFAULT(array_out) BKI_LOOKUP(pg_proc); + + /* binary format (optional) */ + regproc typreceive BKI_ARRAY_DEFAULT(array_recv) BKI_LOOKUP(pg_proc); + regproc typsend BKI_ARRAY_DEFAULT(array_send) BKI_LOOKUP(pg_proc); + + /* + * I/O functions for optional type modifiers. + */ + regproc typmodin BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); + regproc typmodout BKI_DEFAULT(-) BKI_LOOKUP(pg_proc); + + /* + * Custom ANALYZE procedure for the datatype (0 selects the default). + */ + regproc typanalyze BKI_DEFAULT(-) BKI_ARRAY_DEFAULT(array_typanalyze) BKI_LOOKUP(pg_proc); + + /* ---------------- + * typalign is the alignment required when storing a value of this + * type. It applies to storage on disk as well as most + * representations of the value inside Postgres. When multiple values + * are stored consecutively, such as in the representation of a + * complete row on disk, padding is inserted before a datum of this + * type so that it begins on the specified boundary. The alignment + * reference is the beginning of the first datum in the sequence. + * + * 'c' = CHAR alignment, ie no alignment needed. + * 's' = SHORT alignment (2 bytes on most machines). + * 'i' = INT alignment (4 bytes on most machines). + * 'd' = DOUBLE alignment (8 bytes on many machines, but by no means all). + * (Use the TYPALIGN macros below for these.) + * + * See include/access/tupmacs.h for the macros that compute these + * alignment requirements. Note also that we allow the nominal alignment + * to be violated when storing "packed" varlenas; the TOAST mechanism + * takes care of hiding that from most code. + * + * NOTE: for types used in system tables, it is critical that the + * size and alignment defined in pg_type agree with the way that the + * compiler will lay out the field in a struct representing a table row. + * ---------------- + */ + char typalign; + + /* ---------------- + * typstorage tells if the type is prepared for toasting and what + * the default strategy for attributes of this type should be. + * + * 'p' PLAIN type not prepared for toasting + * 'e' EXTERNAL external storage possible, don't try to compress + * 'x' EXTENDED try to compress and store external if required + * 'm' MAIN like 'x' but try to keep in main tuple + * (Use the TYPSTORAGE macros below for these.) + * + * Note that 'm' fields can also be moved out to secondary storage, + * but only as a last resort ('e' and 'x' fields are moved first). + * ---------------- + */ + char typstorage BKI_DEFAULT(p) BKI_ARRAY_DEFAULT(x); + + /* + * This flag represents a "NOT NULL" constraint against this datatype. + * + * If true, the attnotnull column for a corresponding table column using + * this datatype will always enforce the NOT NULL constraint. + * + * Used primarily for domain types. + */ + bool typnotnull BKI_DEFAULT(f); + + /* + * Domains use typbasetype to show the base (or domain) type that the + * domain is based on. Zero if the type is not a domain. + */ + Oid typbasetype BKI_DEFAULT(0); + + /* + * Domains use typtypmod to record the typmod to be applied to their base + * type (-1 if base type does not use a typmod). -1 if this type is not a + * domain. + */ + int32 typtypmod BKI_DEFAULT(-1); + + /* + * typndims is the declared number of dimensions for an array domain type + * (i.e., typbasetype is an array type). Otherwise zero. + */ + int32 typndims BKI_DEFAULT(0); + + /* + * Collation: 0 if type cannot use collations, nonzero (typically + * DEFAULT_COLLATION_OID) for collatable base types, possibly some other + * OID for domains over collatable types + */ + Oid typcollation BKI_DEFAULT(0) BKI_LOOKUP(pg_collation); + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + + /* + * If typdefaultbin is not NULL, it is the nodeToString representation of + * a default expression for the type. Currently this is only used for + * domains. + */ + pg_node_tree typdefaultbin BKI_DEFAULT(_null_) BKI_ARRAY_DEFAULT(_null_); + + /* + * typdefault is NULL if the type has no associated default value. If + * typdefaultbin is not NULL, typdefault must contain a human-readable + * version of the default expression represented by typdefaultbin. If + * typdefaultbin is NULL and typdefault is not, then typdefault is the + * external representation of the type's default value, which may be fed + * to the type's input converter to produce a constant. + */ + text typdefault BKI_DEFAULT(_null_) BKI_ARRAY_DEFAULT(_null_); + + /* + * Access permissions + */ + aclitem typacl[1] BKI_DEFAULT(_null_); +#endif +} FormData_pg_type; + +/* ---------------- + * Form_pg_type corresponds to a pointer to a row with + * the format of pg_type relation. + * ---------------- + */ +typedef FormData_pg_type *Form_pg_type; + +#ifdef EXPOSE_TO_CLIENT_CODE + +/* + * macros for values of poor-mans-enumerated-type columns + */ +#define TYPTYPE_BASE 'b' /* base type (ordinary scalar type) */ +#define TYPTYPE_COMPOSITE 'c' /* composite (e.g., table's rowtype) */ +#define TYPTYPE_DOMAIN 'd' /* domain over another type */ +#define TYPTYPE_ENUM 'e' /* enumerated type */ +#define TYPTYPE_PSEUDO 'p' /* pseudo-type */ +#define TYPTYPE_RANGE 'r' /* range type */ + +#define TYPCATEGORY_INVALID '\0' /* not an allowed category */ +#define TYPCATEGORY_ARRAY 'A' +#define TYPCATEGORY_BOOLEAN 'B' +#define TYPCATEGORY_COMPOSITE 'C' +#define TYPCATEGORY_DATETIME 'D' +#define TYPCATEGORY_ENUM 'E' +#define TYPCATEGORY_GEOMETRIC 'G' +#define TYPCATEGORY_NETWORK 'I' /* think INET */ +#define TYPCATEGORY_NUMERIC 'N' +#define TYPCATEGORY_PSEUDOTYPE 'P' +#define TYPCATEGORY_RANGE 'R' +#define TYPCATEGORY_STRING 'S' +#define TYPCATEGORY_TIMESPAN 'T' +#define TYPCATEGORY_USER 'U' +#define TYPCATEGORY_BITSTRING 'V' /* er ... "varbit"? */ +#define TYPCATEGORY_UNKNOWN 'X' + +#define TYPALIGN_CHAR 'c' /* char alignment (i.e. unaligned) */ +#define TYPALIGN_SHORT 's' /* short alignment (typically 2 bytes) */ +#define TYPALIGN_INT 'i' /* int alignment (typically 4 bytes) */ +#define TYPALIGN_DOUBLE 'd' /* double alignment (often 8 bytes) */ + +#define TYPSTORAGE_PLAIN 'p' /* type not prepared for toasting */ +#define TYPSTORAGE_EXTERNAL 'e' /* toastable, don't try to compress */ +#define TYPSTORAGE_EXTENDED 'x' /* fully toastable */ +#define TYPSTORAGE_MAIN 'm' /* like 'x' but try to store inline */ + +/* Is a type OID a polymorphic pseudotype? (Beware of multiple evaluation) */ +#define IsPolymorphicType(typid) \ + (IsPolymorphicTypeFamily1(typid) || \ + IsPolymorphicTypeFamily2(typid)) + +/* Code not part of polymorphic type resolution should not use these macros: */ +#define IsPolymorphicTypeFamily1(typid) \ + ((typid) == ANYELEMENTOID || \ + (typid) == ANYARRAYOID || \ + (typid) == ANYNONARRAYOID || \ + (typid) == ANYENUMOID || \ + (typid) == ANYRANGEOID) + +#define IsPolymorphicTypeFamily2(typid) \ + ((typid) == ANYCOMPATIBLEOID || \ + (typid) == ANYCOMPATIBLEARRAYOID || \ + (typid) == ANYCOMPATIBLENONARRAYOID || \ + (typid) == ANYCOMPATIBLERANGEOID) + +#endif /* EXPOSE_TO_CLIENT_CODE */ + + +extern ObjectAddress TypeShellMake(const char *typeName, + Oid typeNamespace, + Oid ownerId); + +extern ObjectAddress TypeCreate(Oid newTypeOid, + const char *typeName, + Oid typeNamespace, + Oid relationOid, + char relationKind, + Oid ownerId, + int16 internalSize, + char typeType, + char typeCategory, + bool typePreferred, + char typDelim, + Oid inputProcedure, + Oid outputProcedure, + Oid receiveProcedure, + Oid sendProcedure, + Oid typmodinProcedure, + Oid typmodoutProcedure, + Oid analyzeProcedure, + Oid elementType, + bool isImplicitArray, + Oid arrayType, + Oid baseType, + const char *defaultTypeValue, + char *defaultTypeBin, + bool passedByValue, + char alignment, + char storage, + int32 typeMod, + int32 typNDims, + bool typeNotNull, + Oid typeCollation); + +extern void GenerateTypeDependencies(HeapTuple typeTuple, + Relation typeCatalog, + Node *defaultExpr, + void *typacl, + char relationKind, /* only for relation + * rowtypes */ + bool isImplicitArray, + bool isDependentType, + bool makeExtensionDep, + bool rebuild); + +extern void RenameTypeInternal(Oid typeOid, const char *newTypeName, + Oid typeNamespace); + +extern char *makeArrayTypeName(const char *typeName, Oid typeNamespace); + +extern bool moveArrayTypeName(Oid typeOid, const char *typeName, + Oid typeNamespace); + +#endif /* PG_TYPE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_type_d.h b/contrib/libs/postgresql/src/include/catalog/pg_type_d.h new file mode 100644 index 0000000000..681ec78b84 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_type_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_type_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_user_mapping.h b/contrib/libs/postgresql/src/include/catalog/pg_user_mapping.h new file mode 100644 index 0000000000..f5ccdb857a --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_user_mapping.h @@ -0,0 +1,48 @@ +/*------------------------------------------------------------------------- + * + * pg_user_mapping.h + * definition of the "user mapping" system catalog (pg_user_mapping) + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/pg_user_mapping.h + * + * NOTES + * The Catalog.pm module reads this file and derives schema + * information. + * + *------------------------------------------------------------------------- + */ +#ifndef PG_USER_MAPPING_H +#define PG_USER_MAPPING_H + +#include "catalog/genbki.h" +#include "catalog/pg_user_mapping_d.h" + +/* ---------------- + * pg_user_mapping definition. cpp turns this into + * typedef struct FormData_pg_user_mapping + * ---------------- + */ +CATALOG(pg_user_mapping,1418,UserMappingRelationId) +{ + Oid oid; /* oid */ + + Oid umuser; /* Id of the user, InvalidOid if PUBLIC is + * wanted */ + Oid umserver; /* server of this mapping */ + +#ifdef CATALOG_VARLEN /* variable-length fields start here */ + text umoptions[1]; /* user mapping options */ +#endif +} FormData_pg_user_mapping; + +/* ---------------- + * Form_pg_user_mapping corresponds to a pointer to a tuple with + * the format of pg_user_mapping relation. + * ---------------- + */ +typedef FormData_pg_user_mapping *Form_pg_user_mapping; + +#endif /* PG_USER_MAPPING_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/pg_user_mapping_d.h b/contrib/libs/postgresql/src/include/catalog/pg_user_mapping_d.h new file mode 100644 index 0000000000..0f3c9a413f --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/pg_user_mapping_d.h @@ -0,0 +1 @@ +#include "../../backend/catalog/pg_user_mapping_d.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/schemapg.h b/contrib/libs/postgresql/src/include/catalog/schemapg.h new file mode 100644 index 0000000000..7943644b9b --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/schemapg.h @@ -0,0 +1 @@ +#include "../../backend/catalog/schemapg.h" /* inclink generated by yamaker */ diff --git a/contrib/libs/postgresql/src/include/catalog/storage.h b/contrib/libs/postgresql/src/include/catalog/storage.h new file mode 100644 index 0000000000..30c38e0ca6 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/storage.h @@ -0,0 +1,48 @@ +/*------------------------------------------------------------------------- + * + * storage.h + * prototypes for functions in backend/catalog/storage.c + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/storage.h + * + *------------------------------------------------------------------------- + */ +#ifndef STORAGE_H +#define STORAGE_H + +#include "storage/block.h" +#include "storage/relfilenode.h" +#include "storage/smgr.h" +#include "utils/relcache.h" + +/* GUC variables */ +extern int wal_skip_threshold; + +extern SMgrRelation RelationCreateStorage(RelFileNode rnode, char relpersistence); +extern void RelationDropStorage(Relation rel); +extern void RelationPreserveStorage(RelFileNode rnode, bool atCommit); +extern void RelationPreTruncate(Relation rel); +extern void RelationTruncate(Relation rel, BlockNumber nblocks); +extern void RelationCopyStorage(SMgrRelation src, SMgrRelation dst, + ForkNumber forkNum, char relpersistence); +extern bool RelFileNodeSkippingWAL(RelFileNode rnode); +extern Size EstimatePendingSyncsSpace(void); +extern void SerializePendingSyncs(Size maxSize, char *startAddress); +extern void RestorePendingSyncs(char *startAddress); + +/* + * These functions used to be in storage/smgr/smgr.c, which explains the + * naming + */ +extern void smgrDoPendingDeletes(bool isCommit); +extern void smgrDoPendingSyncs(bool isCommit, bool isParallelWorker); +extern int smgrGetPendingDeletes(bool forCommit, RelFileNode **ptr); +extern void AtSubCommit_smgr(void); +extern void AtSubAbort_smgr(void); +extern void PostPrepare_smgr(void); + +#endif /* STORAGE_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/storage_xlog.h b/contrib/libs/postgresql/src/include/catalog/storage_xlog.h new file mode 100644 index 0000000000..7b21cab2e0 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/storage_xlog.h @@ -0,0 +1,59 @@ +/*------------------------------------------------------------------------- + * + * storage_xlog.h + * prototypes for XLog support for backend/catalog/storage.c + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/storage_xlog.h + * + *------------------------------------------------------------------------- + */ +#ifndef STORAGE_XLOG_H +#define STORAGE_XLOG_H + +#include "access/xlogreader.h" +#include "lib/stringinfo.h" +#include "storage/block.h" +#include "storage/relfilenode.h" + +/* + * Declarations for smgr-related XLOG records + * + * Note: we log file creation and truncation here, but logging of deletion + * actions is handled by xact.c, because it is part of transaction commit. + */ + +/* XLOG gives us high 4 bits */ +#define XLOG_SMGR_CREATE 0x10 +#define XLOG_SMGR_TRUNCATE 0x20 + +typedef struct xl_smgr_create +{ + RelFileNode rnode; + ForkNumber forkNum; +} xl_smgr_create; + +/* flags for xl_smgr_truncate */ +#define SMGR_TRUNCATE_HEAP 0x0001 +#define SMGR_TRUNCATE_VM 0x0002 +#define SMGR_TRUNCATE_FSM 0x0004 +#define SMGR_TRUNCATE_ALL \ + (SMGR_TRUNCATE_HEAP|SMGR_TRUNCATE_VM|SMGR_TRUNCATE_FSM) + +typedef struct xl_smgr_truncate +{ + BlockNumber blkno; + RelFileNode rnode; + int flags; +} xl_smgr_truncate; + +extern void log_smgrcreate(const RelFileNode *rnode, ForkNumber forkNum); + +extern void smgr_redo(XLogReaderState *record); +extern void smgr_desc(StringInfo buf, XLogReaderState *record); +extern const char *smgr_identify(uint8 info); + +#endif /* STORAGE_XLOG_H */ diff --git a/contrib/libs/postgresql/src/include/catalog/toasting.h b/contrib/libs/postgresql/src/include/catalog/toasting.h new file mode 100644 index 0000000000..bde14263a1 --- /dev/null +++ b/contrib/libs/postgresql/src/include/catalog/toasting.h @@ -0,0 +1,105 @@ +/*------------------------------------------------------------------------- + * + * toasting.h + * This file provides some definitions to support creation of toast tables + * + * Caution: all #define's with numeric values in this file had better be + * object OIDs, else renumber_oids.pl might change them inappropriately. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/catalog/toasting.h + * + *------------------------------------------------------------------------- + */ +#ifndef TOASTING_H +#define TOASTING_H + +#include "storage/lock.h" + +/* + * toasting.c prototypes + */ +extern void NewRelationCreateToastTable(Oid relOid, Datum reloptions); +extern void NewHeapCreateToastTable(Oid relOid, Datum reloptions, + LOCKMODE lockmode, Oid OIDOldToast); +extern void AlterTableCreateToastTable(Oid relOid, Datum reloptions, + LOCKMODE lockmode); +extern void BootstrapToastTable(char *relName, + Oid toastOid, Oid toastIndexOid); + + +/* + * This macro is just to keep the C compiler from spitting up on the + * upcoming commands for Catalog.pm. + */ +#define DECLARE_TOAST(name,toastoid,indexoid) extern int no_such_variable + + +/* + * What follows are lines processed by genbki.pl to create the statements + * the bootstrap parser will turn into BootstrapToastTable commands. + * Each line specifies the system catalog that needs a toast table, + * the OID to assign to the toast table, and the OID to assign to the + * toast table's index. The reason we hard-wire these OIDs is that we + * need stable OIDs for shared relations, and that includes toast tables + * of shared relations. + */ + +/* normal catalogs */ +DECLARE_TOAST(pg_aggregate, 4159, 4160); +DECLARE_TOAST(pg_attrdef, 2830, 2831); +DECLARE_TOAST(pg_collation, 4161, 4162); +DECLARE_TOAST(pg_constraint, 2832, 2833); +DECLARE_TOAST(pg_default_acl, 4143, 4144); +DECLARE_TOAST(pg_description, 2834, 2835); +DECLARE_TOAST(pg_event_trigger, 4145, 4146); +DECLARE_TOAST(pg_extension, 4147, 4148); +DECLARE_TOAST(pg_foreign_data_wrapper, 4149, 4150); +DECLARE_TOAST(pg_foreign_server, 4151, 4152); +DECLARE_TOAST(pg_foreign_table, 4153, 4154); +DECLARE_TOAST(pg_init_privs, 4155, 4156); +DECLARE_TOAST(pg_language, 4157, 4158); +DECLARE_TOAST(pg_namespace, 4163, 4164); +DECLARE_TOAST(pg_partitioned_table, 4165, 4166); +DECLARE_TOAST(pg_policy, 4167, 4168); +DECLARE_TOAST(pg_proc, 2836, 2837); +DECLARE_TOAST(pg_rewrite, 2838, 2839); +DECLARE_TOAST(pg_seclabel, 3598, 3599); +DECLARE_TOAST(pg_statistic, 2840, 2841); +DECLARE_TOAST(pg_statistic_ext, 3439, 3440); +DECLARE_TOAST(pg_statistic_ext_data, 3430, 3431); +DECLARE_TOAST(pg_trigger, 2336, 2337); +DECLARE_TOAST(pg_ts_dict, 4169, 4170); +DECLARE_TOAST(pg_type, 4171, 4172); +DECLARE_TOAST(pg_user_mapping, 4173, 4174); + +/* shared catalogs */ +DECLARE_TOAST(pg_authid, 4175, 4176); +#define PgAuthidToastTable 4175 +#define PgAuthidToastIndex 4176 +DECLARE_TOAST(pg_database, 4177, 4178); +#define PgDatabaseToastTable 4177 +#define PgDatabaseToastIndex 4178 +DECLARE_TOAST(pg_db_role_setting, 2966, 2967); +#define PgDbRoleSettingToastTable 2966 +#define PgDbRoleSettingToastIndex 2967 +DECLARE_TOAST(pg_replication_origin, 4181, 4182); +#define PgReplicationOriginToastTable 4181 +#define PgReplicationOriginToastIndex 4182 +DECLARE_TOAST(pg_shdescription, 2846, 2847); +#define PgShdescriptionToastTable 2846 +#define PgShdescriptionToastIndex 2847 +DECLARE_TOAST(pg_shseclabel, 4060, 4061); +#define PgShseclabelToastTable 4060 +#define PgShseclabelToastIndex 4061 +DECLARE_TOAST(pg_subscription, 4183, 4184); +#define PgSubscriptionToastTable 4183 +#define PgSubscriptionToastIndex 4184 +DECLARE_TOAST(pg_tablespace, 4185, 4186); +#define PgTablespaceToastTable 4185 +#define PgTablespaceToastIndex 4186 + +#endif /* TOASTING_H */ diff --git a/contrib/libs/postgresql/src/include/fmgr.h b/contrib/libs/postgresql/src/include/fmgr.h new file mode 100644 index 0000000000..d349510b7c --- /dev/null +++ b/contrib/libs/postgresql/src/include/fmgr.h @@ -0,0 +1,775 @@ +/*------------------------------------------------------------------------- + * + * fmgr.h + * Definitions for the Postgres function manager and function-call + * interface. + * + * This file must be included by all Postgres modules that either define + * or call fmgr-callable functions. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/fmgr.h + * + *------------------------------------------------------------------------- + */ +#ifndef FMGR_H +#define FMGR_H + +/* We don't want to include primnodes.h here, so make some stub references */ +typedef struct Node *fmNodePtr; +typedef struct Aggref *fmAggrefPtr; + +/* Likewise, avoid including execnodes.h here */ +typedef void (*fmExprContextCallbackFunction) (Datum arg); + +/* Likewise, avoid including stringinfo.h here */ +typedef struct StringInfoData *fmStringInfo; + + +/* + * All functions that can be called directly by fmgr must have this signature. + * (Other functions can be called by using a handler that does have this + * signature.) + */ + +typedef struct FunctionCallInfoBaseData *FunctionCallInfo; + +typedef Datum (*PGFunction) (FunctionCallInfo fcinfo); + +/* + * This struct holds the system-catalog information that must be looked up + * before a function can be called through fmgr. If the same function is + * to be called multiple times, the lookup need be done only once and the + * info struct saved for re-use. + * + * Note that fn_expr really is parse-time-determined information about the + * arguments, rather than about the function itself. But it's convenient to + * store it here rather than in FunctionCallInfoBaseData, where it might more + * logically belong. + * + * fn_extra is available for use by the called function; all other fields + * should be treated as read-only after the struct is created. + */ +typedef struct FmgrInfo +{ + PGFunction fn_addr; /* pointer to function or handler to be called */ + Oid fn_oid; /* OID of function (NOT of handler, if any) */ + short fn_nargs; /* number of input args (0..FUNC_MAX_ARGS) */ + bool fn_strict; /* function is "strict" (NULL in => NULL out) */ + bool fn_retset; /* function returns a set */ + unsigned char fn_stats; /* collect stats if track_functions > this */ + void *fn_extra; /* extra space for use by handler */ + MemoryContext fn_mcxt; /* memory context to store fn_extra in */ + fmNodePtr fn_expr; /* expression parse tree for call, or NULL */ +} FmgrInfo; + +/* + * This struct is the data actually passed to an fmgr-called function. + * + * The called function is expected to set isnull, and possibly resultinfo or + * fields in whatever resultinfo points to. It should not change any other + * fields. (In particular, scribbling on the argument arrays is a bad idea, + * since some callers assume they can re-call with the same arguments.) + * + * Note that enough space for arguments needs to be provided, either by using + * SizeForFunctionCallInfo() in dynamic allocations, or by using + * LOCAL_FCINFO() for on-stack allocations. + * + * This struct is named *BaseData, rather than *Data, to break pre v12 code + * that allocated FunctionCallInfoData itself, as it'd often silently break + * old code due to no space for arguments being provided. + */ +typedef struct FunctionCallInfoBaseData +{ + FmgrInfo *flinfo; /* ptr to lookup info used for this call */ + fmNodePtr context; /* pass info about context of call */ + fmNodePtr resultinfo; /* pass or return extra info about result */ + Oid fncollation; /* collation for function to use */ +#define FIELDNO_FUNCTIONCALLINFODATA_ISNULL 4 + bool isnull; /* function must set true if result is NULL */ + short nargs; /* # arguments actually passed */ +#define FIELDNO_FUNCTIONCALLINFODATA_ARGS 6 + NullableDatum args[FLEXIBLE_ARRAY_MEMBER]; +} FunctionCallInfoBaseData; + +/* + * Space needed for a FunctionCallInfoBaseData struct with sufficient space + * for `nargs` arguments. + */ +#define SizeForFunctionCallInfo(nargs) \ + (offsetof(FunctionCallInfoBaseData, args) + \ + sizeof(NullableDatum) * (nargs)) + +/* + * This macro ensures that `name` points to a stack-allocated + * FunctionCallInfoBaseData struct with sufficient space for `nargs` arguments. + */ +#define LOCAL_FCINFO(name, nargs) \ + /* use union with FunctionCallInfoBaseData to guarantee alignment */ \ + union \ + { \ + FunctionCallInfoBaseData fcinfo; \ + /* ensure enough space for nargs args is available */ \ + char fcinfo_data[SizeForFunctionCallInfo(nargs)]; \ + } name##data; \ + FunctionCallInfo name = &name##data.fcinfo + +/* + * This routine fills a FmgrInfo struct, given the OID + * of the function to be called. + */ +extern void fmgr_info(Oid functionId, FmgrInfo *finfo); + +/* + * Same, when the FmgrInfo struct is in a memory context longer-lived than + * CurrentMemoryContext. The specified context will be set as fn_mcxt + * and used to hold all subsidiary data of finfo. + */ +extern void fmgr_info_cxt(Oid functionId, FmgrInfo *finfo, + MemoryContext mcxt); + +/* Convenience macro for setting the fn_expr field */ +#define fmgr_info_set_expr(expr, finfo) \ + ((finfo)->fn_expr = (expr)) + +/* + * Copy an FmgrInfo struct + */ +extern void fmgr_info_copy(FmgrInfo *dstinfo, FmgrInfo *srcinfo, + MemoryContext destcxt); + +extern void fmgr_symbol(Oid functionId, char **mod, char **fn); + +/* + * This macro initializes all the fields of a FunctionCallInfoBaseData except + * for the args[] array. + */ +#define InitFunctionCallInfoData(Fcinfo, Flinfo, Nargs, Collation, Context, Resultinfo) \ + do { \ + (Fcinfo).flinfo = (Flinfo); \ + (Fcinfo).context = (Context); \ + (Fcinfo).resultinfo = (Resultinfo); \ + (Fcinfo).fncollation = (Collation); \ + (Fcinfo).isnull = false; \ + (Fcinfo).nargs = (Nargs); \ + } while (0) + +/* + * This macro invokes a function given a filled-in FunctionCallInfoBaseData + * struct. The macro result is the returned Datum --- but note that + * caller must still check fcinfo->isnull! Also, if function is strict, + * it is caller's responsibility to verify that no null arguments are present + * before calling. + * + * Some code performs multiple calls without redoing InitFunctionCallInfoData, + * possibly altering the argument values. This is okay, but be sure to reset + * the fcinfo->isnull flag before each call, since callees are permitted to + * assume that starts out false. + */ +#define FunctionCallInvoke(fcinfo) ((* (fcinfo)->flinfo->fn_addr) (fcinfo)) + + +/*------------------------------------------------------------------------- + * Support macros to ease writing fmgr-compatible functions + * + * A C-coded fmgr-compatible function should be declared as + * + * Datum + * function_name(PG_FUNCTION_ARGS) + * { + * ... + * } + * + * It should access its arguments using appropriate PG_GETARG_xxx macros + * and should return its result using PG_RETURN_xxx. + * + *------------------------------------------------------------------------- + */ + +/* Standard parameter list for fmgr-compatible functions */ +#define PG_FUNCTION_ARGS FunctionCallInfo fcinfo + +/* + * Get collation function should use. + */ +#define PG_GET_COLLATION() (fcinfo->fncollation) + +/* + * Get number of arguments passed to function. + */ +#define PG_NARGS() (fcinfo->nargs) + +/* + * If function is not marked "proisstrict" in pg_proc, it must check for + * null arguments using this macro. Do not try to GETARG a null argument! + */ +#define PG_ARGISNULL(n) (fcinfo->args[n].isnull) + +/* + * Support for fetching detoasted copies of toastable datatypes (all of + * which are varlena types). pg_detoast_datum() gives you either the input + * datum (if not toasted) or a detoasted copy allocated with palloc(). + * pg_detoast_datum_copy() always gives you a palloc'd copy --- use it + * if you need a modifiable copy of the input. Caller is expected to have + * checked for null inputs first, if necessary. + * + * pg_detoast_datum_packed() will return packed (1-byte header) datums + * unmodified. It will still expand an externally toasted or compressed datum. + * The resulting datum can be accessed using VARSIZE_ANY() and VARDATA_ANY() + * (beware of multiple evaluations in those macros!) + * + * In consumers oblivious to data alignment, call PG_DETOAST_DATUM_PACKED(), + * VARDATA_ANY(), VARSIZE_ANY() and VARSIZE_ANY_EXHDR(). Elsewhere, call + * PG_DETOAST_DATUM(), VARDATA() and VARSIZE(). Directly fetching an int16, + * int32 or wider field in the struct representing the datum layout requires + * aligned data. memcpy() is alignment-oblivious, as are most operations on + * datatypes, such as text, whose layout struct contains only char fields. + * + * Note: it'd be nice if these could be macros, but I see no way to do that + * without evaluating the arguments multiple times, which is NOT acceptable. + */ +extern struct varlena *pg_detoast_datum(struct varlena *datum); +extern struct varlena *pg_detoast_datum_copy(struct varlena *datum); +extern struct varlena *pg_detoast_datum_slice(struct varlena *datum, + int32 first, int32 count); +extern struct varlena *pg_detoast_datum_packed(struct varlena *datum); + +#define PG_DETOAST_DATUM(datum) \ + pg_detoast_datum((struct varlena *) DatumGetPointer(datum)) +#define PG_DETOAST_DATUM_COPY(datum) \ + pg_detoast_datum_copy((struct varlena *) DatumGetPointer(datum)) +#define PG_DETOAST_DATUM_SLICE(datum,f,c) \ + pg_detoast_datum_slice((struct varlena *) DatumGetPointer(datum), \ + (int32) (f), (int32) (c)) +/* WARNING -- unaligned pointer */ +#define PG_DETOAST_DATUM_PACKED(datum) \ + pg_detoast_datum_packed((struct varlena *) DatumGetPointer(datum)) + +/* + * Support for cleaning up detoasted copies of inputs. This must only + * be used for pass-by-ref datatypes, and normally would only be used + * for toastable types. If the given pointer is different from the + * original argument, assume it's a palloc'd detoasted copy, and pfree it. + * NOTE: most functions on toastable types do not have to worry about this, + * but we currently require that support functions for indexes not leak + * memory. + */ +#define PG_FREE_IF_COPY(ptr,n) \ + do { \ + if ((Pointer) (ptr) != PG_GETARG_POINTER(n)) \ + pfree(ptr); \ + } while (0) + +/* Macros for fetching arguments of standard types */ + +#define PG_GETARG_DATUM(n) (fcinfo->args[n].value) +#define PG_GETARG_INT32(n) DatumGetInt32(PG_GETARG_DATUM(n)) +#define PG_GETARG_UINT32(n) DatumGetUInt32(PG_GETARG_DATUM(n)) +#define PG_GETARG_INT16(n) DatumGetInt16(PG_GETARG_DATUM(n)) +#define PG_GETARG_UINT16(n) DatumGetUInt16(PG_GETARG_DATUM(n)) +#define PG_GETARG_CHAR(n) DatumGetChar(PG_GETARG_DATUM(n)) +#define PG_GETARG_BOOL(n) DatumGetBool(PG_GETARG_DATUM(n)) +#define PG_GETARG_OID(n) DatumGetObjectId(PG_GETARG_DATUM(n)) +#define PG_GETARG_POINTER(n) DatumGetPointer(PG_GETARG_DATUM(n)) +#define PG_GETARG_CSTRING(n) DatumGetCString(PG_GETARG_DATUM(n)) +#define PG_GETARG_NAME(n) DatumGetName(PG_GETARG_DATUM(n)) +/* these macros hide the pass-by-reference-ness of the datatype: */ +#define PG_GETARG_FLOAT4(n) DatumGetFloat4(PG_GETARG_DATUM(n)) +#define PG_GETARG_FLOAT8(n) DatumGetFloat8(PG_GETARG_DATUM(n)) +#define PG_GETARG_INT64(n) DatumGetInt64(PG_GETARG_DATUM(n)) +/* use this if you want the raw, possibly-toasted input datum: */ +#define PG_GETARG_RAW_VARLENA_P(n) ((struct varlena *) PG_GETARG_POINTER(n)) +/* use this if you want the input datum de-toasted: */ +#define PG_GETARG_VARLENA_P(n) PG_DETOAST_DATUM(PG_GETARG_DATUM(n)) +/* and this if you can handle 1-byte-header datums: */ +#define PG_GETARG_VARLENA_PP(n) PG_DETOAST_DATUM_PACKED(PG_GETARG_DATUM(n)) +/* DatumGetFoo macros for varlena types will typically look like this: */ +#define DatumGetByteaPP(X) ((bytea *) PG_DETOAST_DATUM_PACKED(X)) +#define DatumGetTextPP(X) ((text *) PG_DETOAST_DATUM_PACKED(X)) +#define DatumGetBpCharPP(X) ((BpChar *) PG_DETOAST_DATUM_PACKED(X)) +#define DatumGetVarCharPP(X) ((VarChar *) PG_DETOAST_DATUM_PACKED(X)) +#define DatumGetHeapTupleHeader(X) ((HeapTupleHeader) PG_DETOAST_DATUM(X)) +/* And we also offer variants that return an OK-to-write copy */ +#define DatumGetByteaPCopy(X) ((bytea *) PG_DETOAST_DATUM_COPY(X)) +#define DatumGetTextPCopy(X) ((text *) PG_DETOAST_DATUM_COPY(X)) +#define DatumGetBpCharPCopy(X) ((BpChar *) PG_DETOAST_DATUM_COPY(X)) +#define DatumGetVarCharPCopy(X) ((VarChar *) PG_DETOAST_DATUM_COPY(X)) +#define DatumGetHeapTupleHeaderCopy(X) ((HeapTupleHeader) PG_DETOAST_DATUM_COPY(X)) +/* Variants which return n bytes starting at pos. m */ +#define DatumGetByteaPSlice(X,m,n) ((bytea *) PG_DETOAST_DATUM_SLICE(X,m,n)) +#define DatumGetTextPSlice(X,m,n) ((text *) PG_DETOAST_DATUM_SLICE(X,m,n)) +#define DatumGetBpCharPSlice(X,m,n) ((BpChar *) PG_DETOAST_DATUM_SLICE(X,m,n)) +#define DatumGetVarCharPSlice(X,m,n) ((VarChar *) PG_DETOAST_DATUM_SLICE(X,m,n)) +/* GETARG macros for varlena types will typically look like this: */ +#define PG_GETARG_BYTEA_PP(n) DatumGetByteaPP(PG_GETARG_DATUM(n)) +#define PG_GETARG_TEXT_PP(n) DatumGetTextPP(PG_GETARG_DATUM(n)) +#define PG_GETARG_BPCHAR_PP(n) DatumGetBpCharPP(PG_GETARG_DATUM(n)) +#define PG_GETARG_VARCHAR_PP(n) DatumGetVarCharPP(PG_GETARG_DATUM(n)) +#define PG_GETARG_HEAPTUPLEHEADER(n) DatumGetHeapTupleHeader(PG_GETARG_DATUM(n)) +/* And we also offer variants that return an OK-to-write copy */ +#define PG_GETARG_BYTEA_P_COPY(n) DatumGetByteaPCopy(PG_GETARG_DATUM(n)) +#define PG_GETARG_TEXT_P_COPY(n) DatumGetTextPCopy(PG_GETARG_DATUM(n)) +#define PG_GETARG_BPCHAR_P_COPY(n) DatumGetBpCharPCopy(PG_GETARG_DATUM(n)) +#define PG_GETARG_VARCHAR_P_COPY(n) DatumGetVarCharPCopy(PG_GETARG_DATUM(n)) +#define PG_GETARG_HEAPTUPLEHEADER_COPY(n) DatumGetHeapTupleHeaderCopy(PG_GETARG_DATUM(n)) +/* And a b-byte slice from position a -also OK to write */ +#define PG_GETARG_BYTEA_P_SLICE(n,a,b) DatumGetByteaPSlice(PG_GETARG_DATUM(n),a,b) +#define PG_GETARG_TEXT_P_SLICE(n,a,b) DatumGetTextPSlice(PG_GETARG_DATUM(n),a,b) +#define PG_GETARG_BPCHAR_P_SLICE(n,a,b) DatumGetBpCharPSlice(PG_GETARG_DATUM(n),a,b) +#define PG_GETARG_VARCHAR_P_SLICE(n,a,b) DatumGetVarCharPSlice(PG_GETARG_DATUM(n),a,b) +/* + * Obsolescent variants that guarantee INT alignment for the return value. + * Few operations on these particular types need alignment, mainly operations + * that cast the VARDATA pointer to a type like int16[]. Most code should use + * the ...PP(X) counterpart. Nonetheless, these appear frequently in code + * predating the PostgreSQL 8.3 introduction of the ...PP(X) variants. + */ +#define DatumGetByteaP(X) ((bytea *) PG_DETOAST_DATUM(X)) +#define DatumGetTextP(X) ((text *) PG_DETOAST_DATUM(X)) +#define DatumGetBpCharP(X) ((BpChar *) PG_DETOAST_DATUM(X)) +#define DatumGetVarCharP(X) ((VarChar *) PG_DETOAST_DATUM(X)) +#define PG_GETARG_BYTEA_P(n) DatumGetByteaP(PG_GETARG_DATUM(n)) +#define PG_GETARG_TEXT_P(n) DatumGetTextP(PG_GETARG_DATUM(n)) +#define PG_GETARG_BPCHAR_P(n) DatumGetBpCharP(PG_GETARG_DATUM(n)) +#define PG_GETARG_VARCHAR_P(n) DatumGetVarCharP(PG_GETARG_DATUM(n)) + +/* To access options from opclass support functions use this: */ +#define PG_HAS_OPCLASS_OPTIONS() has_fn_opclass_options(fcinfo->flinfo) +#define PG_GET_OPCLASS_OPTIONS() get_fn_opclass_options(fcinfo->flinfo) + +/* To return a NULL do this: */ +#define PG_RETURN_NULL() \ + do { fcinfo->isnull = true; return (Datum) 0; } while (0) + +/* A few internal functions return void (which is not the same as NULL!) */ +#define PG_RETURN_VOID() return (Datum) 0 + +/* Macros for returning results of standard types */ + +#define PG_RETURN_DATUM(x) return (x) +#define PG_RETURN_INT32(x) return Int32GetDatum(x) +#define PG_RETURN_UINT32(x) return UInt32GetDatum(x) +#define PG_RETURN_INT16(x) return Int16GetDatum(x) +#define PG_RETURN_UINT16(x) return UInt16GetDatum(x) +#define PG_RETURN_CHAR(x) return CharGetDatum(x) +#define PG_RETURN_BOOL(x) return BoolGetDatum(x) +#define PG_RETURN_OID(x) return ObjectIdGetDatum(x) +#define PG_RETURN_POINTER(x) return PointerGetDatum(x) +#define PG_RETURN_CSTRING(x) return CStringGetDatum(x) +#define PG_RETURN_NAME(x) return NameGetDatum(x) +/* these macros hide the pass-by-reference-ness of the datatype: */ +#define PG_RETURN_FLOAT4(x) return Float4GetDatum(x) +#define PG_RETURN_FLOAT8(x) return Float8GetDatum(x) +#define PG_RETURN_INT64(x) return Int64GetDatum(x) +#define PG_RETURN_UINT64(x) return UInt64GetDatum(x) +/* RETURN macros for other pass-by-ref types will typically look like this: */ +#define PG_RETURN_BYTEA_P(x) PG_RETURN_POINTER(x) +#define PG_RETURN_TEXT_P(x) PG_RETURN_POINTER(x) +#define PG_RETURN_BPCHAR_P(x) PG_RETURN_POINTER(x) +#define PG_RETURN_VARCHAR_P(x) PG_RETURN_POINTER(x) +#define PG_RETURN_HEAPTUPLEHEADER(x) return HeapTupleHeaderGetDatum(x) + + +/*------------------------------------------------------------------------- + * Support for detecting call convention of dynamically-loaded functions + * + * Dynamically loaded functions currently can only use the version-1 ("new + * style") calling convention. Version-0 ("old style") is not supported + * anymore. Version 1 is the call convention defined in this header file, and + * must be accompanied by the macro call + * + * PG_FUNCTION_INFO_V1(function_name); + * + * Note that internal functions do not need this decoration since they are + * assumed to be version-1. + * + *------------------------------------------------------------------------- + */ + +typedef struct +{ + int api_version; /* specifies call convention version number */ + /* More fields may be added later, for version numbers > 1. */ +} Pg_finfo_record; + +/* Expected signature of an info function */ +typedef const Pg_finfo_record *(*PGFInfoFunction) (void); + +/* + * Macro to build an info function associated with the given function name. + * + * As a convenience, also provide an "extern" declaration for the given + * function name, so that writers of C functions need not write that too. + * + * On Windows, the function and info function must be exported. Our normal + * build processes take care of that via .DEF files or --export-all-symbols. + * Module authors using a different build process might need to manually + * declare the function PGDLLEXPORT. We do that automatically here for the + * info function, since authors shouldn't need to be explicitly aware of it. + */ +#define PG_FUNCTION_INFO_V1(funcname) \ +extern Datum funcname(PG_FUNCTION_ARGS); \ +extern PGDLLEXPORT const Pg_finfo_record * CppConcat(pg_finfo_,funcname)(void); \ +const Pg_finfo_record * \ +CppConcat(pg_finfo_,funcname) (void) \ +{ \ + static const Pg_finfo_record my_finfo = { 1 }; \ + return &my_finfo; \ +} \ +extern int no_such_variable + + +/*------------------------------------------------------------------------- + * Support for verifying backend compatibility of loaded modules + * + * We require dynamically-loaded modules to include the macro call + * PG_MODULE_MAGIC; + * so that we can check for obvious incompatibility, such as being compiled + * for a different major PostgreSQL version. + * + * To compile with versions of PostgreSQL that do not support this, + * you may put an #ifdef/#endif test around it. Note that in a multiple- + * source-file module, the macro call should only appear once. + * + * The specific items included in the magic block are intended to be ones that + * are custom-configurable and especially likely to break dynamically loaded + * modules if they were compiled with other values. Also, the length field + * can be used to detect definition changes. + * + * Note: we compare magic blocks with memcmp(), so there had better not be + * any alignment pad bytes in them. + * + * Note: when changing the contents of magic blocks, be sure to adjust the + * incompatible_module_error() function in dfmgr.c. + *------------------------------------------------------------------------- + */ + +/* Definition of the magic block structure */ +typedef struct +{ + int len; /* sizeof(this struct) */ + int version; /* PostgreSQL major version */ + int funcmaxargs; /* FUNC_MAX_ARGS */ + int indexmaxkeys; /* INDEX_MAX_KEYS */ + int namedatalen; /* NAMEDATALEN */ + int float8byval; /* FLOAT8PASSBYVAL */ +} Pg_magic_struct; + +/* The actual data block contents */ +#define PG_MODULE_MAGIC_DATA \ +{ \ + sizeof(Pg_magic_struct), \ + PG_VERSION_NUM / 100, \ + FUNC_MAX_ARGS, \ + INDEX_MAX_KEYS, \ + NAMEDATALEN, \ + FLOAT8PASSBYVAL \ +} + +/* + * Declare the module magic function. It needs to be a function as the dlsym + * in the backend is only guaranteed to work on functions, not data + */ +typedef const Pg_magic_struct *(*PGModuleMagicFunction) (void); + +#define PG_MAGIC_FUNCTION_NAME Pg_magic_func +#define PG_MAGIC_FUNCTION_NAME_STRING "Pg_magic_func" + +#define PG_MODULE_MAGIC \ +extern PGDLLEXPORT const Pg_magic_struct *PG_MAGIC_FUNCTION_NAME(void); \ +const Pg_magic_struct * \ +PG_MAGIC_FUNCTION_NAME(void) \ +{ \ + static const Pg_magic_struct Pg_magic_data = PG_MODULE_MAGIC_DATA; \ + return &Pg_magic_data; \ +} \ +extern int no_such_variable + + +/*------------------------------------------------------------------------- + * Support routines and macros for callers of fmgr-compatible functions + *------------------------------------------------------------------------- + */ + +/* These are for invocation of a specifically named function with a + * directly-computed parameter list. Note that neither arguments nor result + * are allowed to be NULL. Also, the function cannot be one that needs to + * look at FmgrInfo, since there won't be any. + */ +extern Datum DirectFunctionCall1Coll(PGFunction func, Oid collation, + Datum arg1); +extern Datum DirectFunctionCall2Coll(PGFunction func, Oid collation, + Datum arg1, Datum arg2); +extern Datum DirectFunctionCall3Coll(PGFunction func, Oid collation, + Datum arg1, Datum arg2, + Datum arg3); +extern Datum DirectFunctionCall4Coll(PGFunction func, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4); +extern Datum DirectFunctionCall5Coll(PGFunction func, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5); +extern Datum DirectFunctionCall6Coll(PGFunction func, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6); +extern Datum DirectFunctionCall7Coll(PGFunction func, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7); +extern Datum DirectFunctionCall8Coll(PGFunction func, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8); +extern Datum DirectFunctionCall9Coll(PGFunction func, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8, + Datum arg9); + +/* + * These functions work like the DirectFunctionCall functions except that + * they use the flinfo parameter to initialise the fcinfo for the call. + * It's recommended that the callee only use the fn_extra and fn_mcxt + * fields, as other fields will typically describe the calling function + * not the callee. Conversely, the calling function should not have + * used fn_extra, unless its use is known to be compatible with the callee's. + */ +extern Datum CallerFInfoFunctionCall1(PGFunction func, FmgrInfo *flinfo, + Oid collation, Datum arg1); +extern Datum CallerFInfoFunctionCall2(PGFunction func, FmgrInfo *flinfo, + Oid collation, Datum arg1, Datum arg2); + +/* These are for invocation of a previously-looked-up function with a + * directly-computed parameter list. Note that neither arguments nor result + * are allowed to be NULL. + */ +extern Datum FunctionCall0Coll(FmgrInfo *flinfo, Oid collation); +extern Datum FunctionCall1Coll(FmgrInfo *flinfo, Oid collation, + Datum arg1); +extern Datum FunctionCall2Coll(FmgrInfo *flinfo, Oid collation, + Datum arg1, Datum arg2); +extern Datum FunctionCall3Coll(FmgrInfo *flinfo, Oid collation, + Datum arg1, Datum arg2, + Datum arg3); +extern Datum FunctionCall4Coll(FmgrInfo *flinfo, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4); +extern Datum FunctionCall5Coll(FmgrInfo *flinfo, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5); +extern Datum FunctionCall6Coll(FmgrInfo *flinfo, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6); +extern Datum FunctionCall7Coll(FmgrInfo *flinfo, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7); +extern Datum FunctionCall8Coll(FmgrInfo *flinfo, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8); +extern Datum FunctionCall9Coll(FmgrInfo *flinfo, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8, + Datum arg9); + +/* These are for invocation of a function identified by OID with a + * directly-computed parameter list. Note that neither arguments nor result + * are allowed to be NULL. These are essentially fmgr_info() followed by + * FunctionCallN(). If the same function is to be invoked repeatedly, do the + * fmgr_info() once and then use FunctionCallN(). + */ +extern Datum OidFunctionCall0Coll(Oid functionId, Oid collation); +extern Datum OidFunctionCall1Coll(Oid functionId, Oid collation, + Datum arg1); +extern Datum OidFunctionCall2Coll(Oid functionId, Oid collation, + Datum arg1, Datum arg2); +extern Datum OidFunctionCall3Coll(Oid functionId, Oid collation, + Datum arg1, Datum arg2, + Datum arg3); +extern Datum OidFunctionCall4Coll(Oid functionId, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4); +extern Datum OidFunctionCall5Coll(Oid functionId, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5); +extern Datum OidFunctionCall6Coll(Oid functionId, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6); +extern Datum OidFunctionCall7Coll(Oid functionId, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7); +extern Datum OidFunctionCall8Coll(Oid functionId, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8); +extern Datum OidFunctionCall9Coll(Oid functionId, Oid collation, + Datum arg1, Datum arg2, + Datum arg3, Datum arg4, Datum arg5, + Datum arg6, Datum arg7, Datum arg8, + Datum arg9); + +/* These macros allow the collation argument to be omitted (with a default of + * InvalidOid, ie, no collation). They exist mostly for backwards + * compatibility of source code. + */ +#define DirectFunctionCall1(func, arg1) \ + DirectFunctionCall1Coll(func, InvalidOid, arg1) +#define DirectFunctionCall2(func, arg1, arg2) \ + DirectFunctionCall2Coll(func, InvalidOid, arg1, arg2) +#define DirectFunctionCall3(func, arg1, arg2, arg3) \ + DirectFunctionCall3Coll(func, InvalidOid, arg1, arg2, arg3) +#define DirectFunctionCall4(func, arg1, arg2, arg3, arg4) \ + DirectFunctionCall4Coll(func, InvalidOid, arg1, arg2, arg3, arg4) +#define DirectFunctionCall5(func, arg1, arg2, arg3, arg4, arg5) \ + DirectFunctionCall5Coll(func, InvalidOid, arg1, arg2, arg3, arg4, arg5) +#define DirectFunctionCall6(func, arg1, arg2, arg3, arg4, arg5, arg6) \ + DirectFunctionCall6Coll(func, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6) +#define DirectFunctionCall7(func, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \ + DirectFunctionCall7Coll(func, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7) +#define DirectFunctionCall8(func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \ + DirectFunctionCall8Coll(func, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) +#define DirectFunctionCall9(func, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \ + DirectFunctionCall9Coll(func, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +#define FunctionCall1(flinfo, arg1) \ + FunctionCall1Coll(flinfo, InvalidOid, arg1) +#define FunctionCall2(flinfo, arg1, arg2) \ + FunctionCall2Coll(flinfo, InvalidOid, arg1, arg2) +#define FunctionCall3(flinfo, arg1, arg2, arg3) \ + FunctionCall3Coll(flinfo, InvalidOid, arg1, arg2, arg3) +#define FunctionCall4(flinfo, arg1, arg2, arg3, arg4) \ + FunctionCall4Coll(flinfo, InvalidOid, arg1, arg2, arg3, arg4) +#define FunctionCall5(flinfo, arg1, arg2, arg3, arg4, arg5) \ + FunctionCall5Coll(flinfo, InvalidOid, arg1, arg2, arg3, arg4, arg5) +#define FunctionCall6(flinfo, arg1, arg2, arg3, arg4, arg5, arg6) \ + FunctionCall6Coll(flinfo, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6) +#define FunctionCall7(flinfo, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \ + FunctionCall7Coll(flinfo, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7) +#define FunctionCall8(flinfo, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \ + FunctionCall8Coll(flinfo, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) +#define FunctionCall9(flinfo, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \ + FunctionCall9Coll(flinfo, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) +#define OidFunctionCall0(functionId) \ + OidFunctionCall0Coll(functionId, InvalidOid) +#define OidFunctionCall1(functionId, arg1) \ + OidFunctionCall1Coll(functionId, InvalidOid, arg1) +#define OidFunctionCall2(functionId, arg1, arg2) \ + OidFunctionCall2Coll(functionId, InvalidOid, arg1, arg2) +#define OidFunctionCall3(functionId, arg1, arg2, arg3) \ + OidFunctionCall3Coll(functionId, InvalidOid, arg1, arg2, arg3) +#define OidFunctionCall4(functionId, arg1, arg2, arg3, arg4) \ + OidFunctionCall4Coll(functionId, InvalidOid, arg1, arg2, arg3, arg4) +#define OidFunctionCall5(functionId, arg1, arg2, arg3, arg4, arg5) \ + OidFunctionCall5Coll(functionId, InvalidOid, arg1, arg2, arg3, arg4, arg5) +#define OidFunctionCall6(functionId, arg1, arg2, arg3, arg4, arg5, arg6) \ + OidFunctionCall6Coll(functionId, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6) +#define OidFunctionCall7(functionId, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \ + OidFunctionCall7Coll(functionId, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7) +#define OidFunctionCall8(functionId, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \ + OidFunctionCall8Coll(functionId, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) +#define OidFunctionCall9(functionId, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) \ + OidFunctionCall9Coll(functionId, InvalidOid, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) + + +/* Special cases for convenient invocation of datatype I/O functions. */ +extern Datum InputFunctionCall(FmgrInfo *flinfo, char *str, + Oid typioparam, int32 typmod); +extern Datum OidInputFunctionCall(Oid functionId, char *str, + Oid typioparam, int32 typmod); +extern char *OutputFunctionCall(FmgrInfo *flinfo, Datum val); +extern char *OidOutputFunctionCall(Oid functionId, Datum val); +extern Datum ReceiveFunctionCall(FmgrInfo *flinfo, fmStringInfo buf, + Oid typioparam, int32 typmod); +extern Datum OidReceiveFunctionCall(Oid functionId, fmStringInfo buf, + Oid typioparam, int32 typmod); +extern bytea *SendFunctionCall(FmgrInfo *flinfo, Datum val); +extern bytea *OidSendFunctionCall(Oid functionId, Datum val); + + +/* + * Routines in fmgr.c + */ +extern const Pg_finfo_record *fetch_finfo_record(void *filehandle, const char *funcname); +extern void clear_external_function_hash(void *filehandle); +extern Oid fmgr_internal_function(const char *proname); +extern Oid get_fn_expr_rettype(FmgrInfo *flinfo); +extern Oid get_fn_expr_argtype(FmgrInfo *flinfo, int argnum); +extern Oid get_call_expr_argtype(fmNodePtr expr, int argnum); +extern bool get_fn_expr_arg_stable(FmgrInfo *flinfo, int argnum); +extern bool get_call_expr_arg_stable(fmNodePtr expr, int argnum); +extern bool get_fn_expr_variadic(FmgrInfo *flinfo); +extern bytea *get_fn_opclass_options(FmgrInfo *flinfo); +extern bool has_fn_opclass_options(FmgrInfo *flinfo); +extern void set_fn_opclass_options(FmgrInfo *flinfo, bytea *options); +extern bool CheckFunctionValidatorAccess(Oid validatorOid, Oid functionOid); + +/* + * Routines in dfmgr.c + */ +extern char *Dynamic_library_path; + +extern PGFunction load_external_function(const char *filename, const char *funcname, + bool signalNotFound, void **filehandle); +extern PGFunction lookup_external_function(void *filehandle, const char *funcname); +extern void load_file(const char *filename, bool restricted); +extern void **find_rendezvous_variable(const char *varName); +extern Size EstimateLibraryStateSpace(void); +extern void SerializeLibraryState(Size maxsize, char *start_address); +extern void RestoreLibraryState(char *start_address); + +/* + * Support for aggregate functions + * + * These are actually in executor/nodeAgg.c, but we declare them here since + * the whole point is for callers to not be overly friendly with nodeAgg. + */ + +/* AggCheckCallContext can return one of the following codes, or 0: */ +#define AGG_CONTEXT_AGGREGATE 1 /* regular aggregate */ +#define AGG_CONTEXT_WINDOW 2 /* window function */ + +extern int AggCheckCallContext(FunctionCallInfo fcinfo, + MemoryContext *aggcontext); +extern fmAggrefPtr AggGetAggref(FunctionCallInfo fcinfo); +extern MemoryContext AggGetTempMemoryContext(FunctionCallInfo fcinfo); +extern bool AggStateIsShared(FunctionCallInfo fcinfo); +extern void AggRegisterCallback(FunctionCallInfo fcinfo, + fmExprContextCallbackFunction func, + Datum arg); + +/* + * We allow plugin modules to hook function entry/exit. This is intended + * as support for loadable security policy modules, which may want to + * perform additional privilege checks on function entry or exit, or to do + * other internal bookkeeping. To make this possible, such modules must be + * able not only to support normal function entry and exit, but also to trap + * the case where we bail out due to an error; and they must also be able to + * prevent inlining. + */ +typedef enum FmgrHookEventType +{ + FHET_START, + FHET_END, + FHET_ABORT +} FmgrHookEventType; + +typedef bool (*needs_fmgr_hook_type) (Oid fn_oid); + +typedef void (*fmgr_hook_type) (FmgrHookEventType event, + FmgrInfo *flinfo, Datum *arg); + +extern PGDLLIMPORT needs_fmgr_hook_type needs_fmgr_hook; +extern PGDLLIMPORT fmgr_hook_type fmgr_hook; + +#define FmgrHookIsNeeded(fn_oid) \ + (!needs_fmgr_hook ? false : (*needs_fmgr_hook)(fn_oid)) + +#endif /* FMGR_H */ diff --git a/contrib/libs/postgresql/src/include/funcapi.h b/contrib/libs/postgresql/src/include/funcapi.h new file mode 100644 index 0000000000..b047acdc1a --- /dev/null +++ b/contrib/libs/postgresql/src/include/funcapi.h @@ -0,0 +1,348 @@ +/*------------------------------------------------------------------------- + * + * funcapi.h + * Definitions for functions which return composite type and/or sets + * or work on VARIADIC inputs. + * + * This file must be included by all Postgres modules that either define + * or call FUNCAPI-callable functions or macros. + * + * + * Copyright (c) 2002-2020, PostgreSQL Global Development Group + * + * src/include/funcapi.h + * + *------------------------------------------------------------------------- + */ +#ifndef FUNCAPI_H +#define FUNCAPI_H + +#include "access/tupdesc.h" +#include "executor/executor.h" +#include "executor/tuptable.h" +#include "fmgr.h" + +/*------------------------------------------------------------------------- + * Support to ease writing Functions returning composite types + *------------------------------------------------------------------------- + * + * This struct holds arrays of individual attribute information + * needed to create a tuple from raw C strings. It also requires + * a copy of the TupleDesc. The information carried here + * is derived from the TupleDesc, but it is stored here to + * avoid redundant cpu cycles on each call to an SRF. + */ +typedef struct AttInMetadata +{ + /* full TupleDesc */ + TupleDesc tupdesc; + + /* array of attribute type input function finfo */ + FmgrInfo *attinfuncs; + + /* array of attribute type i/o parameter OIDs */ + Oid *attioparams; + + /* array of attribute typmod */ + int32 *atttypmods; +} AttInMetadata; + +/*------------------------------------------------------------------------- + * Support struct to ease writing Set Returning Functions (SRFs) + *------------------------------------------------------------------------- + * + * This struct holds function context for Set Returning Functions. + * Use fn_extra to hold a pointer to it across calls + */ +typedef struct FuncCallContext +{ + /* + * Number of times we've been called before + * + * call_cntr is initialized to 0 for you by SRF_FIRSTCALL_INIT(), and + * incremented for you every time SRF_RETURN_NEXT() is called. + */ + uint64 call_cntr; + + /* + * OPTIONAL maximum number of calls + * + * max_calls is here for convenience only and setting it is optional. If + * not set, you must provide alternative means to know when the function + * is done. + */ + uint64 max_calls; + + /* + * OPTIONAL pointer to miscellaneous user-provided context information + * + * user_fctx is for use as a pointer to your own struct to retain + * arbitrary context information between calls of your function. + */ + void *user_fctx; + + /* + * OPTIONAL pointer to struct containing attribute type input metadata + * + * attinmeta is for use when returning tuples (i.e. composite data types) + * and is not used when returning base data types. It is only needed if + * you intend to use BuildTupleFromCStrings() to create the return tuple. + */ + AttInMetadata *attinmeta; + + /* + * memory context used for structures that must live for multiple calls + * + * multi_call_memory_ctx is set by SRF_FIRSTCALL_INIT() for you, and used + * by SRF_RETURN_DONE() for cleanup. It is the most appropriate memory + * context for any memory that is to be reused across multiple calls of + * the SRF. + */ + MemoryContext multi_call_memory_ctx; + + /* + * OPTIONAL pointer to struct containing tuple description + * + * tuple_desc is for use when returning tuples (i.e. composite data types) + * and is only needed if you are going to build the tuples with + * heap_form_tuple() rather than with BuildTupleFromCStrings(). Note that + * the TupleDesc pointer stored here should usually have been run through + * BlessTupleDesc() first. + */ + TupleDesc tuple_desc; + +} FuncCallContext; + +/*---------- + * Support to ease writing functions returning composite types + * + * External declarations: + * get_call_result_type: + * Given a function's call info record, determine the kind of datatype + * it is supposed to return. If resultTypeId isn't NULL, *resultTypeId + * receives the actual datatype OID (this is mainly useful for scalar + * result types). If resultTupleDesc isn't NULL, *resultTupleDesc + * receives a pointer to a TupleDesc when the result is of a composite + * type, or NULL when it's a scalar result or the rowtype could not be + * determined. NB: the tupledesc should be copied if it is to be + * accessed over a long period. + * get_expr_result_type: + * Given an expression node, return the same info as for + * get_call_result_type. Note: the cases in which rowtypes cannot be + * determined are different from the cases for get_call_result_type. + * get_func_result_type: + * Given only a function's OID, return the same info as for + * get_call_result_type. Note: the cases in which rowtypes cannot be + * determined are different from the cases for get_call_result_type. + * Do *not* use this if you can use one of the others. + * + * See also get_expr_result_tupdesc(), which is a convenient wrapper around + * get_expr_result_type() for use when the caller only cares about + * determinable-rowtype cases. + *---------- + */ + +/* Type categories for get_call_result_type and siblings */ +typedef enum TypeFuncClass +{ + TYPEFUNC_SCALAR, /* scalar result type */ + TYPEFUNC_COMPOSITE, /* determinable rowtype result */ + TYPEFUNC_COMPOSITE_DOMAIN, /* domain over determinable rowtype result */ + TYPEFUNC_RECORD, /* indeterminate rowtype result */ + TYPEFUNC_OTHER /* bogus type, eg pseudotype */ +} TypeFuncClass; + +extern TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo, + Oid *resultTypeId, + TupleDesc *resultTupleDesc); +extern TypeFuncClass get_expr_result_type(Node *expr, + Oid *resultTypeId, + TupleDesc *resultTupleDesc); +extern TypeFuncClass get_func_result_type(Oid functionId, + Oid *resultTypeId, + TupleDesc *resultTupleDesc); + +extern TupleDesc get_expr_result_tupdesc(Node *expr, bool noError); + +extern bool resolve_polymorphic_argtypes(int numargs, Oid *argtypes, + char *argmodes, + Node *call_expr); + +extern int get_func_arg_info(HeapTuple procTup, + Oid **p_argtypes, char ***p_argnames, + char **p_argmodes); + +extern int get_func_input_arg_names(Datum proargnames, Datum proargmodes, + char ***arg_names); + +extern int get_func_trftypes(HeapTuple procTup, Oid **p_trftypes); +extern char *get_func_result_name(Oid functionId); + +extern TupleDesc build_function_result_tupdesc_d(char prokind, + Datum proallargtypes, + Datum proargmodes, + Datum proargnames); +extern TupleDesc build_function_result_tupdesc_t(HeapTuple procTuple); + + +/*---------- + * Support to ease writing functions returning composite types + * + * External declarations: + * TupleDesc BlessTupleDesc(TupleDesc tupdesc) - "Bless" a completed tuple + * descriptor so that it can be used to return properly labeled tuples. + * You need to call this if you are going to use heap_form_tuple directly. + * TupleDescGetAttInMetadata does it for you, however, so no need to call + * it if you call TupleDescGetAttInMetadata. + * AttInMetadata *TupleDescGetAttInMetadata(TupleDesc tupdesc) - Build an + * AttInMetadata struct based on the given TupleDesc. AttInMetadata can + * be used in conjunction with C strings to produce a properly formed + * tuple. + * HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values) - + * build a HeapTuple given user data in C string form. values is an array + * of C strings, one for each attribute of the return tuple. + * Datum HeapTupleHeaderGetDatum(HeapTupleHeader tuple) - convert a + * HeapTupleHeader to a Datum. + * + * Macro declarations: + * HeapTupleGetDatum(HeapTuple tuple) - convert a HeapTuple to a Datum. + * + * Obsolete routines and macros: + * TupleDesc RelationNameGetTupleDesc(const char *relname) - Use to get a + * TupleDesc based on a named relation. + * TupleDesc TypeGetTupleDesc(Oid typeoid, List *colaliases) - Use to get a + * TupleDesc based on a type OID. + * TupleGetDatum(TupleTableSlot *slot, HeapTuple tuple) - get a Datum + * given a tuple and a slot. + *---------- + */ + +#define HeapTupleGetDatum(tuple) HeapTupleHeaderGetDatum((tuple)->t_data) +/* obsolete version of above */ +#define TupleGetDatum(_slot, _tuple) HeapTupleGetDatum(_tuple) + +extern TupleDesc RelationNameGetTupleDesc(const char *relname); +extern TupleDesc TypeGetTupleDesc(Oid typeoid, List *colaliases); + +/* from execTuples.c */ +extern TupleDesc BlessTupleDesc(TupleDesc tupdesc); +extern AttInMetadata *TupleDescGetAttInMetadata(TupleDesc tupdesc); +extern HeapTuple BuildTupleFromCStrings(AttInMetadata *attinmeta, char **values); +extern Datum HeapTupleHeaderGetDatum(HeapTupleHeader tuple); + + +/*---------- + * Support for Set Returning Functions (SRFs) + * + * The basic API for SRFs using ValuePerCall mode looks something like this: + * + * Datum + * my_Set_Returning_Function(PG_FUNCTION_ARGS) + * { + * FuncCallContext *funcctx; + * Datum result; + * MemoryContext oldcontext; + * <user defined declarations> + * + * if (SRF_IS_FIRSTCALL()) + * { + * funcctx = SRF_FIRSTCALL_INIT(); + * // switch context when allocating stuff to be used in later calls + * oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx); + * <user defined code> + * <if returning composite> + * <build TupleDesc, and perhaps AttInMetadata> + * <endif returning composite> + * <user defined code> + * // return to original context when allocating transient memory + * MemoryContextSwitchTo(oldcontext); + * } + * <user defined code> + * funcctx = SRF_PERCALL_SETUP(); + * <user defined code> + * + * if (funcctx->call_cntr < funcctx->max_calls) + * { + * <user defined code> + * <obtain result Datum> + * SRF_RETURN_NEXT(funcctx, result); + * } + * else + * SRF_RETURN_DONE(funcctx); + * } + * + * NOTE: there is no guarantee that a SRF using ValuePerCall mode will be + * run to completion; for example, a query with LIMIT might stop short of + * fetching all the rows. Therefore, do not expect that you can do resource + * cleanup just before SRF_RETURN_DONE(). You need not worry about releasing + * memory allocated in multi_call_memory_ctx, but holding file descriptors or + * other non-memory resources open across calls is a bug. SRFs that need + * such resources should not use these macros, but instead populate a + * tuplestore during a single call, and return that using SFRM_Materialize + * mode (see fmgr/README). Alternatively, set up a callback to release + * resources at query shutdown, using RegisterExprContextCallback(). + * + *---------- + */ + +/* from funcapi.c */ +extern FuncCallContext *init_MultiFuncCall(PG_FUNCTION_ARGS); +extern FuncCallContext *per_MultiFuncCall(PG_FUNCTION_ARGS); +extern void end_MultiFuncCall(PG_FUNCTION_ARGS, FuncCallContext *funcctx); + +#define SRF_IS_FIRSTCALL() (fcinfo->flinfo->fn_extra == NULL) + +#define SRF_FIRSTCALL_INIT() init_MultiFuncCall(fcinfo) + +#define SRF_PERCALL_SETUP() per_MultiFuncCall(fcinfo) + +#define SRF_RETURN_NEXT(_funcctx, _result) \ + do { \ + ReturnSetInfo *rsi; \ + (_funcctx)->call_cntr++; \ + rsi = (ReturnSetInfo *) fcinfo->resultinfo; \ + rsi->isDone = ExprMultipleResult; \ + PG_RETURN_DATUM(_result); \ + } while (0) + +#define SRF_RETURN_NEXT_NULL(_funcctx) \ + do { \ + ReturnSetInfo *rsi; \ + (_funcctx)->call_cntr++; \ + rsi = (ReturnSetInfo *) fcinfo->resultinfo; \ + rsi->isDone = ExprMultipleResult; \ + PG_RETURN_NULL(); \ + } while (0) + +#define SRF_RETURN_DONE(_funcctx) \ + do { \ + ReturnSetInfo *rsi; \ + end_MultiFuncCall(fcinfo, _funcctx); \ + rsi = (ReturnSetInfo *) fcinfo->resultinfo; \ + rsi->isDone = ExprEndResult; \ + PG_RETURN_NULL(); \ + } while (0) + +/*---------- + * Support to ease writing of functions dealing with VARIADIC inputs + *---------- + * + * This function extracts a set of argument values, types and NULL markers + * for a given input function. This returns a set of data: + * - **values includes the set of Datum values extracted. + * - **types the data type OID for each element. + * - **nulls tracks if an element is NULL. + * + * variadic_start indicates the argument number where the VARIADIC argument + * starts. + * convert_unknown set to true will enforce the conversion of arguments + * with unknown data type to text. + * + * The return result is the number of elements stored, or -1 in the case of + * "VARIADIC NULL". + */ +extern int extract_variadic_args(FunctionCallInfo fcinfo, int variadic_start, + bool convert_unknown, Datum **values, + Oid **types, bool **nulls); + +#endif /* FUNCAPI_H */ diff --git a/contrib/libs/postgresql/src/include/getaddrinfo.h b/contrib/libs/postgresql/src/include/getaddrinfo.h new file mode 100644 index 0000000000..38fa3b84e7 --- /dev/null +++ b/contrib/libs/postgresql/src/include/getaddrinfo.h @@ -0,0 +1,162 @@ +/*------------------------------------------------------------------------- + * + * getaddrinfo.h + * Support getaddrinfo() on platforms that don't have it. + * + * Note: we use our own routines on platforms that don't HAVE_STRUCT_ADDRINFO, + * whether or not the library routine getaddrinfo() can be found. This + * policy is needed because on some platforms a manually installed libbind.a + * may provide getaddrinfo(), yet the system headers may not provide the + * struct definitions needed to call it. To avoid conflict with the libbind + * definition in such cases, we rename our routines to pg_xxx() via macros. + * + * This code will also work on platforms where struct addrinfo is defined + * in the system headers but no getaddrinfo() can be located. + * + * Copyright (c) 2003-2020, PostgreSQL Global Development Group + * + * src/include/getaddrinfo.h + * + *------------------------------------------------------------------------- + */ +#ifndef GETADDRINFO_H +#define GETADDRINFO_H + +#include <sys/socket.h> +#include <netdb.h> + + +/* Various macros that ought to be in <netdb.h>, but might not be */ + +#ifndef EAI_FAIL +#ifndef WIN32 +#define EAI_BADFLAGS (-1) +#define EAI_NONAME (-2) +#define EAI_AGAIN (-3) +#define EAI_FAIL (-4) +#define EAI_FAMILY (-6) +#define EAI_SOCKTYPE (-7) +#define EAI_SERVICE (-8) +#define EAI_MEMORY (-10) +#define EAI_SYSTEM (-11) +#else /* WIN32 */ +#ifdef _MSC_VER +#ifndef WSA_NOT_ENOUGH_MEMORY +#define WSA_NOT_ENOUGH_MEMORY (WSAENOBUFS) +#endif +#define WSATYPE_NOT_FOUND (WSABASEERR+109) +#endif +#define EAI_AGAIN WSATRY_AGAIN +#define EAI_BADFLAGS WSAEINVAL +#define EAI_FAIL WSANO_RECOVERY +#define EAI_FAMILY WSAEAFNOSUPPORT +#define EAI_MEMORY WSA_NOT_ENOUGH_MEMORY +#define EAI_NODATA WSANO_DATA +#define EAI_NONAME WSAHOST_NOT_FOUND +#define EAI_SERVICE WSATYPE_NOT_FOUND +#define EAI_SOCKTYPE WSAESOCKTNOSUPPORT +#endif /* !WIN32 */ +#endif /* !EAI_FAIL */ + +#ifndef AI_PASSIVE +#define AI_PASSIVE 0x0001 +#endif + +#ifndef AI_NUMERICHOST +/* + * some platforms don't support AI_NUMERICHOST; define as zero if using + * the system version of getaddrinfo... + */ +#if defined(HAVE_STRUCT_ADDRINFO) && defined(HAVE_GETADDRINFO) +#define AI_NUMERICHOST 0 +#else +#define AI_NUMERICHOST 0x0004 +#endif +#endif + +#ifndef NI_NUMERICHOST +#define NI_NUMERICHOST 1 +#endif +#ifndef NI_NUMERICSERV +#define NI_NUMERICSERV 2 +#endif +#ifndef NI_NAMEREQD +#define NI_NAMEREQD 4 +#endif + +#ifndef NI_MAXHOST +#define NI_MAXHOST 1025 +#endif +#ifndef NI_MAXSERV +#define NI_MAXSERV 32 +#endif + + +#ifndef HAVE_STRUCT_ADDRINFO + +#ifndef WIN32 +struct addrinfo +{ + int ai_flags; + int ai_family; + int ai_socktype; + int ai_protocol; + size_t ai_addrlen; + struct sockaddr *ai_addr; + char *ai_canonname; + struct addrinfo *ai_next; +}; +#else +/* + * The order of the structure elements on Win32 doesn't match the + * order specified in the standard, but we have to match it for + * IPv6 to work. + */ +struct addrinfo +{ + int ai_flags; + int ai_family; + int ai_socktype; + int ai_protocol; + size_t ai_addrlen; + char *ai_canonname; + struct sockaddr *ai_addr; + struct addrinfo *ai_next; +}; +#endif +#endif /* HAVE_STRUCT_ADDRINFO */ + + +#ifndef HAVE_GETADDRINFO + +/* Rename private copies per comments above */ +#ifdef getaddrinfo +#undef getaddrinfo +#endif +#define getaddrinfo pg_getaddrinfo + +#ifdef freeaddrinfo +#undef freeaddrinfo +#endif +#define freeaddrinfo pg_freeaddrinfo + +#ifdef gai_strerror +#undef gai_strerror +#endif +#define gai_strerror pg_gai_strerror + +#ifdef getnameinfo +#undef getnameinfo +#endif +#define getnameinfo pg_getnameinfo + +extern int getaddrinfo(const char *node, const char *service, + const struct addrinfo *hints, struct addrinfo **res); +extern void freeaddrinfo(struct addrinfo *res); +extern const char *gai_strerror(int errcode); +extern int getnameinfo(const struct sockaddr *sa, int salen, + char *node, int nodelen, + char *service, int servicelen, int flags); +#endif /* HAVE_GETADDRINFO */ + +#endif /* GETADDRINFO_H */ diff --git a/contrib/libs/postgresql/src/include/miscadmin.h b/contrib/libs/postgresql/src/include/miscadmin.h new file mode 100644 index 0000000000..6b2b4343a0 --- /dev/null +++ b/contrib/libs/postgresql/src/include/miscadmin.h @@ -0,0 +1,489 @@ +/*------------------------------------------------------------------------- + * + * miscadmin.h + * This file contains general postgres administration and initialization + * stuff that used to be spread out between the following files: + * globals.h global variables + * pdir.h directory path crud + * pinit.h postgres initialization + * pmod.h processing modes + * Over time, this has also become the preferred place for widely known + * resource-limitation stuff, such as work_mem and check_stack_depth(). + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/miscadmin.h + * + * NOTES + * some of the information in this file should be moved to other files. + * + *------------------------------------------------------------------------- + */ +#ifndef MISCADMIN_H +#define MISCADMIN_H + +#include <signal.h> + +#include "datatype/timestamp.h" /* for TimestampTz */ +#include "pgtime.h" /* for pg_time_t */ + + +#define InvalidPid (-1) + + +/***************************************************************************** + * System interrupt and critical section handling + * + * There are two types of interrupts that a running backend needs to accept + * without messing up its state: QueryCancel (SIGINT) and ProcDie (SIGTERM). + * In both cases, we need to be able to clean up the current transaction + * gracefully, so we can't respond to the interrupt instantaneously --- + * there's no guarantee that internal data structures would be self-consistent + * if the code is interrupted at an arbitrary instant. Instead, the signal + * handlers set flags that are checked periodically during execution. + * + * The CHECK_FOR_INTERRUPTS() macro is called at strategically located spots + * where it is normally safe to accept a cancel or die interrupt. In some + * cases, we invoke CHECK_FOR_INTERRUPTS() inside low-level subroutines that + * might sometimes be called in contexts that do *not* want to allow a cancel + * or die interrupt. The HOLD_INTERRUPTS() and RESUME_INTERRUPTS() macros + * allow code to ensure that no cancel or die interrupt will be accepted, + * even if CHECK_FOR_INTERRUPTS() gets called in a subroutine. The interrupt + * will be held off until CHECK_FOR_INTERRUPTS() is done outside any + * HOLD_INTERRUPTS() ... RESUME_INTERRUPTS() section. + * + * There is also a mechanism to prevent query cancel interrupts, while still + * allowing die interrupts: HOLD_CANCEL_INTERRUPTS() and + * RESUME_CANCEL_INTERRUPTS(). + * + * Note that ProcessInterrupts() has also acquired a number of tasks that + * do not necessarily cause a query-cancel-or-die response. Hence, it's + * possible that it will just clear InterruptPending and return. + * + * INTERRUPTS_PENDING_CONDITION() can be checked to see whether an + * interrupt needs to be serviced, without trying to do so immediately. + * Some callers are also interested in INTERRUPTS_CAN_BE_PROCESSED(), + * which tells whether ProcessInterrupts is sure to clear the interrupt. + * + * Special mechanisms are used to let an interrupt be accepted when we are + * waiting for a lock or when we are waiting for command input (but, of + * course, only if the interrupt holdoff counter is zero). See the + * related code for details. + * + * A lost connection is handled similarly, although the loss of connection + * does not raise a signal, but is detected when we fail to write to the + * socket. If there was a signal for a broken connection, we could make use of + * it by setting ClientConnectionLost in the signal handler. + * + * A related, but conceptually distinct, mechanism is the "critical section" + * mechanism. A critical section not only holds off cancel/die interrupts, + * but causes any ereport(ERROR) or ereport(FATAL) to become ereport(PANIC) + * --- that is, a system-wide reset is forced. Needless to say, only really + * *critical* code should be marked as a critical section! Currently, this + * mechanism is only used for XLOG-related code. + * + *****************************************************************************/ + +/* in globals.c */ +/* these are marked volatile because they are set by signal handlers: */ +extern PGDLLIMPORT volatile sig_atomic_t InterruptPending; +extern PGDLLIMPORT volatile sig_atomic_t QueryCancelPending; +extern PGDLLIMPORT volatile sig_atomic_t ProcDiePending; +extern PGDLLIMPORT volatile sig_atomic_t IdleInTransactionSessionTimeoutPending; +extern PGDLLIMPORT volatile sig_atomic_t ProcSignalBarrierPending; + +extern PGDLLIMPORT volatile sig_atomic_t ClientConnectionLost; + +/* these are marked volatile because they are examined by signal handlers: */ +extern PGDLLIMPORT volatile uint32 InterruptHoldoffCount; +extern PGDLLIMPORT volatile uint32 QueryCancelHoldoffCount; +extern PGDLLIMPORT volatile uint32 CritSectionCount; + +/* in tcop/postgres.c */ +extern void ProcessInterrupts(void); + +/* Test whether an interrupt is pending */ +#ifndef WIN32 +#define INTERRUPTS_PENDING_CONDITION() \ + (unlikely(InterruptPending)) +#else +#define INTERRUPTS_PENDING_CONDITION() \ + (unlikely(UNBLOCKED_SIGNAL_QUEUE()) ? pgwin32_dispatch_queued_signals() : 0, \ + unlikely(InterruptPending)) +#endif + +/* Service interrupt, if one is pending and it's safe to service it now */ +#define CHECK_FOR_INTERRUPTS() \ +do { \ + if (INTERRUPTS_PENDING_CONDITION()) \ + ProcessInterrupts(); \ +} while(0) + +/* Is ProcessInterrupts() guaranteed to clear InterruptPending? */ +#define INTERRUPTS_CAN_BE_PROCESSED() \ + (InterruptHoldoffCount == 0 && CritSectionCount == 0 && \ + QueryCancelHoldoffCount == 0) + +#define HOLD_INTERRUPTS() (InterruptHoldoffCount++) + +#define RESUME_INTERRUPTS() \ +do { \ + Assert(InterruptHoldoffCount > 0); \ + InterruptHoldoffCount--; \ +} while(0) + +#define HOLD_CANCEL_INTERRUPTS() (QueryCancelHoldoffCount++) + +#define RESUME_CANCEL_INTERRUPTS() \ +do { \ + Assert(QueryCancelHoldoffCount > 0); \ + QueryCancelHoldoffCount--; \ +} while(0) + +#define START_CRIT_SECTION() (CritSectionCount++) + +#define END_CRIT_SECTION() \ +do { \ + Assert(CritSectionCount > 0); \ + CritSectionCount--; \ +} while(0) + + +/***************************************************************************** + * globals.h -- * + *****************************************************************************/ + +/* + * from utils/init/globals.c + */ +extern PGDLLIMPORT pid_t PostmasterPid; +extern PGDLLIMPORT bool IsPostmasterEnvironment; +extern PGDLLIMPORT bool IsUnderPostmaster; +extern PGDLLIMPORT bool IsBackgroundWorker; +extern PGDLLIMPORT bool IsBinaryUpgrade; + +extern PGDLLIMPORT bool ExitOnAnyError; + +extern PGDLLIMPORT char *DataDir; +extern PGDLLIMPORT int data_directory_mode; + +extern PGDLLIMPORT int NBuffers; +extern PGDLLIMPORT int MaxBackends; +extern PGDLLIMPORT int MaxConnections; +extern PGDLLIMPORT int max_worker_processes; +extern PGDLLIMPORT int max_parallel_workers; + +extern PGDLLIMPORT int MyProcPid; +extern PGDLLIMPORT pg_time_t MyStartTime; +extern PGDLLIMPORT TimestampTz MyStartTimestamp; +extern PGDLLIMPORT struct Port *MyProcPort; +extern PGDLLIMPORT struct Latch *MyLatch; +extern int32 MyCancelKey; +extern int MyPMChildSlot; + +extern char OutputFileName[]; +extern PGDLLIMPORT char my_exec_path[]; +extern char pkglib_path[]; + +#ifdef EXEC_BACKEND +extern char postgres_exec_path[]; +#endif + +/* + * done in storage/backendid.h for now. + * + * extern BackendId MyBackendId; + */ +extern PGDLLIMPORT Oid MyDatabaseId; + +extern PGDLLIMPORT Oid MyDatabaseTableSpace; + +/* + * Date/Time Configuration + * + * DateStyle defines the output formatting choice for date/time types: + * USE_POSTGRES_DATES specifies traditional Postgres format + * USE_ISO_DATES specifies ISO-compliant format + * USE_SQL_DATES specifies Oracle/Ingres-compliant format + * USE_GERMAN_DATES specifies German-style dd.mm/yyyy + * + * DateOrder defines the field order to be assumed when reading an + * ambiguous date (anything not in YYYY-MM-DD format, with a four-digit + * year field first, is taken to be ambiguous): + * DATEORDER_YMD specifies field order yy-mm-dd + * DATEORDER_DMY specifies field order dd-mm-yy ("European" convention) + * DATEORDER_MDY specifies field order mm-dd-yy ("US" convention) + * + * In the Postgres and SQL DateStyles, DateOrder also selects output field + * order: day comes before month in DMY style, else month comes before day. + * + * The user-visible "DateStyle" run-time parameter subsumes both of these. + */ + +/* valid DateStyle values */ +#define USE_POSTGRES_DATES 0 +#define USE_ISO_DATES 1 +#define USE_SQL_DATES 2 +#define USE_GERMAN_DATES 3 +#define USE_XSD_DATES 4 + +/* valid DateOrder values */ +#define DATEORDER_YMD 0 +#define DATEORDER_DMY 1 +#define DATEORDER_MDY 2 + +extern PGDLLIMPORT int DateStyle; +extern PGDLLIMPORT int DateOrder; + +/* + * IntervalStyles + * INTSTYLE_POSTGRES Like Postgres < 8.4 when DateStyle = 'iso' + * INTSTYLE_POSTGRES_VERBOSE Like Postgres < 8.4 when DateStyle != 'iso' + * INTSTYLE_SQL_STANDARD SQL standard interval literals + * INTSTYLE_ISO_8601 ISO-8601-basic formatted intervals + */ +#define INTSTYLE_POSTGRES 0 +#define INTSTYLE_POSTGRES_VERBOSE 1 +#define INTSTYLE_SQL_STANDARD 2 +#define INTSTYLE_ISO_8601 3 + +extern PGDLLIMPORT int IntervalStyle; + +#define MAXTZLEN 10 /* max TZ name len, not counting tr. null */ + +extern bool enableFsync; +extern PGDLLIMPORT bool allowSystemTableMods; +extern PGDLLIMPORT int work_mem; +extern PGDLLIMPORT double hash_mem_multiplier; +extern PGDLLIMPORT int maintenance_work_mem; +extern PGDLLIMPORT int max_parallel_maintenance_workers; + +extern int VacuumCostPageHit; +extern int VacuumCostPageMiss; +extern int VacuumCostPageDirty; +extern int VacuumCostLimit; +extern double VacuumCostDelay; + +extern int64 VacuumPageHit; +extern int64 VacuumPageMiss; +extern int64 VacuumPageDirty; + +extern int VacuumCostBalance; +extern bool VacuumCostActive; + +extern double vacuum_cleanup_index_scale_factor; + + +/* in tcop/postgres.c */ + +#if defined(__ia64__) || defined(__ia64) +typedef struct +{ + char *stack_base_ptr; + char *register_stack_base_ptr; +} pg_stack_base_t; +#else +typedef char *pg_stack_base_t; +#endif + +extern pg_stack_base_t set_stack_base(void); +extern void restore_stack_base(pg_stack_base_t base); +extern void check_stack_depth(void); +extern bool stack_is_too_deep(void); + +/* in tcop/utility.c */ +extern void PreventCommandIfReadOnly(const char *cmdname); +extern void PreventCommandIfParallelMode(const char *cmdname); +extern void PreventCommandDuringRecovery(const char *cmdname); + +/* in utils/misc/guc.c */ +extern int trace_recovery_messages; +extern int trace_recovery(int trace_level); + +/***************************************************************************** + * pdir.h -- * + * POSTGRES directory path definitions. * + *****************************************************************************/ + +/* flags to be OR'd to form sec_context */ +#define SECURITY_LOCAL_USERID_CHANGE 0x0001 +#define SECURITY_RESTRICTED_OPERATION 0x0002 +#define SECURITY_NOFORCE_RLS 0x0004 + +extern char *DatabasePath; + +/* now in utils/init/miscinit.c */ +extern void InitPostmasterChild(void); +extern void InitStandaloneProcess(const char *argv0); +extern void SwitchToSharedLatch(void); +extern void SwitchBackToLocalLatch(void); + +typedef enum BackendType +{ + B_INVALID = 0, + B_AUTOVAC_LAUNCHER, + B_AUTOVAC_WORKER, + B_BACKEND, + B_BG_WORKER, + B_BG_WRITER, + B_CHECKPOINTER, + B_STARTUP, + B_WAL_RECEIVER, + B_WAL_SENDER, + B_WAL_WRITER, + B_ARCHIVER, + B_STATS_COLLECTOR, + B_LOGGER, +} BackendType; + +extern BackendType MyBackendType; + +extern const char *GetBackendTypeDesc(BackendType backendType); + +extern void SetDatabasePath(const char *path); +extern void checkDataDir(void); +extern void SetDataDir(const char *dir); +extern void ChangeToDataDir(void); + +extern char *GetUserNameFromId(Oid roleid, bool noerr); +extern Oid GetUserId(void); +extern Oid GetOuterUserId(void); +extern Oid GetSessionUserId(void); +extern Oid GetAuthenticatedUserId(void); +extern void GetUserIdAndSecContext(Oid *userid, int *sec_context); +extern void SetUserIdAndSecContext(Oid userid, int sec_context); +extern bool InLocalUserIdChange(void); +extern bool InSecurityRestrictedOperation(void); +extern bool InNoForceRLSOperation(void); +extern void GetUserIdAndContext(Oid *userid, bool *sec_def_context); +extern void SetUserIdAndContext(Oid userid, bool sec_def_context); +extern void InitializeSessionUserId(const char *rolename, Oid useroid); +extern void InitializeSessionUserIdStandalone(void); +extern void SetSessionAuthorization(Oid userid, bool is_superuser); +extern Oid GetCurrentRoleId(void); +extern void SetCurrentRoleId(Oid roleid, bool is_superuser); + +/* in utils/misc/superuser.c */ +extern bool superuser(void); /* current user is superuser */ +extern bool superuser_arg(Oid roleid); /* given user is superuser */ + + +/***************************************************************************** + * pmod.h -- * + * POSTGRES processing mode definitions. * + *****************************************************************************/ + +/* + * Description: + * There are three processing modes in POSTGRES. They are + * BootstrapProcessing or "bootstrap," InitProcessing or + * "initialization," and NormalProcessing or "normal." + * + * The first two processing modes are used during special times. When the + * system state indicates bootstrap processing, transactions are all given + * transaction id "one" and are consequently guaranteed to commit. This mode + * is used during the initial generation of template databases. + * + * Initialization mode: used while starting a backend, until all normal + * initialization is complete. Some code behaves differently when executed + * in this mode to enable system bootstrapping. + * + * If a POSTGRES backend process is in normal mode, then all code may be + * executed normally. + */ + +typedef enum ProcessingMode +{ + BootstrapProcessing, /* bootstrap creation of template database */ + InitProcessing, /* initializing system */ + NormalProcessing /* normal processing */ +} ProcessingMode; + +extern ProcessingMode Mode; + +#define IsBootstrapProcessingMode() (Mode == BootstrapProcessing) +#define IsInitProcessingMode() (Mode == InitProcessing) +#define IsNormalProcessingMode() (Mode == NormalProcessing) + +#define GetProcessingMode() Mode + +#define SetProcessingMode(mode) \ + do { \ + AssertArg((mode) == BootstrapProcessing || \ + (mode) == InitProcessing || \ + (mode) == NormalProcessing); \ + Mode = (mode); \ + } while(0) + + +/* + * Auxiliary-process type identifiers. These used to be in bootstrap.h + * but it seems saner to have them here, with the ProcessingMode stuff. + * The MyAuxProcType global is defined and set in bootstrap.c. + */ + +typedef enum +{ + NotAnAuxProcess = -1, + CheckerProcess = 0, + BootstrapProcess, + StartupProcess, + BgWriterProcess, + CheckpointerProcess, + WalWriterProcess, + WalReceiverProcess, + + NUM_AUXPROCTYPES /* Must be last! */ +} AuxProcType; + +extern AuxProcType MyAuxProcType; + +#define AmBootstrapProcess() (MyAuxProcType == BootstrapProcess) +#define AmStartupProcess() (MyAuxProcType == StartupProcess) +#define AmBackgroundWriterProcess() (MyAuxProcType == BgWriterProcess) +#define AmCheckpointerProcess() (MyAuxProcType == CheckpointerProcess) +#define AmWalWriterProcess() (MyAuxProcType == WalWriterProcess) +#define AmWalReceiverProcess() (MyAuxProcType == WalReceiverProcess) + + +/***************************************************************************** + * pinit.h -- * + * POSTGRES initialization and cleanup definitions. * + *****************************************************************************/ + +/* in utils/init/postinit.c */ +extern void pg_split_opts(char **argv, int *argcp, const char *optstr); +extern void InitializeMaxBackends(void); +extern void InitPostgres(const char *in_dbname, Oid dboid, const char *username, + Oid useroid, char *out_dbname, bool override_allow_connections); +extern void BaseInit(void); + +/* in utils/init/miscinit.c */ +extern bool IgnoreSystemIndexes; +extern PGDLLIMPORT bool process_shared_preload_libraries_in_progress; +extern char *session_preload_libraries_string; +extern char *shared_preload_libraries_string; +extern char *local_preload_libraries_string; + +extern void CreateDataDirLockFile(bool amPostmaster); +extern void CreateSocketLockFile(const char *socketfile, bool amPostmaster, + const char *socketDir); +extern void TouchSocketLockFiles(void); +extern void AddToDataDirLockFile(int target_line, const char *str); +extern bool RecheckDataDirLockFile(void); +extern void ValidatePgVersion(const char *path); +extern void process_shared_preload_libraries(void); +extern void process_session_preload_libraries(void); +extern void pg_bindtextdomain(const char *domain); +extern bool has_rolreplication(Oid roleid); + +/* in access/transam/xlog.c */ +extern bool BackupInProgress(void); +extern void CancelBackup(void); + +/* in executor/nodeHash.c */ +extern size_t get_hash_memory_limit(void); +extern int get_hash_mem(void); + +#endif /* MISCADMIN_H */ diff --git a/contrib/libs/postgresql/src/include/pg_config-linux.h b/contrib/libs/postgresql/src/include/pg_config-linux.h new file mode 100644 index 0000000000..30c8422e97 --- /dev/null +++ b/contrib/libs/postgresql/src/include/pg_config-linux.h @@ -0,0 +1,981 @@ +/* src/include/pg_config.h. Generated from pg_config.h.in by configure. */ +/* src/include/pg_config.h.in. Generated from configure.in by autoheader. */ + +/* Define to the type of arg 1 of 'accept' */ +#define ACCEPT_TYPE_ARG1 int + +/* Define to the type of arg 2 of 'accept' */ +#define ACCEPT_TYPE_ARG2 struct sockaddr * + +/* Define to the type of arg 3 of 'accept' */ +#define ACCEPT_TYPE_ARG3 socklen_t + +/* Define to the return type of 'accept' */ +#define ACCEPT_TYPE_RETURN int + +/* Define if building universal (internal helper macro) */ +/* #undef AC_APPLE_UNIVERSAL_BUILD */ + +/* The normal alignment of `double', in bytes. */ +#define ALIGNOF_DOUBLE 8 + +/* The normal alignment of `int', in bytes. */ +#define ALIGNOF_INT 4 + +/* The normal alignment of `long', in bytes. */ +#define ALIGNOF_LONG 8 + +/* The normal alignment of `long long int', in bytes. */ +/* #undef ALIGNOF_LONG_LONG_INT */ + +/* The normal alignment of `PG_INT128_TYPE', in bytes. */ +#define ALIGNOF_PG_INT128_TYPE 16 + +/* The normal alignment of `short', in bytes. */ +#define ALIGNOF_SHORT 2 + +/* Size of a disk block --- this also limits the size of a tuple. You can set + it bigger if you need bigger tuples (although TOAST should reduce the need + to have large tuples, since fields can be spread across multiple tuples). + BLCKSZ must be a power of 2. The maximum possible value of BLCKSZ is + currently 2^15 (32768). This is determined by the 15-bit widths of the + lp_off and lp_len fields in ItemIdData (see include/storage/itemid.h). + Changing BLCKSZ requires an initdb. */ +#define BLCKSZ 8192 + +/* Saved arguments from configure */ +#define CONFIGURE_ARGS " '--prefix=/var/empty/postgresql-13.5' '--with-openssl' '--with-libxml' '--sysconfdir=/etc' '--libdir=$(lib)/lib' '--with-system-tzdata=/var/empty/tzdata-2021c/share/zoneinfo' '--enable-debug' '--with-systemd' '--with-ossp-uuid' '--with-icu' '--with-gssapi' '--without-gssapi' '--without-systemd' 'CC=cc' 'CXX=g++' 'PKG_CONFIG=pkg-config' 'PKG_CONFIG_PATH=/var/empty/zlib-1.2.11-dev/lib/pkgconfig:/var/empty/ncurses-6.2-dev/lib/pkgconfig:/var/empty/openssl-1.1.1l-dev/lib/pkgconfig:/var/empty/libxml2-2.9.12-dev/lib/pkgconfig:/var/empty/icu4c-70.1-dev/lib/pkgconfig:/var/empty/systemd-249.5-dev/lib/pkgconfig:/var/empty/systemd-249.5-dev/share/pkgconfig:/var/empty/libkrb5-1.18-dev/lib/pkgconfig:/var/empty/libossp-uuid-1.6.2/lib/pkgconfig'" + +/* Define to the default TCP port number on which the server listens and to + which clients will try to connect. This can be overridden at run-time, but + it's convenient if your clients have the right default compiled in. + (--with-pgport=PORTNUM) */ +#define DEF_PGPORT 5432 + +/* Define to the default TCP port number as a string constant. */ +#define DEF_PGPORT_STR "5432" + +/* Define to build with GSSAPI support. (--with-gssapi) */ +/* #undef ENABLE_GSS */ + +/* Define to 1 if you want National Language Support. (--enable-nls) */ +/* #undef ENABLE_NLS */ + +/* Define to 1 to build client libraries as thread-safe code. + (--enable-thread-safety) */ +#define ENABLE_THREAD_SAFETY 1 + +/* Define to 1 if gettimeofday() takes only 1 argument. */ +/* #undef GETTIMEOFDAY_1ARG */ + +#ifdef GETTIMEOFDAY_1ARG +# define gettimeofday(a,b) gettimeofday(a) +#endif + +/* Define to 1 if you have the `append_history' function. */ +#define HAVE_APPEND_HISTORY 1 + +/* Define to 1 if you have the `ASN1_STRING_get0_data' function. */ +#define HAVE_ASN1_STRING_GET0_DATA 1 + +/* Define to 1 if you want to use atomics if available. */ +#define HAVE_ATOMICS 1 + +/* Define to 1 if you have the <atomic.h> header file. */ +/* #undef HAVE_ATOMIC_H */ + +/* Define to 1 if you have the `backtrace_symbols' function. */ +#define HAVE_BACKTRACE_SYMBOLS 1 + +/* Define to 1 if you have the `BIO_get_data' function. */ +#define HAVE_BIO_GET_DATA 1 + +/* Define to 1 if you have the `BIO_meth_new' function. */ +#define HAVE_BIO_METH_NEW 1 + +/* Define to 1 if you have the `clock_gettime' function. */ +#define HAVE_CLOCK_GETTIME 1 + +/* Define to 1 if your compiler handles computed gotos. */ +#define HAVE_COMPUTED_GOTO 1 + +/* Define to 1 if you have the `copyfile' function. */ +/* #undef HAVE_COPYFILE */ + +/* Define to 1 if you have the <copyfile.h> header file. */ +/* #undef HAVE_COPYFILE_H */ + +/* Define to 1 if you have the <crtdefs.h> header file. */ +/* #undef HAVE_CRTDEFS_H */ + +/* Define to 1 if you have the `CRYPTO_lock' function. */ +/* #undef HAVE_CRYPTO_LOCK */ + +/* Define to 1 if you have the declaration of `fdatasync', and to 0 if you + don't. */ +#define HAVE_DECL_FDATASYNC 1 + +/* Define to 1 if you have the declaration of `F_FULLFSYNC', and to 0 if you + don't. */ +#define HAVE_DECL_F_FULLFSYNC 0 + +/* Define to 1 if you have the declaration of + `LLVMCreateGDBRegistrationListener', and to 0 if you don't. */ +/* #undef HAVE_DECL_LLVMCREATEGDBREGISTRATIONLISTENER */ + +/* Define to 1 if you have the declaration of + `LLVMCreatePerfJITEventListener', and to 0 if you don't. */ +/* #undef HAVE_DECL_LLVMCREATEPERFJITEVENTLISTENER */ + +/* Define to 1 if you have the declaration of `LLVMGetHostCPUFeatures', and to + 0 if you don't. */ +/* #undef HAVE_DECL_LLVMGETHOSTCPUFEATURES */ + +/* Define to 1 if you have the declaration of `LLVMGetHostCPUName', and to 0 + if you don't. */ +/* #undef HAVE_DECL_LLVMGETHOSTCPUNAME */ + +/* Define to 1 if you have the declaration of `LLVMOrcGetSymbolAddressIn', and + to 0 if you don't. */ +/* #undef HAVE_DECL_LLVMORCGETSYMBOLADDRESSIN */ + +/* Define to 1 if you have the declaration of `posix_fadvise', and to 0 if you + don't. */ +#define HAVE_DECL_POSIX_FADVISE 1 + +/* Define to 1 if you have the declaration of `RTLD_GLOBAL', and to 0 if you + don't. */ +#define HAVE_DECL_RTLD_GLOBAL 1 + +/* Define to 1 if you have the declaration of `RTLD_NOW', and to 0 if you + don't. */ +#define HAVE_DECL_RTLD_NOW 1 + +/* Define to 1 if you have the declaration of `strlcat', and to 0 if you + don't. */ +#define HAVE_DECL_STRLCAT 0 + +/* Define to 1 if you have the declaration of `strlcpy', and to 0 if you + don't. */ +#define HAVE_DECL_STRLCPY 0 + +/* Define to 1 if you have the declaration of `strnlen', and to 0 if you + don't. */ +#define HAVE_DECL_STRNLEN 1 + +/* Define to 1 if you have the declaration of `strtoll', and to 0 if you + don't. */ +#define HAVE_DECL_STRTOLL 1 + +/* Define to 1 if you have the declaration of `strtoull', and to 0 if you + don't. */ +#define HAVE_DECL_STRTOULL 1 + +/* Define to 1 if you have the `dlopen' function. */ +#define HAVE_DLOPEN 1 + +/* Define to 1 if you have the <editline/history.h> header file. */ +/* #undef HAVE_EDITLINE_HISTORY_H */ + +/* Define to 1 if you have the <editline/readline.h> header file. */ +/* #undef HAVE_EDITLINE_READLINE_H */ + +/* Define to 1 if you have the <execinfo.h> header file. */ +#define HAVE_EXECINFO_H 1 + +/* Define to 1 if you have the `explicit_bzero' function. */ +#define HAVE_EXPLICIT_BZERO 1 + +/* Define to 1 if you have the `fdatasync' function. */ +#define HAVE_FDATASYNC 1 + +/* Define to 1 if you have the `fls' function. */ +/* #undef HAVE_FLS */ + +/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */ +#define HAVE_FSEEKO 1 + +/* Define to 1 if your compiler understands __func__. */ +#define HAVE_FUNCNAME__FUNC 1 + +/* Define to 1 if your compiler understands __FUNCTION__. */ +/* #undef HAVE_FUNCNAME__FUNCTION */ + +/* Define to 1 if you have __atomic_compare_exchange_n(int *, int *, int). */ +#define HAVE_GCC__ATOMIC_INT32_CAS 1 + +/* Define to 1 if you have __atomic_compare_exchange_n(int64 *, int64 *, + int64). */ +#define HAVE_GCC__ATOMIC_INT64_CAS 1 + +/* Define to 1 if you have __sync_lock_test_and_set(char *) and friends. */ +#define HAVE_GCC__SYNC_CHAR_TAS 1 + +/* Define to 1 if you have __sync_val_compare_and_swap(int *, int, int). */ +#define HAVE_GCC__SYNC_INT32_CAS 1 + +/* Define to 1 if you have __sync_lock_test_and_set(int *) and friends. */ +#define HAVE_GCC__SYNC_INT32_TAS 1 + +/* Define to 1 if you have __sync_val_compare_and_swap(int64 *, int64, int64). + */ +#define HAVE_GCC__SYNC_INT64_CAS 1 + +/* Define to 1 if you have the `getaddrinfo' function. */ +#define HAVE_GETADDRINFO 1 + +/* Define to 1 if you have the `gethostbyname_r' function. */ +#define HAVE_GETHOSTBYNAME_R 1 + +/* Define to 1 if you have the `getifaddrs' function. */ +#define HAVE_GETIFADDRS 1 + +/* Define to 1 if you have the `getopt' function. */ +#define HAVE_GETOPT 1 + +/* Define to 1 if you have the <getopt.h> header file. */ +#define HAVE_GETOPT_H 1 + +/* Define to 1 if you have the `getopt_long' function. */ +#define HAVE_GETOPT_LONG 1 + +/* Define to 1 if you have the `getpeereid' function. */ +/* #undef HAVE_GETPEEREID */ + +/* Define to 1 if you have the `getpeerucred' function. */ +/* #undef HAVE_GETPEERUCRED */ + +/* Define to 1 if you have the `getpwuid_r' function. */ +#define HAVE_GETPWUID_R 1 + +/* Define to 1 if you have the `getrlimit' function. */ +#define HAVE_GETRLIMIT 1 + +/* Define to 1 if you have the `getrusage' function. */ +#define HAVE_GETRUSAGE 1 + +/* Define to 1 if you have the `gettimeofday' function. */ +/* #undef HAVE_GETTIMEOFDAY */ + +/* Define to 1 if you have the <gssapi/gssapi.h> header file. */ +/* #undef HAVE_GSSAPI_GSSAPI_H */ + +/* Define to 1 if you have the <gssapi.h> header file. */ +/* #undef HAVE_GSSAPI_H */ + +/* Define to 1 if you have the <history.h> header file. */ +/* #undef HAVE_HISTORY_H */ + +/* Define to 1 if you have the `history_truncate_file' function. */ +#define HAVE_HISTORY_TRUNCATE_FILE 1 + +/* Define to 1 if you have the <ifaddrs.h> header file. */ +#define HAVE_IFADDRS_H 1 + +/* Define to 1 if you have the `inet_aton' function. */ +#define HAVE_INET_ATON 1 + +/* Define to 1 if the system has the type `int64'. */ +/* #undef HAVE_INT64 */ + +/* Define to 1 if the system has the type `int8'. */ +/* #undef HAVE_INT8 */ + +/* Define to 1 if you have the <inttypes.h> header file. */ +#define HAVE_INTTYPES_H 1 + +/* Define to 1 if you have the global variable 'int opterr'. */ +#define HAVE_INT_OPTERR 1 + +/* Define to 1 if you have the global variable 'int optreset'. */ +/* #undef HAVE_INT_OPTRESET */ + +/* Define to 1 if you have the global variable 'int timezone'. */ +#define HAVE_INT_TIMEZONE 1 + +/* Define to 1 if you have support for IPv6. */ +#define HAVE_IPV6 1 + +/* Define to 1 if __builtin_constant_p(x) implies "i"(x) acceptance. */ +/* #undef HAVE_I_CONSTRAINT__BUILTIN_CONSTANT_P */ + +/* Define to 1 if you have the `kqueue' function. */ +/* #undef HAVE_KQUEUE */ + +/* Define to 1 if you have the <langinfo.h> header file. */ +#define HAVE_LANGINFO_H 1 + +/* Define to 1 if you have the <ldap.h> header file. */ +/* #undef HAVE_LDAP_H */ + +/* Define to 1 if you have the `ldap_initialize' function. */ +/* #undef HAVE_LDAP_INITIALIZE */ + +/* Define to 1 if you have the `crypto' library (-lcrypto). */ +#define HAVE_LIBCRYPTO 1 + +/* Define to 1 if you have the `ldap' library (-lldap). */ +/* #undef HAVE_LIBLDAP */ + +/* Define to 1 if you have the `m' library (-lm). */ +#define HAVE_LIBM 1 + +/* Define to 1 if you have the `pam' library (-lpam). */ +/* #undef HAVE_LIBPAM */ + +/* Define if you have a function readline library */ +#define HAVE_LIBREADLINE 1 + +/* Define to 1 if you have the `selinux' library (-lselinux). */ +/* #undef HAVE_LIBSELINUX */ + +/* Define to 1 if you have the `ssl' library (-lssl). */ +#define HAVE_LIBSSL 1 + +/* Define to 1 if you have the `wldap32' library (-lwldap32). */ +/* #undef HAVE_LIBWLDAP32 */ + +/* Define to 1 if you have the `xml2' library (-lxml2). */ +#define HAVE_LIBXML2 1 + +/* Define to 1 if you have the `xslt' library (-lxslt). */ +/* #undef HAVE_LIBXSLT */ + +/* Define to 1 if you have the `z' library (-lz). */ +#define HAVE_LIBZ 1 + +/* Define to 1 if you have the `link' function. */ +#define HAVE_LINK 1 + +/* Define to 1 if the system has the type `locale_t'. */ +#define HAVE_LOCALE_T 1 + +/* Define to 1 if `long int' works and is 64 bits. */ +#define HAVE_LONG_INT_64 1 + +/* Define to 1 if `long long int' works and is 64 bits. */ +/* #undef HAVE_LONG_LONG_INT_64 */ + +/* Define to 1 if you have the <mbarrier.h> header file. */ +/* #undef HAVE_MBARRIER_H */ + +/* Define to 1 if you have the `mbstowcs_l' function. */ +/* #undef HAVE_MBSTOWCS_L */ + +/* Define to 1 if you have the <memory.h> header file. */ +#define HAVE_MEMORY_H 1 + +/* Define to 1 if you have the `memset_s' function. */ +/* #undef HAVE_MEMSET_S */ + +/* Define to 1 if the system has the type `MINIDUMP_TYPE'. */ +/* #undef HAVE_MINIDUMP_TYPE */ + +/* Define to 1 if you have the `mkdtemp' function. */ +#define HAVE_MKDTEMP 1 + +/* Define to 1 if you have the <netinet/tcp.h> header file. */ +#define HAVE_NETINET_TCP_H 1 + +/* Define to 1 if you have the <net/if.h> header file. */ +#define HAVE_NET_IF_H 1 + +/* Define to 1 if you have the `OPENSSL_init_ssl' function. */ +#define HAVE_OPENSSL_INIT_SSL 1 + +/* Define to 1 if you have the <ossp/uuid.h> header file. */ +/* #undef HAVE_OSSP_UUID_H */ + +/* Define to 1 if you have the <pam/pam_appl.h> header file. */ +/* #undef HAVE_PAM_PAM_APPL_H */ + +/* Define to 1 if you have the `poll' function. */ +#define HAVE_POLL 1 + +/* Define to 1 if you have the <poll.h> header file. */ +#define HAVE_POLL_H 1 + +/* Define to 1 if you have the `posix_fadvise' function. */ +#define HAVE_POSIX_FADVISE 1 + +/* Define to 1 if you have the `posix_fallocate' function. */ +#define HAVE_POSIX_FALLOCATE 1 + +/* Define to 1 if the assembler supports PPC's LWARX mutex hint bit. */ +/* #undef HAVE_PPC_LWARX_MUTEX_HINT */ + +/* Define to 1 if you have the `ppoll' function. */ +#define HAVE_PPOLL 1 + +/* Define to 1 if you have the `pread' function. */ +#define HAVE_PREAD 1 + +/* Define to 1 if you have the `pstat' function. */ +/* #undef HAVE_PSTAT */ + +/* Define to 1 if the PS_STRINGS thing exists. */ +/* #undef HAVE_PS_STRINGS */ + +/* Define if you have POSIX threads libraries and header files. */ +#define HAVE_PTHREAD 1 + +/* Define to 1 if you have the `pthread_is_threaded_np' function. */ +/* #undef HAVE_PTHREAD_IS_THREADED_NP */ + +/* Have PTHREAD_PRIO_INHERIT. */ +#define HAVE_PTHREAD_PRIO_INHERIT 1 + +/* Define to 1 if you have the `pwrite' function. */ +#define HAVE_PWRITE 1 + +/* Define to 1 if you have the `random' function. */ +#define HAVE_RANDOM 1 + +/* Define to 1 if you have the <readline.h> header file. */ +/* #undef HAVE_READLINE_H */ + +/* Define to 1 if you have the <readline/history.h> header file. */ +#define HAVE_READLINE_HISTORY_H 1 + +/* Define to 1 if you have the <readline/readline.h> header file. */ +#define HAVE_READLINE_READLINE_H 1 + +/* Define to 1 if you have the `readlink' function. */ +#define HAVE_READLINK 1 + +/* Define to 1 if you have the global variable + 'rl_completion_append_character'. */ +#define HAVE_RL_COMPLETION_APPEND_CHARACTER 1 + +/* Define to 1 if you have the `rl_completion_matches' function. */ +#define HAVE_RL_COMPLETION_MATCHES 1 + +/* Define to 1 if you have the global variable 'rl_completion_suppress_quote'. + */ +#define HAVE_RL_COMPLETION_SUPPRESS_QUOTE 1 + +/* Define to 1 if you have the `rl_filename_completion_function' function. */ +#define HAVE_RL_FILENAME_COMPLETION_FUNCTION 1 + +/* Define to 1 if you have the global variable 'rl_filename_quote_characters'. + */ +#define HAVE_RL_FILENAME_QUOTE_CHARACTERS 1 + +/* Define to 1 if you have the global variable 'rl_filename_quoting_function'. + */ +#define HAVE_RL_FILENAME_QUOTING_FUNCTION 1 + +/* Define to 1 if you have the `rl_reset_screen_size' function. */ +#define HAVE_RL_RESET_SCREEN_SIZE 1 + +/* Define to 1 if you have the <security/pam_appl.h> header file. */ +/* #undef HAVE_SECURITY_PAM_APPL_H */ + +/* Define to 1 if you have the `setenv' function. */ +#define HAVE_SETENV 1 + +/* Define to 1 if you have the `setproctitle' function. */ +/* #undef HAVE_SETPROCTITLE */ + +/* Define to 1 if you have the `setproctitle_fast' function. */ +/* #undef HAVE_SETPROCTITLE_FAST */ + +/* Define to 1 if you have the `setsid' function. */ +#define HAVE_SETSID 1 + +/* Define to 1 if you have the `shm_open' function. */ +#define HAVE_SHM_OPEN 1 + +/* Define to 1 if you have spinlocks. */ +#define HAVE_SPINLOCKS 1 + +/* Define to 1 if you have the `srandom' function. */ +#define HAVE_SRANDOM 1 + +/* Define to 1 if stdbool.h conforms to C99. */ +#define HAVE_STDBOOL_H 1 + +/* Define to 1 if you have the <stdint.h> header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the <stdlib.h> header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the `strchrnul' function. */ +#define HAVE_STRCHRNUL 1 + +/* Define to 1 if you have the `strerror_r' function. */ +#define HAVE_STRERROR_R 1 + +/* Define to 1 if you have the <strings.h> header file. */ +#define HAVE_STRINGS_H 1 + +/* Define to 1 if you have the <string.h> header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the `strlcat' function. */ +/* #undef HAVE_STRLCAT */ + +/* Define to 1 if you have the `strlcpy' function. */ +/* #undef HAVE_STRLCPY */ + +/* Define to 1 if you have the `strnlen' function. */ +#define HAVE_STRNLEN 1 + +/* Define to 1 if you have the `strsignal' function. */ +#define HAVE_STRSIGNAL 1 + +/* Define to 1 if you have the `strtof' function. */ +#define HAVE_STRTOF 1 + +/* Define to 1 if you have the `strtoll' function. */ +#define HAVE_STRTOLL 1 + +/* Define to 1 if you have the `strtoq' function. */ +/* #undef HAVE_STRTOQ */ + +/* Define to 1 if you have the `strtoull' function. */ +#define HAVE_STRTOULL 1 + +/* Define to 1 if you have the `strtouq' function. */ +/* #undef HAVE_STRTOUQ */ + +/* Define to 1 if the system has the type `struct addrinfo'. */ +#define HAVE_STRUCT_ADDRINFO 1 + +/* Define to 1 if the system has the type `struct cmsgcred'. */ +/* #undef HAVE_STRUCT_CMSGCRED */ + +/* Define to 1 if the system has the type `struct option'. */ +#define HAVE_STRUCT_OPTION 1 + +/* Define to 1 if `sa_len' is a member of `struct sockaddr'. */ +/* #undef HAVE_STRUCT_SOCKADDR_SA_LEN */ + +/* Define to 1 if the system has the type `struct sockaddr_storage'. */ +#define HAVE_STRUCT_SOCKADDR_STORAGE 1 + +/* Define to 1 if `ss_family' is a member of `struct sockaddr_storage'. */ +#define HAVE_STRUCT_SOCKADDR_STORAGE_SS_FAMILY 1 + +/* Define to 1 if `ss_len' is a member of `struct sockaddr_storage'. */ +/* #undef HAVE_STRUCT_SOCKADDR_STORAGE_SS_LEN */ + +/* Define to 1 if `__ss_family' is a member of `struct sockaddr_storage'. */ +/* #undef HAVE_STRUCT_SOCKADDR_STORAGE___SS_FAMILY */ + +/* Define to 1 if `__ss_len' is a member of `struct sockaddr_storage'. */ +/* #undef HAVE_STRUCT_SOCKADDR_STORAGE___SS_LEN */ + +/* Define to 1 if the system has the type `struct sockaddr_un'. */ +#define HAVE_STRUCT_SOCKADDR_UN 1 + +/* Define to 1 if `tm_zone' is a member of `struct tm'. */ +#define HAVE_STRUCT_TM_TM_ZONE 1 + +/* Define to 1 if you have the `symlink' function. */ +#define HAVE_SYMLINK 1 + +/* Define to 1 if you have the `sync_file_range' function. */ +#define HAVE_SYNC_FILE_RANGE 1 + +/* Define to 1 if you have the syslog interface. */ +#define HAVE_SYSLOG 1 + +/* Define to 1 if you have the <sys/epoll.h> header file. */ +#define HAVE_SYS_EPOLL_H 1 + +/* Define to 1 if you have the <sys/event.h> header file. */ +/* #undef HAVE_SYS_EVENT_H */ + +/* Define to 1 if you have the <sys/ipc.h> header file. */ +#define HAVE_SYS_IPC_H 1 + +/* Define to 1 if you have the <sys/prctl.h> header file. */ +#define HAVE_SYS_PRCTL_H 1 + +/* Define to 1 if you have the <sys/procctl.h> header file. */ +/* #undef HAVE_SYS_PROCCTL_H */ + +/* Define to 1 if you have the <sys/pstat.h> header file. */ +/* #undef HAVE_SYS_PSTAT_H */ + +/* Define to 1 if you have the <sys/resource.h> header file. */ +#define HAVE_SYS_RESOURCE_H 1 + +/* Define to 1 if you have the <sys/select.h> header file. */ +#define HAVE_SYS_SELECT_H 1 + +/* Define to 1 if you have the <sys/sem.h> header file. */ +#define HAVE_SYS_SEM_H 1 + +/* Define to 1 if you have the <sys/shm.h> header file. */ +#define HAVE_SYS_SHM_H 1 + +/* Define to 1 if you have the <sys/sockio.h> header file. */ +/* #undef HAVE_SYS_SOCKIO_H */ + +/* Define to 1 if you have the <sys/stat.h> header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the <sys/tas.h> header file. */ +/* #undef HAVE_SYS_TAS_H */ + +/* Define to 1 if you have the <sys/types.h> header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the <sys/ucred.h> header file. */ +/* #undef HAVE_SYS_UCRED_H */ + +/* Define to 1 if you have the <sys/un.h> header file. */ +#define HAVE_SYS_UN_H 1 + +/* Define to 1 if you have the <termios.h> header file. */ +#define HAVE_TERMIOS_H 1 + +/* Define to 1 if your compiler understands `typeof' or something similar. */ +#define HAVE_TYPEOF 1 + +/* Define to 1 if you have the <ucred.h> header file. */ +/* #undef HAVE_UCRED_H */ + +/* Define to 1 if the system has the type `uint64'. */ +/* #undef HAVE_UINT64 */ + +/* Define to 1 if the system has the type `uint8'. */ +/* #undef HAVE_UINT8 */ + +/* Define to 1 if the system has the type `union semun'. */ +/* #undef HAVE_UNION_SEMUN */ + +/* Define to 1 if you have the <unistd.h> header file. */ +#define HAVE_UNISTD_H 1 + +/* Define to 1 if you have the `unsetenv' function. */ +#define HAVE_UNSETENV 1 + +/* Define to 1 if you have the `uselocale' function. */ +#define HAVE_USELOCALE 1 + +/* Define to 1 if you have BSD UUID support. */ +/* #undef HAVE_UUID_BSD */ + +/* Define to 1 if you have E2FS UUID support. */ +/* #undef HAVE_UUID_E2FS */ + +/* Define to 1 if you have the <uuid.h> header file. */ +#define HAVE_UUID_H 1 + +/* Define to 1 if you have OSSP UUID support. */ +#define HAVE_UUID_OSSP 1 + +/* Define to 1 if you have the <uuid/uuid.h> header file. */ +/* #undef HAVE_UUID_UUID_H */ + +/* Define to 1 if you have the `wcstombs_l' function. */ +/* #undef HAVE_WCSTOMBS_L */ + +/* Define to 1 if you have the <wctype.h> header file. */ +#define HAVE_WCTYPE_H 1 + +/* Define to 1 if you have the <winldap.h> header file. */ +/* #undef HAVE_WINLDAP_H */ + +/* Define to 1 if you have the `X509_get_signature_nid' function. */ +#define HAVE_X509_GET_SIGNATURE_NID 1 + +/* Define to 1 if the assembler supports X86_64's POPCNTQ instruction. */ +#define HAVE_X86_64_POPCNTQ 1 + +/* Define to 1 if the system has the type `_Bool'. */ +#define HAVE__BOOL 1 + +/* Define to 1 if your compiler understands __builtin_bswap16. */ +#define HAVE__BUILTIN_BSWAP16 1 + +/* Define to 1 if your compiler understands __builtin_bswap32. */ +#define HAVE__BUILTIN_BSWAP32 1 + +/* Define to 1 if your compiler understands __builtin_bswap64. */ +#define HAVE__BUILTIN_BSWAP64 1 + +/* Define to 1 if your compiler understands __builtin_clz. */ +#define HAVE__BUILTIN_CLZ 1 + +/* Define to 1 if your compiler understands __builtin_constant_p. */ +#define HAVE__BUILTIN_CONSTANT_P 1 + +/* Define to 1 if your compiler understands __builtin_ctz. */ +#define HAVE__BUILTIN_CTZ 1 + +/* Define to 1 if your compiler understands __builtin_$op_overflow. */ +#define HAVE__BUILTIN_OP_OVERFLOW 1 + +/* Define to 1 if your compiler understands __builtin_popcount. */ +#define HAVE__BUILTIN_POPCOUNT 1 + +/* Define to 1 if your compiler understands __builtin_types_compatible_p. */ +#define HAVE__BUILTIN_TYPES_COMPATIBLE_P 1 + +/* Define to 1 if your compiler understands __builtin_unreachable. */ +#define HAVE__BUILTIN_UNREACHABLE 1 + +/* Define to 1 if you have the `_configthreadlocale' function. */ +/* #undef HAVE__CONFIGTHREADLOCALE */ + +/* Define to 1 if you have __cpuid. */ +/* #undef HAVE__CPUID */ + +/* Define to 1 if you have __get_cpuid. */ +#define HAVE__GET_CPUID 1 + +/* Define to 1 if your compiler understands _Static_assert. */ +#define HAVE__STATIC_ASSERT 1 + +/* Define to 1 if you have the `__strtoll' function. */ +/* #undef HAVE___STRTOLL */ + +/* Define to 1 if you have the `__strtoull' function. */ +/* #undef HAVE___STRTOULL */ + +/* Define to the appropriate printf length modifier for 64-bit ints. */ +#define INT64_MODIFIER "l" + +/* Define to 1 if `locale_t' requires <xlocale.h>. */ +/* #undef LOCALE_T_IN_XLOCALE */ + +/* Define as the maximum alignment requirement of any C data type. */ +#define MAXIMUM_ALIGNOF 8 + +/* Define bytes to use libc memset(). */ +#define MEMSET_LOOP_LIMIT 1024 + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "pgsql-bugs@lists.postgresql.org" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "PostgreSQL" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "PostgreSQL 13.5" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "postgresql" + +/* Define to the home page for this package. */ +#define PACKAGE_URL "https://www.postgresql.org/" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "13.5" + +/* Define to the name of a signed 128-bit integer type. */ +#define PG_INT128_TYPE __int128 + +/* Define to the name of a signed 64-bit integer type. */ +#define PG_INT64_TYPE long int + +/* Define to the name of the default PostgreSQL service principal in Kerberos + (GSSAPI). (--with-krb-srvnam=NAME) */ +#define PG_KRB_SRVNAM "postgres" + +/* PostgreSQL major version as a string */ +#define PG_MAJORVERSION "13" + +/* PostgreSQL major version number */ +#define PG_MAJORVERSION_NUM 13 + +/* PostgreSQL minor version number */ +#define PG_MINORVERSION_NUM 5 + +/* Define to best printf format archetype, usually gnu_printf if available. */ +#define PG_PRINTF_ATTRIBUTE gnu_printf + +/* Define to 1 to use <stdbool.h> to define type bool. */ +#define PG_USE_STDBOOL 1 + +/* PostgreSQL version as a string */ +#define PG_VERSION "13.5" + +/* PostgreSQL version as a number */ +#define PG_VERSION_NUM 130005 + +/* A string containing the version number, platform, and C compiler */ +#define PG_VERSION_STR "PostgreSQL 13.5 on x86_64-pc-linux-gnu, compiled by gcc (GCC) 10.3.0, 64-bit" + +/* Define to 1 to allow profiling output to be saved separately for each + process. */ +/* #undef PROFILE_PID_DIR */ + +/* Define to necessary symbol if this constant uses a non-standard name on + your system. */ +/* #undef PTHREAD_CREATE_JOINABLE */ + +/* RELSEG_SIZE is the maximum number of blocks allowed in one disk file. Thus, + the maximum size of a single file is RELSEG_SIZE * BLCKSZ; relations bigger + than that are divided into multiple files. RELSEG_SIZE * BLCKSZ must be + less than your OS' limit on file size. This is often 2 GB or 4GB in a + 32-bit operating system, unless you have large file support enabled. By + default, we make the limit 1 GB to avoid any possible integer-overflow + problems within the OS. A limit smaller than necessary only means we divide + a large relation into more chunks than necessary, so it seems best to err + in the direction of a small limit. A power-of-2 value is recommended to + save a few cycles in md.c, but is not absolutely required. Changing + RELSEG_SIZE requires an initdb. */ +#define RELSEG_SIZE 131072 + +/* The size of `bool', as computed by sizeof. */ +#define SIZEOF_BOOL 1 + +/* The size of `long', as computed by sizeof. */ +#define SIZEOF_LONG 8 + +/* The size of `off_t', as computed by sizeof. */ +#define SIZEOF_OFF_T 8 + +/* The size of `size_t', as computed by sizeof. */ +#define SIZEOF_SIZE_T 8 + +/* The size of `void *', as computed by sizeof. */ +#define SIZEOF_VOID_P 8 + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Define to 1 if strerror_r() returns int. */ +/* #undef STRERROR_R_INT */ + +/* Define to 1 to use ARMv8 CRC Extension. */ +/* #undef USE_ARMV8_CRC32C */ + +/* Define to 1 to use ARMv8 CRC Extension with a runtime check. */ +/* #undef USE_ARMV8_CRC32C_WITH_RUNTIME_CHECK */ + +/* Define to 1 to build with assertion checks. (--enable-cassert) */ +/* #undef USE_ASSERT_CHECKING */ + +/* Define to 1 to build with Bonjour support. (--with-bonjour) */ +/* #undef USE_BONJOUR */ + +/* Define to 1 to build with BSD Authentication support. (--with-bsd-auth) */ +/* #undef USE_BSD_AUTH */ + +/* Define to use /dev/urandom for random number generation */ +/* #undef USE_DEV_URANDOM */ + +/* Define to build with ICU support. (--with-icu) */ +#define USE_ICU 1 + +/* Define to 1 to build with LDAP support. (--with-ldap) */ +/* #undef USE_LDAP */ + +/* Define to 1 to build with XML support. (--with-libxml) */ +#define USE_LIBXML 1 + +/* Define to 1 to use XSLT support when building contrib/xml2. + (--with-libxslt) */ +/* #undef USE_LIBXSLT */ + +/* Define to 1 to build with LLVM based JIT support. (--with-llvm) */ +/* #undef USE_LLVM */ + +/* Define to select named POSIX semaphores. */ +/* #undef USE_NAMED_POSIX_SEMAPHORES */ + +/* Define to build with OpenSSL support. (--with-openssl) */ +#define USE_OPENSSL 1 + +/* Define to use OpenSSL for random number generation */ +#define USE_OPENSSL_RANDOM 1 + +/* Define to 1 to build with PAM support. (--with-pam) */ +/* #undef USE_PAM */ + +/* Define to 1 to use software CRC-32C implementation (slicing-by-8). */ +/* #undef USE_SLICING_BY_8_CRC32C */ + +/* Define to 1 use Intel SSE 4.2 CRC instructions. */ +/* #undef USE_SSE42_CRC32C */ + +/* Define to 1 to use Intel SSE 4.2 CRC instructions with a runtime check. */ +#define USE_SSE42_CRC32C_WITH_RUNTIME_CHECK 1 + +/* Define to build with systemd support. (--with-systemd) */ +/* #undef USE_SYSTEMD */ + +/* Define to select SysV-style semaphores. */ +/* #undef USE_SYSV_SEMAPHORES */ + +/* Define to select SysV-style shared memory. */ +#define USE_SYSV_SHARED_MEMORY 1 + +/* Define to select unnamed POSIX semaphores. */ +#define USE_UNNAMED_POSIX_SEMAPHORES 1 + +/* Define to use native Windows API for random number generation */ +/* #undef USE_WIN32_RANDOM */ + +/* Define to select Win32-style semaphores. */ +/* #undef USE_WIN32_SEMAPHORES */ + +/* Define to select Win32-style shared memory. */ +/* #undef USE_WIN32_SHARED_MEMORY */ + +/* Define to 1 if `wcstombs_l' requires <xlocale.h>. */ +/* #undef WCSTOMBS_L_IN_XLOCALE */ + +/* Define WORDS_BIGENDIAN to 1 if your processor stores words with the most + significant byte first (like Motorola and SPARC, unlike Intel). */ +#if defined AC_APPLE_UNIVERSAL_BUILD +# if defined __BIG_ENDIAN__ +# define WORDS_BIGENDIAN 1 +# endif +#else +# ifndef WORDS_BIGENDIAN +/* # undef WORDS_BIGENDIAN */ +# endif +#endif + +/* Size of a WAL file block. This need have no particular relation to BLCKSZ. + XLOG_BLCKSZ must be a power of 2, and if your system supports O_DIRECT I/O, + XLOG_BLCKSZ must be a multiple of the alignment requirement for direct-I/O + buffers, else direct I/O may fail. Changing XLOG_BLCKSZ requires an initdb. + */ +#define XLOG_BLCKSZ 8192 + + + +/* Number of bits in a file offset, on hosts where this is settable. */ +/* #undef _FILE_OFFSET_BITS */ + +/* Define to 1 to make fseeko visible on some hosts (e.g. glibc 2.2). */ +/* #undef _LARGEFILE_SOURCE */ + +/* Define for large files, on AIX-style hosts. */ +/* #undef _LARGE_FILES */ + +/* Define to `__inline__' or `__inline' if that's what the C compiler + calls it, or to nothing if 'inline' is not supported under any name. */ +#ifndef __cplusplus +/* #undef inline */ +#endif + +/* Define to keyword to use for C99 restrict support, or to nothing if not + supported */ +#define pg_restrict __restrict + +/* Define to the equivalent of the C99 'restrict' keyword, or to + nothing if this is not supported. Do not define if restrict is + supported directly. */ +#define restrict __restrict +/* Work around a bug in Sun C++: it does not support _Restrict or + __restrict__, even though the corresponding Sun C compiler ends up with + "#define restrict _Restrict" or "#define restrict __restrict__" in the + previous line. Perhaps some future version of Sun C++ will work with + restrict; if so, hopefully it defines __RESTRICT like Sun C does. */ +#if defined __SUNPRO_CC && !defined __RESTRICT +# define _Restrict +# define __restrict__ +#endif + +/* Define to how the compiler spells `typeof'. */ +/* #undef typeof */ diff --git a/contrib/libs/postgresql/src/include/pg_config-osx.h b/contrib/libs/postgresql/src/include/pg_config-osx.h new file mode 100644 index 0000000000..7ffb92c467 --- /dev/null +++ b/contrib/libs/postgresql/src/include/pg_config-osx.h @@ -0,0 +1,31 @@ +#pragma once + +#include "pg_config-linux.h" + +/* Define to 1 if you have the declaration of `strlcat', and to 0 if you + don't. */ +#undef HAVE_DECL_STRLCAT +#define HAVE_DECL_STRLCAT 1 + +/* Define to 1 if you have the declaration of `strlcpy', and to 0 if you + don't. */ +#undef HAVE_DECL_STRLCPY +#define HAVE_DECL_STRLCPY 1 + +/* Define to 1 if the system has the type `locale_t'. */ +#undef HAVE_LOCALE_T + +/* Define to 1 if you have the <sys/prctl.h> header file. */ +#undef HAVE_SYS_PRCTL_H + +/* Define to 1 if you have the `sync_file_range' function. */ +#undef HAVE_SYNC_FILE_RANGE + +/* Define to 1 if you have the <sys/ucred.h> header file. */ +#define HAVE_SYS_UCRED_H 1 + +/* Define to 1 if you have the <sys/epoll.h> header file. */ +#undef HAVE_SYS_EPOLL_H + +/* Define to 1 if you have the `strchrnul' function. */ +#undef HAVE_STRCHRNUL
\ No newline at end of file diff --git a/contrib/libs/postgresql/src/include/pg_config-win.h b/contrib/libs/postgresql/src/include/pg_config-win.h new file mode 100644 index 0000000000..ed526bebfd --- /dev/null +++ b/contrib/libs/postgresql/src/include/pg_config-win.h @@ -0,0 +1,173 @@ +#pragma once + +#include "pg_config-linux.h" + +/* Define to 1 if you have the <strings.h> header file. */ +#undef HAVE_STRINGS_H + +/* Define to 1 if you have the <sys/un.h> header file. */ +#undef HAVE_SYS_UN_H + +/* Define to 1 if you have the <termios.h> header file. */ +#undef HAVE_TERMIOS_H + +/* Define to 1 if you have the `inet_aton' function. */ +#undef HAVE_INET_ATON + +/* Define to 1 if you have the <sys/select.h> header file. */ +#undef HAVE_SYS_SELECT_H + +/* Define to 1 if you have the <sys/prctl.h> header file. */ +#undef HAVE_SYS_PRCTL_H + +/* Define to 1 if you have the <netinet/tcp.h> header file. */ +#undef HAVE_NETINET_TCP_H + +/* Define to 1 if you have the <sys/resource.h> header file. */ +#undef HAVE_SYS_RESOURCE_H + +/* Define to 1 if you have the `dlopen' function. */ +#undef HAVE_DLOPEN + +/* Define to 1 if you have the syslog interface. */ +#undef HAVE_SYSLOG + +/* Define to 1 if you have the <getopt.h> header file. */ +#undef HAVE_GETOPT_H + +/* Define to 1 if you have the <execinfo.h> header file. */ +#undef HAVE_EXECINFO_H + +/* Define to 1 if you have the `sync_file_range' function. */ +#undef HAVE_SYNC_FILE_RANGE + +/* Define to 1 if you have the <sys/epoll.h> header file. */ +#undef HAVE_SYS_EPOLL_H + +/* Define to 1 if you have the <poll.h> header file. */ +#undef HAVE_POLL_H + +/* Define to 1 if you have the `poll' function. */ +#undef HAVE_POLL + +/* Define to 1 if you have the <sys/ipc.h> header file. */ +#undef HAVE_SYS_IPC_H + +/* Define to 1 if you have the <langinfo.h> header file. */ +#undef HAVE_LANGINFO_H + +/* Define to 1 if you have the <sys/shm.h> header file. */ +#undef HAVE_SYS_SHM_H + +/* Define to 1 if the assembler supports X86_64's POPCNTQ instruction. */ +#undef HAVE_X86_64_POPCNTQ + +/* Define to 1 if you have the declaration of `RTLD_GLOBAL', and to 0 if you + don't. */ +#undef HAVE_DECL_RTLD_GLOBAL + +/* Define to 1 if you have the declaration of `RTLD_NOW', and to 0 if you + don't. */ +#undef HAVE_DECL_RTLD_NOW + +/* Define to 1 if you have the `getrlimit' function. */ +#undef HAVE_GETRLIMIT + +/* Define to 1 if you have the `getrusage' function. */ +#undef HAVE_GETRUSAGE + +/* Define to 1 if your compiler understands _Static_assert. */ +#undef HAVE__STATIC_ASSERT + +/* Define to 1 if you have the global variable 'int opterr'. */ +#undef HAVE_INT_OPTERR + +/* Define to 1 if you have the `strchrnul' function. */ +#undef HAVE_STRCHRNUL + +/* Define to 1 if you have the `backtrace_symbols' function. */ +#undef HAVE_BACKTRACE_SYMBOLS + +/* Define to 1 if you have the `setsid' function. */ +#undef HAVE_SETSID + +/* Define to 1 if you have the `fdatasync' function. */ +#undef HAVE_FDATASYNC + +/* Define to 1 if the system has the type `locale_t'. */ +#undef HAVE_LOCALE_T + +/* Define to 1 if you have the `strerror_r' function. */ +#undef HAVE_STRERROR_R + +/* Define to 1 if you have the `getaddrinfo' function. */ +#undef HAVE_GETADDRINFO + +/* Define to use OpenSSL for random number generation */ +#undef USE_OPENSSL_RANDOM + +/* Define to use native Windows API for random number generation */ +#define USE_WIN32_RANDOM 1 + +/* Define to 1 if the system has the type `_Bool'. */ +#undef HAVE__BOOL + +/* Define to 1 if your compiler understands __builtin_bswap16. */ +#undef HAVE__BUILTIN_BSWAP16 + +/* Define to 1 if your compiler understands __builtin_bswap32. */ +#undef HAVE__BUILTIN_BSWAP32 + +/* Define to 1 if your compiler understands __builtin_bswap64. */ +#undef HAVE__BUILTIN_BSWAP64 + +/* Define to 1 if your compiler understands __builtin_clz. */ +#undef HAVE__BUILTIN_CLZ + +/* Define to 1 if your compiler understands __builtin_constant_p. */ +#undef HAVE__BUILTIN_CONSTANT_P + +/* Define to 1 if your compiler understands __builtin_ctz. */ +#undef HAVE__BUILTIN_CTZ + +/* Define to 1 if your compiler understands __builtin_$op_overflow. */ +#undef HAVE__BUILTIN_OP_OVERFLOW + +/* Define to 1 if your compiler understands __builtin_popcount. */ +#undef HAVE__BUILTIN_POPCOUNT + +/* Define to 1 if your compiler understands __builtin_types_compatible_p. */ +#undef HAVE__BUILTIN_TYPES_COMPATIBLE_P + +/* Define to 1 if your compiler understands __builtin_unreachable. */ +#undef HAVE__BUILTIN_UNREACHABLE + +/* Define to 1 if you have the `_configthreadlocale' function. */ +#define HAVE__CONFIGTHREADLOCALE 1 + +/* Define to 1 if you have __cpuid. */ +#define HAVE__CPUID 1 + +/* Define to 1 if you have __get_cpuid. */ +#undef HAVE__GET_CPUID + +/* Define to 1 if your compiler understands `typeof' or something similar. */ +#undef HAVE_TYPEOF + +/* Define to 1 if your compiler handles computed gotos. */ +#undef HAVE_COMPUTED_GOTO + +/* Define to 1 if you have the `readlink' function. */ +#undef HAVE_READLINK + + + +/* PostgreSQL's CFLAG for windows. */ +#define WIN32_STACK_RLIMIT 4194304 + +/* NO GOOD WAY WAS FOUND TO PROVIDE DEFINITIONS FOR random AND srandom. */ +/* rand is PostgreSQL's implementation of random from stdlib.h for windows. */ +#define random rand + +/* srand is PostgreSQL's implementation of srandom from stdlib.h for windows. */ +#define srandom srand diff --git a/contrib/libs/postgresql/src/include/pg_config.h b/contrib/libs/postgresql/src/include/pg_config.h new file mode 100644 index 0000000000..d18cad5285 --- /dev/null +++ b/contrib/libs/postgresql/src/include/pg_config.h @@ -0,0 +1,9 @@ +#pragma once + +#if defined(__APPLE__) +# include "pg_config-osx.h" +#elif defined(_MSC_VER) +# include "pg_config-win.h" +#else +# include "pg_config-linux.h" +#endif diff --git a/contrib/libs/postgresql/src/include/pg_config_ext.h b/contrib/libs/postgresql/src/include/pg_config_ext.h new file mode 100644 index 0000000000..b4c07dd857 --- /dev/null +++ b/contrib/libs/postgresql/src/include/pg_config_ext.h @@ -0,0 +1,8 @@ +/* src/include/pg_config_ext.h. Generated from pg_config_ext.h.in by configure. */ +/* + * src/include/pg_config_ext.h.in. This is generated manually, not by + * autoheader, since we want to limit which symbols get defined here. + */ + +/* Define to the name of a signed 64-bit integer type. */ +#define PG_INT64_TYPE long int diff --git a/contrib/libs/postgresql/src/include/pg_config_manual.h b/contrib/libs/postgresql/src/include/pg_config_manual.h new file mode 100644 index 0000000000..91818326a4 --- /dev/null +++ b/contrib/libs/postgresql/src/include/pg_config_manual.h @@ -0,0 +1,357 @@ +/*------------------------------------------------------------------------ + * PostgreSQL manual configuration settings + * + * This file contains various configuration symbols and limits. In + * all cases, changing them is only useful in very rare situations or + * for developers. If you edit any of these, be sure to do a *full* + * rebuild (and an initdb if noted). + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/pg_config_manual.h + *------------------------------------------------------------------------ + */ + +/* + * This is the default value for wal_segment_size to be used when initdb is run + * without the --wal-segsize option. It must be a valid segment size. + */ +#define DEFAULT_XLOG_SEG_SIZE (16*1024*1024) + +/* + * Maximum length for identifiers (e.g. table names, column names, + * function names). Names actually are limited to one less byte than this, + * because the length must include a trailing zero byte. + * + * Changing this requires an initdb. + */ +#define NAMEDATALEN 64 + +/* + * Maximum number of arguments to a function. + * + * The minimum value is 8 (GIN indexes use 8-argument support functions). + * The maximum possible value is around 600 (limited by index tuple size in + * pg_proc's index; BLCKSZ larger than 8K would allow more). Values larger + * than needed will waste memory and processing time, but do not directly + * cost disk space. + * + * Changing this does not require an initdb, but it does require a full + * backend recompile (including any user-defined C functions). + */ +#define FUNC_MAX_ARGS 100 + +/* + * Maximum number of columns in an index. There is little point in making + * this anything but a multiple of 32, because the main cost is associated + * with index tuple header size (see access/itup.h). + * + * Changing this requires an initdb. + */ +#define INDEX_MAX_KEYS 32 + +/* + * Maximum number of columns in a partition key + */ +#define PARTITION_MAX_KEYS 32 + +/* + * Decide whether built-in 8-byte types, including float8, int8, and + * timestamp, are passed by value. This is on by default if sizeof(Datum) >= + * 8 (that is, on 64-bit platforms). If sizeof(Datum) < 8 (32-bit platforms), + * this must be off. We keep this here as an option so that it is easy to + * test the pass-by-reference code paths on 64-bit platforms. + * + * Changing this requires an initdb. + */ +#if SIZEOF_VOID_P >= 8 +#define USE_FLOAT8_BYVAL 1 +#endif + +/* + * When we don't have native spinlocks, we use semaphores to simulate them. + * Decreasing this value reduces consumption of OS resources; increasing it + * may improve performance, but supplying a real spinlock implementation is + * probably far better. + */ +#define NUM_SPINLOCK_SEMAPHORES 128 + +/* + * When we have neither spinlocks nor atomic operations support we're + * implementing atomic operations on top of spinlock on top of semaphores. To + * be safe against atomic operations while holding a spinlock separate + * semaphores have to be used. + */ +#define NUM_ATOMICS_SEMAPHORES 64 + +/* + * MAXPGPATH: standard size of a pathname buffer in PostgreSQL (hence, + * maximum usable pathname length is one less). + * + * We'd use a standard system header symbol for this, if there weren't + * so many to choose from: MAXPATHLEN, MAX_PATH, PATH_MAX are all + * defined by different "standards", and often have different values + * on the same platform! So we just punt and use a reasonably + * generous setting here. + */ +#define MAXPGPATH 1024 + +/* + * PG_SOMAXCONN: maximum accept-queue length limit passed to + * listen(2). You'd think we should use SOMAXCONN from + * <sys/socket.h>, but on many systems that symbol is much smaller + * than the kernel's actual limit. In any case, this symbol need be + * twiddled only if you have a kernel that refuses large limit values, + * rather than silently reducing the value to what it can handle + * (which is what most if not all Unixen do). + */ +#define PG_SOMAXCONN 10000 + +/* + * You can try changing this if you have a machine with bytes of + * another size, but no guarantee... + */ +#define BITS_PER_BYTE 8 + +/* + * Preferred alignment for disk I/O buffers. On some CPUs, copies between + * user space and kernel space are significantly faster if the user buffer + * is aligned on a larger-than-MAXALIGN boundary. Ideally this should be + * a platform-dependent value, but for now we just hard-wire it. + */ +#define ALIGNOF_BUFFER 32 + +/* + * If EXEC_BACKEND is defined, the postmaster uses an alternative method for + * starting subprocesses: Instead of simply using fork(), as is standard on + * Unix platforms, it uses fork()+exec() or something equivalent on Windows, + * as well as lots of extra code to bring the required global state to those + * new processes. This must be enabled on Windows (because there is no + * fork()). On other platforms, it's only useful for verifying those + * otherwise Windows-specific code paths. + */ +#if defined(WIN32) && !defined(__CYGWIN__) +#define EXEC_BACKEND +#endif + +/* + * Define this if your operating system supports link() + */ +#if !defined(WIN32) && !defined(__CYGWIN__) +#define HAVE_WORKING_LINK 1 +#endif + +/* + * USE_POSIX_FADVISE controls whether Postgres will attempt to use the + * posix_fadvise() kernel call. Usually the automatic configure tests are + * sufficient, but some older Linux distributions had broken versions of + * posix_fadvise(). If necessary you can remove the #define here. + */ +#if HAVE_DECL_POSIX_FADVISE && defined(HAVE_POSIX_FADVISE) +#define USE_POSIX_FADVISE +#endif + +/* + * USE_PREFETCH code should be compiled only if we have a way to implement + * prefetching. (This is decoupled from USE_POSIX_FADVISE because there + * might in future be support for alternative low-level prefetch APIs. + * If you change this, you probably need to adjust the error message in + * check_effective_io_concurrency.) + */ +#ifdef USE_POSIX_FADVISE +#define USE_PREFETCH +#endif + +/* + * Default and maximum values for backend_flush_after, bgwriter_flush_after + * and checkpoint_flush_after; measured in blocks. Currently, these are + * enabled by default if sync_file_range() exists, ie, only on Linux. Perhaps + * we could also enable by default if we have mmap and msync(MS_ASYNC)? + */ +#ifdef HAVE_SYNC_FILE_RANGE +#define DEFAULT_BACKEND_FLUSH_AFTER 0 /* never enabled by default */ +#define DEFAULT_BGWRITER_FLUSH_AFTER 64 +#define DEFAULT_CHECKPOINT_FLUSH_AFTER 32 +#else +#define DEFAULT_BACKEND_FLUSH_AFTER 0 +#define DEFAULT_BGWRITER_FLUSH_AFTER 0 +#define DEFAULT_CHECKPOINT_FLUSH_AFTER 0 +#endif +/* upper limit for all three variables */ +#define WRITEBACK_MAX_PENDING_FLUSHES 256 + +/* + * USE_SSL code should be compiled only when compiling with an SSL + * implementation. (Currently, only OpenSSL is supported, but we might add + * more implementations in the future.) + */ +#ifdef USE_OPENSSL +#define USE_SSL +#endif + +/* + * This is the default directory in which AF_UNIX socket files are + * placed. Caution: changing this risks breaking your existing client + * applications, which are likely to continue to look in the old + * directory. But if you just hate the idea of sockets in /tmp, + * here's where to twiddle it. You can also override this at runtime + * with the postmaster's -k switch. + * + * If set to an empty string, then AF_UNIX sockets are not used by default: A + * server will not create an AF_UNIX socket unless the run-time configuration + * is changed, a client will connect via TCP/IP by default and will only use + * an AF_UNIX socket if one is explicitly specified. + * + * This is done by default on Windows because there is no good standard + * location for AF_UNIX sockets and many installations on Windows don't + * support them yet. + */ +#ifndef WIN32 +#define DEFAULT_PGSOCKET_DIR "/run/postgresql" +#else +#define DEFAULT_PGSOCKET_DIR "" +#endif + +/* + * This is the default event source for Windows event log. + */ +#define DEFAULT_EVENT_SOURCE "PostgreSQL" + +/* + * The random() function is expected to yield values between 0 and + * MAX_RANDOM_VALUE. Currently, all known implementations yield + * 0..2^31-1, so we just hardwire this constant. We could do a + * configure test if it proves to be necessary. CAUTION: Think not to + * replace this with RAND_MAX. RAND_MAX defines the maximum value of + * the older rand() function, which is often different from --- and + * considerably inferior to --- random(). + */ +#define MAX_RANDOM_VALUE PG_INT32_MAX + +/* + * On PPC machines, decide whether to use the mutex hint bit in LWARX + * instructions. Setting the hint bit will slightly improve spinlock + * performance on POWER6 and later machines, but does nothing before that, + * and will result in illegal-instruction failures on some pre-POWER4 + * machines. By default we use the hint bit when building for 64-bit PPC, + * which should be safe in nearly all cases. You might want to override + * this if you are building 32-bit code for a known-recent PPC machine. + */ +#ifdef HAVE_PPC_LWARX_MUTEX_HINT /* must have assembler support in any case */ +#if defined(__ppc64__) || defined(__powerpc64__) +#define USE_PPC_LWARX_MUTEX_HINT +#endif +#endif + +/* + * On PPC machines, decide whether to use LWSYNC instructions in place of + * ISYNC and SYNC. This provides slightly better performance, but will + * result in illegal-instruction failures on some pre-POWER4 machines. + * By default we use LWSYNC when building for 64-bit PPC, which should be + * safe in nearly all cases. + */ +#if defined(__ppc64__) || defined(__powerpc64__) +#define USE_PPC_LWSYNC +#endif + +/* + * Assumed cache line size. This doesn't affect correctness, but can be used + * for low-level optimizations. Currently, this is used to pad some data + * structures in xlog.c, to ensure that highly-contended fields are on + * different cache lines. Too small a value can hurt performance due to false + * sharing, while the only downside of too large a value is a few bytes of + * wasted memory. The default is 128, which should be large enough for all + * supported platforms. + */ +#define PG_CACHE_LINE_SIZE 128 + +/* + *------------------------------------------------------------------------ + * The following symbols are for enabling debugging code, not for + * controlling user-visible features or resource limits. + *------------------------------------------------------------------------ + */ + +/* + * Include Valgrind "client requests", mostly in the memory allocator, so + * Valgrind understands PostgreSQL memory contexts. This permits detecting + * memory errors that Valgrind would not detect on a vanilla build. See also + * src/tools/valgrind.supp. "make installcheck" runs 20-30x longer under + * Valgrind. Note that USE_VALGRIND slowed older versions of Valgrind by an + * additional order of magnitude; Valgrind 3.8.1 does not have this problem. + * The client requests fall in hot code paths, so USE_VALGRIND also slows + * native execution by a few percentage points. + * + * You should normally use MEMORY_CONTEXT_CHECKING with USE_VALGRIND; + * instrumentation of repalloc() is inferior without it. + */ +/* #define USE_VALGRIND */ + +/* + * Define this to cause pfree()'d memory to be cleared immediately, to + * facilitate catching bugs that refer to already-freed values. + * Right now, this gets defined automatically if --enable-cassert. + */ +#ifdef USE_ASSERT_CHECKING +#define CLOBBER_FREED_MEMORY +#endif + +/* + * Define this to check memory allocation errors (scribbling on more + * bytes than were allocated). Right now, this gets defined + * automatically if --enable-cassert or USE_VALGRIND. + */ +#if defined(USE_ASSERT_CHECKING) || defined(USE_VALGRIND) +#define MEMORY_CONTEXT_CHECKING +#endif + +/* + * Define this to cause palloc()'d memory to be filled with random data, to + * facilitate catching code that depends on the contents of uninitialized + * memory. Caution: this is horrendously expensive. + */ +/* #define RANDOMIZE_ALLOCATED_MEMORY */ + +/* + * Define this to force all parse and plan trees to be passed through + * copyObject(), to facilitate catching errors and omissions in + * copyObject(). + */ +/* #define COPY_PARSE_PLAN_TREES */ + +/* + * Define this to force all parse and plan trees to be passed through + * outfuncs.c/readfuncs.c, to facilitate catching errors and omissions in + * those modules. + */ +/* #define WRITE_READ_PARSE_PLAN_TREES */ + +/* + * Define this to force all raw parse trees for DML statements to be scanned + * by raw_expression_tree_walker(), to facilitate catching errors and + * omissions in that function. + */ +/* #define RAW_EXPRESSION_COVERAGE_TEST */ + +/* + * Enable debugging print statements for lock-related operations. + */ +/* #define LOCK_DEBUG */ + +/* + * Enable debugging print statements for WAL-related operations; see + * also the wal_debug GUC var. + */ +/* #define WAL_DEBUG */ + +/* + * Enable tracing of resource consumption during sort operations; + * see also the trace_sort GUC var. For 8.1 this is enabled by default. + */ +#define TRACE_SORT 1 + +/* + * Enable tracing of syncscan operations (see also the trace_syncscan GUC var). + */ +/* #define TRACE_SYNCSCAN */ diff --git a/contrib/libs/postgresql/src/include/pg_config_os-linux.h b/contrib/libs/postgresql/src/include/pg_config_os-linux.h new file mode 100644 index 0000000000..331e1b2cf1 --- /dev/null +++ b/contrib/libs/postgresql/src/include/pg_config_os-linux.h @@ -0,0 +1 @@ +#include <contrib/libs/libpq/src/include/port/linux.h> diff --git a/contrib/libs/postgresql/src/include/pg_config_os-osx.h b/contrib/libs/postgresql/src/include/pg_config_os-osx.h new file mode 100644 index 0000000000..f77fb9d4da --- /dev/null +++ b/contrib/libs/postgresql/src/include/pg_config_os-osx.h @@ -0,0 +1 @@ +#include <contrib/libs/libpq/src/include/port/darwin.h> diff --git a/contrib/libs/postgresql/src/include/pg_config_os-win.h b/contrib/libs/postgresql/src/include/pg_config_os-win.h new file mode 100644 index 0000000000..e26ba92209 --- /dev/null +++ b/contrib/libs/postgresql/src/include/pg_config_os-win.h @@ -0,0 +1 @@ +#include <contrib/libs/libpq/src/include/port/win32.h> diff --git a/contrib/libs/postgresql/src/include/pg_config_os.h b/contrib/libs/postgresql/src/include/pg_config_os.h new file mode 100644 index 0000000000..86db251be2 --- /dev/null +++ b/contrib/libs/postgresql/src/include/pg_config_os.h @@ -0,0 +1,9 @@ +#pragma once + +#if defined(__APPLE__) +# include "pg_config_os-osx.h" +#elif defined(_MSC_VER) +# include "pg_config_os-win.h" +#else +# include "pg_config_os-linux.h" +#endif diff --git a/contrib/libs/postgresql/src/include/pg_getopt.h b/contrib/libs/postgresql/src/include/pg_getopt.h new file mode 100644 index 0000000000..e646fc3419 --- /dev/null +++ b/contrib/libs/postgresql/src/include/pg_getopt.h @@ -0,0 +1,56 @@ +/* + * Postgres files that use getopt(3) always include this file. + * We must cope with three different scenarios: + * 1. We're using the platform's getopt(), and we should just import the + * appropriate declarations. + * 2. The platform lacks getopt(), and we must declare everything. + * 3. The platform has getopt(), but we're not using it because we don't + * like its behavior. The declarations we make here must be compatible + * with both the platform's getopt() and our src/port/getopt.c. + * + * Portions Copyright (c) 1987, 1993, 1994 + * The Regents of the University of California. All rights reserved. + * + * Portions Copyright (c) 2003-2020, PostgreSQL Global Development Group + * + * src/include/pg_getopt.h + */ +#ifndef PG_GETOPT_H +#define PG_GETOPT_H + +/* POSIX says getopt() is provided by unistd.h */ +#include <unistd.h> + +/* rely on the system's getopt.h if present */ +#ifdef HAVE_GETOPT_H +#include <getopt.h> +#endif + +/* + * If we have <getopt.h>, assume it declares these variables, else do that + * ourselves. (We used to just declare them unconditionally, but Cygwin + * doesn't like that.) + */ +#ifndef HAVE_GETOPT_H + +extern char *optarg; +extern int optind; +extern int opterr; +extern int optopt; + +#endif /* HAVE_GETOPT_H */ + +/* + * Some platforms have optreset but fail to declare it in <getopt.h>, so cope. + * Cygwin, however, doesn't like this either. + */ +#if defined(HAVE_INT_OPTRESET) && !defined(__CYGWIN__) +extern int optreset; +#endif + +/* Provide getopt() declaration if the platform doesn't have it */ +#ifndef HAVE_GETOPT +extern int getopt(int nargc, char *const *nargv, const char *ostr); +#endif + +#endif /* PG_GETOPT_H */ diff --git a/contrib/libs/postgresql/src/include/pg_trace.h b/contrib/libs/postgresql/src/include/pg_trace.h new file mode 100644 index 0000000000..cf212aeabd --- /dev/null +++ b/contrib/libs/postgresql/src/include/pg_trace.h @@ -0,0 +1,17 @@ +/* ---------- + * pg_trace.h + * + * Definitions for the PostgreSQL tracing framework + * + * Copyright (c) 2006-2020, PostgreSQL Global Development Group + * + * src/include/pg_trace.h + * ---------- + */ + +#ifndef PG_TRACE_H +#define PG_TRACE_H + +#include "utils/probes.h" /* pgrminclude ignore */ + +#endif /* PG_TRACE_H */ diff --git a/contrib/libs/postgresql/src/include/pgstat.h b/contrib/libs/postgresql/src/include/pgstat.h new file mode 100644 index 0000000000..c55dc1481c --- /dev/null +++ b/contrib/libs/postgresql/src/include/pgstat.h @@ -0,0 +1,1487 @@ +/* ---------- + * pgstat.h + * + * Definitions for the PostgreSQL statistics collector daemon. + * + * Copyright (c) 2001-2020, PostgreSQL Global Development Group + * + * src/include/pgstat.h + * ---------- + */ +#ifndef PGSTAT_H +#define PGSTAT_H + +#include "datatype/timestamp.h" +#include "libpq/pqcomm.h" +#include "miscadmin.h" +#include "port/atomics.h" +#include "portability/instr_time.h" +#include "postmaster/pgarch.h" +#include "storage/proc.h" +#include "utils/hsearch.h" +#include "utils/relcache.h" + + +/* ---------- + * Paths for the statistics files (relative to installation's $PGDATA). + * ---------- + */ +#define PGSTAT_STAT_PERMANENT_DIRECTORY "pg_stat" +#define PGSTAT_STAT_PERMANENT_FILENAME "pg_stat/global.stat" +#define PGSTAT_STAT_PERMANENT_TMPFILE "pg_stat/global.tmp" + +/* Default directory to store temporary statistics data in */ +#define PG_STAT_TMP_DIR "pg_stat_tmp" + +/* Values for track_functions GUC variable --- order is significant! */ +typedef enum TrackFunctionsLevel +{ + TRACK_FUNC_OFF, + TRACK_FUNC_PL, + TRACK_FUNC_ALL +} TrackFunctionsLevel; + +/* ---------- + * The types of backend -> collector messages + * ---------- + */ +typedef enum StatMsgType +{ + PGSTAT_MTYPE_DUMMY, + PGSTAT_MTYPE_INQUIRY, + PGSTAT_MTYPE_TABSTAT, + PGSTAT_MTYPE_TABPURGE, + PGSTAT_MTYPE_DROPDB, + PGSTAT_MTYPE_RESETCOUNTER, + PGSTAT_MTYPE_RESETSHAREDCOUNTER, + PGSTAT_MTYPE_RESETSINGLECOUNTER, + PGSTAT_MTYPE_RESETSLRUCOUNTER, + PGSTAT_MTYPE_AUTOVAC_START, + PGSTAT_MTYPE_VACUUM, + PGSTAT_MTYPE_ANALYZE, + PGSTAT_MTYPE_ARCHIVER, + PGSTAT_MTYPE_BGWRITER, + PGSTAT_MTYPE_SLRU, + PGSTAT_MTYPE_FUNCSTAT, + PGSTAT_MTYPE_FUNCPURGE, + PGSTAT_MTYPE_RECOVERYCONFLICT, + PGSTAT_MTYPE_TEMPFILE, + PGSTAT_MTYPE_DEADLOCK, + PGSTAT_MTYPE_CHECKSUMFAILURE +} StatMsgType; + +/* ---------- + * The data type used for counters. + * ---------- + */ +typedef int64 PgStat_Counter; + +/* ---------- + * PgStat_TableCounts The actual per-table counts kept by a backend + * + * This struct should contain only actual event counters, because we memcmp + * it against zeroes to detect whether there are any counts to transmit. + * It is a component of PgStat_TableStatus (within-backend state) and + * PgStat_TableEntry (the transmitted message format). + * + * Note: for a table, tuples_returned is the number of tuples successfully + * fetched by heap_getnext, while tuples_fetched is the number of tuples + * successfully fetched by heap_fetch under the control of bitmap indexscans. + * For an index, tuples_returned is the number of index entries returned by + * the index AM, while tuples_fetched is the number of tuples successfully + * fetched by heap_fetch under the control of simple indexscans for this index. + * + * tuples_inserted/updated/deleted/hot_updated count attempted actions, + * regardless of whether the transaction committed. delta_live_tuples, + * delta_dead_tuples, and changed_tuples are set depending on commit or abort. + * Note that delta_live_tuples and delta_dead_tuples can be negative! + * ---------- + */ +typedef struct PgStat_TableCounts +{ + PgStat_Counter t_numscans; + + PgStat_Counter t_tuples_returned; + PgStat_Counter t_tuples_fetched; + + PgStat_Counter t_tuples_inserted; + PgStat_Counter t_tuples_updated; + PgStat_Counter t_tuples_deleted; + PgStat_Counter t_tuples_hot_updated; + bool t_truncated; + + PgStat_Counter t_delta_live_tuples; + PgStat_Counter t_delta_dead_tuples; + PgStat_Counter t_changed_tuples; + + PgStat_Counter t_blocks_fetched; + PgStat_Counter t_blocks_hit; +} PgStat_TableCounts; + +/* Possible targets for resetting cluster-wide shared values */ +typedef enum PgStat_Shared_Reset_Target +{ + RESET_ARCHIVER, + RESET_BGWRITER +} PgStat_Shared_Reset_Target; + +/* Possible object types for resetting single counters */ +typedef enum PgStat_Single_Reset_Type +{ + RESET_TABLE, + RESET_FUNCTION +} PgStat_Single_Reset_Type; + +/* ------------------------------------------------------------ + * Structures kept in backend local memory while accumulating counts + * ------------------------------------------------------------ + */ + + +/* ---------- + * PgStat_TableStatus Per-table status within a backend + * + * Many of the event counters are nontransactional, ie, we count events + * in committed and aborted transactions alike. For these, we just count + * directly in the PgStat_TableStatus. However, delta_live_tuples, + * delta_dead_tuples, and changed_tuples must be derived from event counts + * with awareness of whether the transaction or subtransaction committed or + * aborted. Hence, we also keep a stack of per-(sub)transaction status + * records for every table modified in the current transaction. At commit + * or abort, we propagate tuples_inserted/updated/deleted up to the + * parent subtransaction level, or out to the parent PgStat_TableStatus, + * as appropriate. + * ---------- + */ +typedef struct PgStat_TableStatus +{ + Oid t_id; /* table's OID */ + bool t_shared; /* is it a shared catalog? */ + struct PgStat_TableXactStatus *trans; /* lowest subxact's counts */ + PgStat_TableCounts t_counts; /* event counts to be sent */ +} PgStat_TableStatus; + +/* ---------- + * PgStat_TableXactStatus Per-table, per-subtransaction status + * ---------- + */ +typedef struct PgStat_TableXactStatus +{ + PgStat_Counter tuples_inserted; /* tuples inserted in (sub)xact */ + PgStat_Counter tuples_updated; /* tuples updated in (sub)xact */ + PgStat_Counter tuples_deleted; /* tuples deleted in (sub)xact */ + bool truncated; /* relation truncated in this (sub)xact */ + PgStat_Counter inserted_pre_trunc; /* tuples inserted prior to truncate */ + PgStat_Counter updated_pre_trunc; /* tuples updated prior to truncate */ + PgStat_Counter deleted_pre_trunc; /* tuples deleted prior to truncate */ + int nest_level; /* subtransaction nest level */ + /* links to other structs for same relation: */ + struct PgStat_TableXactStatus *upper; /* next higher subxact if any */ + PgStat_TableStatus *parent; /* per-table status */ + /* structs of same subxact level are linked here: */ + struct PgStat_TableXactStatus *next; /* next of same subxact */ +} PgStat_TableXactStatus; + + +/* ------------------------------------------------------------ + * Message formats follow + * ------------------------------------------------------------ + */ + + +/* ---------- + * PgStat_MsgHdr The common message header + * ---------- + */ +typedef struct PgStat_MsgHdr +{ + StatMsgType m_type; + int m_size; +} PgStat_MsgHdr; + +/* ---------- + * Space available in a message. This will keep the UDP packets below 1K, + * which should fit unfragmented into the MTU of the loopback interface. + * (Larger values of PGSTAT_MAX_MSG_SIZE would work for that on most + * platforms, but we're being conservative here.) + * ---------- + */ +#define PGSTAT_MAX_MSG_SIZE 1000 +#define PGSTAT_MSG_PAYLOAD (PGSTAT_MAX_MSG_SIZE - sizeof(PgStat_MsgHdr)) + + +/* ---------- + * PgStat_MsgDummy A dummy message, ignored by the collector + * ---------- + */ +typedef struct PgStat_MsgDummy +{ + PgStat_MsgHdr m_hdr; +} PgStat_MsgDummy; + + +/* ---------- + * PgStat_MsgInquiry Sent by a backend to ask the collector + * to write the stats file(s). + * + * Ordinarily, an inquiry message prompts writing of the global stats file, + * the stats file for shared catalogs, and the stats file for the specified + * database. If databaseid is InvalidOid, only the first two are written. + * + * New file(s) will be written only if the existing file has a timestamp + * older than the specified cutoff_time; this prevents duplicated effort + * when multiple requests arrive at nearly the same time, assuming that + * backends send requests with cutoff_times a little bit in the past. + * + * clock_time should be the requestor's current local time; the collector + * uses this to check for the system clock going backward, but it has no + * effect unless that occurs. We assume clock_time >= cutoff_time, though. + * ---------- + */ + +typedef struct PgStat_MsgInquiry +{ + PgStat_MsgHdr m_hdr; + TimestampTz clock_time; /* observed local clock time */ + TimestampTz cutoff_time; /* minimum acceptable file timestamp */ + Oid databaseid; /* requested DB (InvalidOid => shared only) */ +} PgStat_MsgInquiry; + + +/* ---------- + * PgStat_TableEntry Per-table info in a MsgTabstat + * ---------- + */ +typedef struct PgStat_TableEntry +{ + Oid t_id; + PgStat_TableCounts t_counts; +} PgStat_TableEntry; + +/* ---------- + * PgStat_MsgTabstat Sent by the backend to report table + * and buffer access statistics. + * ---------- + */ +#define PGSTAT_NUM_TABENTRIES \ + ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - 3 * sizeof(int) - 2 * sizeof(PgStat_Counter)) \ + / sizeof(PgStat_TableEntry)) + +typedef struct PgStat_MsgTabstat +{ + PgStat_MsgHdr m_hdr; + Oid m_databaseid; + int m_nentries; + int m_xact_commit; + int m_xact_rollback; + PgStat_Counter m_block_read_time; /* times in microseconds */ + PgStat_Counter m_block_write_time; + PgStat_TableEntry m_entry[PGSTAT_NUM_TABENTRIES]; +} PgStat_MsgTabstat; + + +/* ---------- + * PgStat_MsgTabpurge Sent by the backend to tell the collector + * about dead tables. + * ---------- + */ +#define PGSTAT_NUM_TABPURGE \ + ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \ + / sizeof(Oid)) + +typedef struct PgStat_MsgTabpurge +{ + PgStat_MsgHdr m_hdr; + Oid m_databaseid; + int m_nentries; + Oid m_tableid[PGSTAT_NUM_TABPURGE]; +} PgStat_MsgTabpurge; + + +/* ---------- + * PgStat_MsgDropdb Sent by the backend to tell the collector + * about a dropped database + * ---------- + */ +typedef struct PgStat_MsgDropdb +{ + PgStat_MsgHdr m_hdr; + Oid m_databaseid; +} PgStat_MsgDropdb; + + +/* ---------- + * PgStat_MsgResetcounter Sent by the backend to tell the collector + * to reset counters + * ---------- + */ +typedef struct PgStat_MsgResetcounter +{ + PgStat_MsgHdr m_hdr; + Oid m_databaseid; +} PgStat_MsgResetcounter; + +/* ---------- + * PgStat_MsgResetsharedcounter Sent by the backend to tell the collector + * to reset a shared counter + * ---------- + */ +typedef struct PgStat_MsgResetsharedcounter +{ + PgStat_MsgHdr m_hdr; + PgStat_Shared_Reset_Target m_resettarget; +} PgStat_MsgResetsharedcounter; + +/* ---------- + * PgStat_MsgResetsinglecounter Sent by the backend to tell the collector + * to reset a single counter + * ---------- + */ +typedef struct PgStat_MsgResetsinglecounter +{ + PgStat_MsgHdr m_hdr; + Oid m_databaseid; + PgStat_Single_Reset_Type m_resettype; + Oid m_objectid; +} PgStat_MsgResetsinglecounter; + +/* ---------- + * PgStat_MsgResetslrucounter Sent by the backend to tell the collector + * to reset a SLRU counter + * ---------- + */ +typedef struct PgStat_MsgResetslrucounter +{ + PgStat_MsgHdr m_hdr; + int m_index; +} PgStat_MsgResetslrucounter; + +/* ---------- + * PgStat_MsgAutovacStart Sent by the autovacuum daemon to signal + * that a database is going to be processed + * ---------- + */ +typedef struct PgStat_MsgAutovacStart +{ + PgStat_MsgHdr m_hdr; + Oid m_databaseid; + TimestampTz m_start_time; +} PgStat_MsgAutovacStart; + + +/* ---------- + * PgStat_MsgVacuum Sent by the backend or autovacuum daemon + * after VACUUM + * ---------- + */ +typedef struct PgStat_MsgVacuum +{ + PgStat_MsgHdr m_hdr; + Oid m_databaseid; + Oid m_tableoid; + bool m_autovacuum; + TimestampTz m_vacuumtime; + PgStat_Counter m_live_tuples; + PgStat_Counter m_dead_tuples; +} PgStat_MsgVacuum; + + +/* ---------- + * PgStat_MsgAnalyze Sent by the backend or autovacuum daemon + * after ANALYZE + * ---------- + */ +typedef struct PgStat_MsgAnalyze +{ + PgStat_MsgHdr m_hdr; + Oid m_databaseid; + Oid m_tableoid; + bool m_autovacuum; + bool m_resetcounter; + TimestampTz m_analyzetime; + PgStat_Counter m_live_tuples; + PgStat_Counter m_dead_tuples; +} PgStat_MsgAnalyze; + + +/* ---------- + * PgStat_MsgArchiver Sent by the archiver to update statistics. + * ---------- + */ +typedef struct PgStat_MsgArchiver +{ + PgStat_MsgHdr m_hdr; + bool m_failed; /* Failed attempt */ + char m_xlog[MAX_XFN_CHARS + 1]; + TimestampTz m_timestamp; +} PgStat_MsgArchiver; + +/* ---------- + * PgStat_MsgBgWriter Sent by the bgwriter to update statistics. + * ---------- + */ +typedef struct PgStat_MsgBgWriter +{ + PgStat_MsgHdr m_hdr; + + PgStat_Counter m_timed_checkpoints; + PgStat_Counter m_requested_checkpoints; + PgStat_Counter m_buf_written_checkpoints; + PgStat_Counter m_buf_written_clean; + PgStat_Counter m_maxwritten_clean; + PgStat_Counter m_buf_written_backend; + PgStat_Counter m_buf_fsync_backend; + PgStat_Counter m_buf_alloc; + PgStat_Counter m_checkpoint_write_time; /* times in milliseconds */ + PgStat_Counter m_checkpoint_sync_time; +} PgStat_MsgBgWriter; + +/* ---------- + * PgStat_MsgSLRU Sent by a backend to update SLRU statistics. + * ---------- + */ +typedef struct PgStat_MsgSLRU +{ + PgStat_MsgHdr m_hdr; + PgStat_Counter m_index; + PgStat_Counter m_blocks_zeroed; + PgStat_Counter m_blocks_hit; + PgStat_Counter m_blocks_read; + PgStat_Counter m_blocks_written; + PgStat_Counter m_blocks_exists; + PgStat_Counter m_flush; + PgStat_Counter m_truncate; +} PgStat_MsgSLRU; + +/* ---------- + * PgStat_MsgRecoveryConflict Sent by the backend upon recovery conflict + * ---------- + */ +typedef struct PgStat_MsgRecoveryConflict +{ + PgStat_MsgHdr m_hdr; + + Oid m_databaseid; + int m_reason; +} PgStat_MsgRecoveryConflict; + +/* ---------- + * PgStat_MsgTempFile Sent by the backend upon creating a temp file + * ---------- + */ +typedef struct PgStat_MsgTempFile +{ + PgStat_MsgHdr m_hdr; + + Oid m_databaseid; + size_t m_filesize; +} PgStat_MsgTempFile; + +/* ---------- + * PgStat_FunctionCounts The actual per-function counts kept by a backend + * + * This struct should contain only actual event counters, because we memcmp + * it against zeroes to detect whether there are any counts to transmit. + * + * Note that the time counters are in instr_time format here. We convert to + * microseconds in PgStat_Counter format when transmitting to the collector. + * ---------- + */ +typedef struct PgStat_FunctionCounts +{ + PgStat_Counter f_numcalls; + instr_time f_total_time; + instr_time f_self_time; +} PgStat_FunctionCounts; + +/* ---------- + * PgStat_BackendFunctionEntry Entry in backend's per-function hash table + * ---------- + */ +typedef struct PgStat_BackendFunctionEntry +{ + Oid f_id; + PgStat_FunctionCounts f_counts; +} PgStat_BackendFunctionEntry; + +/* ---------- + * PgStat_FunctionEntry Per-function info in a MsgFuncstat + * ---------- + */ +typedef struct PgStat_FunctionEntry +{ + Oid f_id; + PgStat_Counter f_numcalls; + PgStat_Counter f_total_time; /* times in microseconds */ + PgStat_Counter f_self_time; +} PgStat_FunctionEntry; + +/* ---------- + * PgStat_MsgFuncstat Sent by the backend to report function + * usage statistics. + * ---------- + */ +#define PGSTAT_NUM_FUNCENTRIES \ + ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \ + / sizeof(PgStat_FunctionEntry)) + +typedef struct PgStat_MsgFuncstat +{ + PgStat_MsgHdr m_hdr; + Oid m_databaseid; + int m_nentries; + PgStat_FunctionEntry m_entry[PGSTAT_NUM_FUNCENTRIES]; +} PgStat_MsgFuncstat; + +/* ---------- + * PgStat_MsgFuncpurge Sent by the backend to tell the collector + * about dead functions. + * ---------- + */ +#define PGSTAT_NUM_FUNCPURGE \ + ((PGSTAT_MSG_PAYLOAD - sizeof(Oid) - sizeof(int)) \ + / sizeof(Oid)) + +typedef struct PgStat_MsgFuncpurge +{ + PgStat_MsgHdr m_hdr; + Oid m_databaseid; + int m_nentries; + Oid m_functionid[PGSTAT_NUM_FUNCPURGE]; +} PgStat_MsgFuncpurge; + +/* ---------- + * PgStat_MsgDeadlock Sent by the backend to tell the collector + * about a deadlock that occurred. + * ---------- + */ +typedef struct PgStat_MsgDeadlock +{ + PgStat_MsgHdr m_hdr; + Oid m_databaseid; +} PgStat_MsgDeadlock; + +/* ---------- + * PgStat_MsgChecksumFailure Sent by the backend to tell the collector + * about checksum failures noticed. + * ---------- + */ +typedef struct PgStat_MsgChecksumFailure +{ + PgStat_MsgHdr m_hdr; + Oid m_databaseid; + int m_failurecount; + TimestampTz m_failure_time; +} PgStat_MsgChecksumFailure; + + +/* ---------- + * PgStat_Msg Union over all possible messages. + * ---------- + */ +typedef union PgStat_Msg +{ + PgStat_MsgHdr msg_hdr; + PgStat_MsgDummy msg_dummy; + PgStat_MsgInquiry msg_inquiry; + PgStat_MsgTabstat msg_tabstat; + PgStat_MsgTabpurge msg_tabpurge; + PgStat_MsgDropdb msg_dropdb; + PgStat_MsgResetcounter msg_resetcounter; + PgStat_MsgResetsharedcounter msg_resetsharedcounter; + PgStat_MsgResetsinglecounter msg_resetsinglecounter; + PgStat_MsgResetslrucounter msg_resetslrucounter; + PgStat_MsgAutovacStart msg_autovacuum_start; + PgStat_MsgVacuum msg_vacuum; + PgStat_MsgAnalyze msg_analyze; + PgStat_MsgArchiver msg_archiver; + PgStat_MsgBgWriter msg_bgwriter; + PgStat_MsgSLRU msg_slru; + PgStat_MsgFuncstat msg_funcstat; + PgStat_MsgFuncpurge msg_funcpurge; + PgStat_MsgRecoveryConflict msg_recoveryconflict; + PgStat_MsgDeadlock msg_deadlock; + PgStat_MsgTempFile msg_tempfile; + PgStat_MsgChecksumFailure msg_checksumfailure; +} PgStat_Msg; + + +/* ------------------------------------------------------------ + * Statistic collector data structures follow + * + * PGSTAT_FILE_FORMAT_ID should be changed whenever any of these + * data structures change. + * ------------------------------------------------------------ + */ + +#define PGSTAT_FILE_FORMAT_ID 0x01A5BC9D + +/* ---------- + * PgStat_StatDBEntry The collector's data per database + * ---------- + */ +typedef struct PgStat_StatDBEntry +{ + Oid databaseid; + PgStat_Counter n_xact_commit; + PgStat_Counter n_xact_rollback; + PgStat_Counter n_blocks_fetched; + PgStat_Counter n_blocks_hit; + PgStat_Counter n_tuples_returned; + PgStat_Counter n_tuples_fetched; + PgStat_Counter n_tuples_inserted; + PgStat_Counter n_tuples_updated; + PgStat_Counter n_tuples_deleted; + TimestampTz last_autovac_time; + PgStat_Counter n_conflict_tablespace; + PgStat_Counter n_conflict_lock; + PgStat_Counter n_conflict_snapshot; + PgStat_Counter n_conflict_bufferpin; + PgStat_Counter n_conflict_startup_deadlock; + PgStat_Counter n_temp_files; + PgStat_Counter n_temp_bytes; + PgStat_Counter n_deadlocks; + PgStat_Counter n_checksum_failures; + TimestampTz last_checksum_failure; + PgStat_Counter n_block_read_time; /* times in microseconds */ + PgStat_Counter n_block_write_time; + + TimestampTz stat_reset_timestamp; + TimestampTz stats_timestamp; /* time of db stats file update */ + + /* + * tables and functions must be last in the struct, because we don't write + * the pointers out to the stats file. + */ + HTAB *tables; + HTAB *functions; +} PgStat_StatDBEntry; + + +/* ---------- + * PgStat_StatTabEntry The collector's data per table (or index) + * ---------- + */ +typedef struct PgStat_StatTabEntry +{ + Oid tableid; + + PgStat_Counter numscans; + + PgStat_Counter tuples_returned; + PgStat_Counter tuples_fetched; + + PgStat_Counter tuples_inserted; + PgStat_Counter tuples_updated; + PgStat_Counter tuples_deleted; + PgStat_Counter tuples_hot_updated; + + PgStat_Counter n_live_tuples; + PgStat_Counter n_dead_tuples; + PgStat_Counter changes_since_analyze; + PgStat_Counter inserts_since_vacuum; + + PgStat_Counter blocks_fetched; + PgStat_Counter blocks_hit; + + TimestampTz vacuum_timestamp; /* user initiated vacuum */ + PgStat_Counter vacuum_count; + TimestampTz autovac_vacuum_timestamp; /* autovacuum initiated */ + PgStat_Counter autovac_vacuum_count; + TimestampTz analyze_timestamp; /* user initiated */ + PgStat_Counter analyze_count; + TimestampTz autovac_analyze_timestamp; /* autovacuum initiated */ + PgStat_Counter autovac_analyze_count; +} PgStat_StatTabEntry; + + +/* ---------- + * PgStat_StatFuncEntry The collector's data per function + * ---------- + */ +typedef struct PgStat_StatFuncEntry +{ + Oid functionid; + + PgStat_Counter f_numcalls; + + PgStat_Counter f_total_time; /* times in microseconds */ + PgStat_Counter f_self_time; +} PgStat_StatFuncEntry; + + +/* + * Archiver statistics kept in the stats collector + */ +typedef struct PgStat_ArchiverStats +{ + PgStat_Counter archived_count; /* archival successes */ + char last_archived_wal[MAX_XFN_CHARS + 1]; /* last WAL file + * archived */ + TimestampTz last_archived_timestamp; /* last archival success time */ + PgStat_Counter failed_count; /* failed archival attempts */ + char last_failed_wal[MAX_XFN_CHARS + 1]; /* WAL file involved in + * last failure */ + TimestampTz last_failed_timestamp; /* last archival failure time */ + TimestampTz stat_reset_timestamp; +} PgStat_ArchiverStats; + +/* + * Global statistics kept in the stats collector + */ +typedef struct PgStat_GlobalStats +{ + TimestampTz stats_timestamp; /* time of stats file update */ + PgStat_Counter timed_checkpoints; + PgStat_Counter requested_checkpoints; + PgStat_Counter checkpoint_write_time; /* times in milliseconds */ + PgStat_Counter checkpoint_sync_time; + PgStat_Counter buf_written_checkpoints; + PgStat_Counter buf_written_clean; + PgStat_Counter maxwritten_clean; + PgStat_Counter buf_written_backend; + PgStat_Counter buf_fsync_backend; + PgStat_Counter buf_alloc; + TimestampTz stat_reset_timestamp; +} PgStat_GlobalStats; + +/* + * SLRU statistics kept in the stats collector + */ +typedef struct PgStat_SLRUStats +{ + PgStat_Counter blocks_zeroed; + PgStat_Counter blocks_hit; + PgStat_Counter blocks_read; + PgStat_Counter blocks_written; + PgStat_Counter blocks_exists; + PgStat_Counter flush; + PgStat_Counter truncate; + TimestampTz stat_reset_timestamp; +} PgStat_SLRUStats; + + +/* ---------- + * Backend states + * ---------- + */ +typedef enum BackendState +{ + STATE_UNDEFINED, + STATE_IDLE, + STATE_RUNNING, + STATE_IDLEINTRANSACTION, + STATE_FASTPATH, + STATE_IDLEINTRANSACTION_ABORTED, + STATE_DISABLED +} BackendState; + + +/* ---------- + * Wait Classes + * ---------- + */ +#define PG_WAIT_LWLOCK 0x01000000U +#define PG_WAIT_LOCK 0x03000000U +#define PG_WAIT_BUFFER_PIN 0x04000000U +#define PG_WAIT_ACTIVITY 0x05000000U +#define PG_WAIT_CLIENT 0x06000000U +#define PG_WAIT_EXTENSION 0x07000000U +#define PG_WAIT_IPC 0x08000000U +#define PG_WAIT_TIMEOUT 0x09000000U +#define PG_WAIT_IO 0x0A000000U + +/* ---------- + * Wait Events - Activity + * + * Use this category when a process is waiting because it has no work to do, + * unless the "Client" or "Timeout" category describes the situation better. + * Typically, this should only be used for background processes. + * ---------- + */ +typedef enum +{ + WAIT_EVENT_ARCHIVER_MAIN = PG_WAIT_ACTIVITY, + WAIT_EVENT_AUTOVACUUM_MAIN, + WAIT_EVENT_BGWRITER_HIBERNATE, + WAIT_EVENT_BGWRITER_MAIN, + WAIT_EVENT_CHECKPOINTER_MAIN, + WAIT_EVENT_LOGICAL_APPLY_MAIN, + WAIT_EVENT_LOGICAL_LAUNCHER_MAIN, + WAIT_EVENT_PGSTAT_MAIN, + WAIT_EVENT_RECOVERY_WAL_STREAM, + WAIT_EVENT_SYSLOGGER_MAIN, + WAIT_EVENT_WAL_RECEIVER_MAIN, + WAIT_EVENT_WAL_SENDER_MAIN, + WAIT_EVENT_WAL_WRITER_MAIN +} WaitEventActivity; + +/* ---------- + * Wait Events - Client + * + * Use this category when a process is waiting to send data to or receive data + * from the frontend process to which it is connected. This is never used for + * a background process, which has no client connection. + * ---------- + */ +typedef enum +{ + WAIT_EVENT_CLIENT_READ = PG_WAIT_CLIENT, + WAIT_EVENT_CLIENT_WRITE, + WAIT_EVENT_GSS_OPEN_SERVER, + WAIT_EVENT_LIBPQWALRECEIVER_CONNECT, + WAIT_EVENT_LIBPQWALRECEIVER_RECEIVE, + WAIT_EVENT_SSL_OPEN_SERVER, + WAIT_EVENT_WAL_RECEIVER_WAIT_START, + WAIT_EVENT_WAL_SENDER_WAIT_WAL, + WAIT_EVENT_WAL_SENDER_WRITE_DATA, +} WaitEventClient; + +/* ---------- + * Wait Events - IPC + * + * Use this category when a process cannot complete the work it is doing because + * it is waiting for a notification from another process. + * ---------- + */ +typedef enum +{ + WAIT_EVENT_BACKUP_WAIT_WAL_ARCHIVE = PG_WAIT_IPC, + WAIT_EVENT_BGWORKER_SHUTDOWN, + WAIT_EVENT_BGWORKER_STARTUP, + WAIT_EVENT_BTREE_PAGE, + WAIT_EVENT_CHECKPOINT_DONE, + WAIT_EVENT_CHECKPOINT_START, + WAIT_EVENT_EXECUTE_GATHER, + WAIT_EVENT_HASH_BATCH_ALLOCATE, + WAIT_EVENT_HASH_BATCH_ELECT, + WAIT_EVENT_HASH_BATCH_LOAD, + WAIT_EVENT_HASH_BUILD_ALLOCATE, + WAIT_EVENT_HASH_BUILD_ELECT, + WAIT_EVENT_HASH_BUILD_HASH_INNER, + WAIT_EVENT_HASH_BUILD_HASH_OUTER, + WAIT_EVENT_HASH_GROW_BATCHES_ALLOCATE, + WAIT_EVENT_HASH_GROW_BATCHES_DECIDE, + WAIT_EVENT_HASH_GROW_BATCHES_ELECT, + WAIT_EVENT_HASH_GROW_BATCHES_FINISH, + WAIT_EVENT_HASH_GROW_BATCHES_REPARTITION, + WAIT_EVENT_HASH_GROW_BUCKETS_ALLOCATE, + WAIT_EVENT_HASH_GROW_BUCKETS_ELECT, + WAIT_EVENT_HASH_GROW_BUCKETS_REINSERT, + WAIT_EVENT_LOGICAL_SYNC_DATA, + WAIT_EVENT_LOGICAL_SYNC_STATE_CHANGE, + WAIT_EVENT_MQ_INTERNAL, + WAIT_EVENT_MQ_PUT_MESSAGE, + WAIT_EVENT_MQ_RECEIVE, + WAIT_EVENT_MQ_SEND, + WAIT_EVENT_PARALLEL_BITMAP_SCAN, + WAIT_EVENT_PARALLEL_CREATE_INDEX_SCAN, + WAIT_EVENT_PARALLEL_FINISH, + WAIT_EVENT_PROCARRAY_GROUP_UPDATE, + WAIT_EVENT_PROC_SIGNAL_BARRIER, + WAIT_EVENT_PROMOTE, + WAIT_EVENT_RECOVERY_CONFLICT_SNAPSHOT, + WAIT_EVENT_RECOVERY_CONFLICT_TABLESPACE, + WAIT_EVENT_RECOVERY_PAUSE, + WAIT_EVENT_REPLICATION_ORIGIN_DROP, + WAIT_EVENT_REPLICATION_SLOT_DROP, + WAIT_EVENT_SAFE_SNAPSHOT, + WAIT_EVENT_SYNC_REP, + WAIT_EVENT_XACT_GROUP_UPDATE +} WaitEventIPC; + +/* ---------- + * Wait Events - Timeout + * + * Use this category when a process is waiting for a timeout to expire. + * ---------- + */ +typedef enum +{ + WAIT_EVENT_BASE_BACKUP_THROTTLE = PG_WAIT_TIMEOUT, + WAIT_EVENT_PG_SLEEP, + WAIT_EVENT_RECOVERY_APPLY_DELAY, + WAIT_EVENT_RECOVERY_RETRIEVE_RETRY_INTERVAL, + WAIT_EVENT_VACUUM_DELAY +} WaitEventTimeout; + +/* ---------- + * Wait Events - IO + * + * Use this category when a process is waiting for a IO. + * ---------- + */ +typedef enum +{ + WAIT_EVENT_BUFFILE_READ = PG_WAIT_IO, + WAIT_EVENT_BUFFILE_WRITE, + WAIT_EVENT_CONTROL_FILE_READ, + WAIT_EVENT_CONTROL_FILE_SYNC, + WAIT_EVENT_CONTROL_FILE_SYNC_UPDATE, + WAIT_EVENT_CONTROL_FILE_WRITE, + WAIT_EVENT_CONTROL_FILE_WRITE_UPDATE, + WAIT_EVENT_COPY_FILE_READ, + WAIT_EVENT_COPY_FILE_WRITE, + WAIT_EVENT_DATA_FILE_EXTEND, + WAIT_EVENT_DATA_FILE_FLUSH, + WAIT_EVENT_DATA_FILE_IMMEDIATE_SYNC, + WAIT_EVENT_DATA_FILE_PREFETCH, + WAIT_EVENT_DATA_FILE_READ, + WAIT_EVENT_DATA_FILE_SYNC, + WAIT_EVENT_DATA_FILE_TRUNCATE, + WAIT_EVENT_DATA_FILE_WRITE, + WAIT_EVENT_DSM_FILL_ZERO_WRITE, + WAIT_EVENT_LOCK_FILE_ADDTODATADIR_READ, + WAIT_EVENT_LOCK_FILE_ADDTODATADIR_SYNC, + WAIT_EVENT_LOCK_FILE_ADDTODATADIR_WRITE, + WAIT_EVENT_LOCK_FILE_CREATE_READ, + WAIT_EVENT_LOCK_FILE_CREATE_SYNC, + WAIT_EVENT_LOCK_FILE_CREATE_WRITE, + WAIT_EVENT_LOCK_FILE_RECHECKDATADIR_READ, + WAIT_EVENT_LOGICAL_REWRITE_CHECKPOINT_SYNC, + WAIT_EVENT_LOGICAL_REWRITE_MAPPING_SYNC, + WAIT_EVENT_LOGICAL_REWRITE_MAPPING_WRITE, + WAIT_EVENT_LOGICAL_REWRITE_SYNC, + WAIT_EVENT_LOGICAL_REWRITE_TRUNCATE, + WAIT_EVENT_LOGICAL_REWRITE_WRITE, + WAIT_EVENT_RELATION_MAP_READ, + WAIT_EVENT_RELATION_MAP_SYNC, + WAIT_EVENT_RELATION_MAP_WRITE, + WAIT_EVENT_REORDER_BUFFER_READ, + WAIT_EVENT_REORDER_BUFFER_WRITE, + WAIT_EVENT_REORDER_LOGICAL_MAPPING_READ, + WAIT_EVENT_REPLICATION_SLOT_READ, + WAIT_EVENT_REPLICATION_SLOT_RESTORE_SYNC, + WAIT_EVENT_REPLICATION_SLOT_SYNC, + WAIT_EVENT_REPLICATION_SLOT_WRITE, + WAIT_EVENT_SLRU_FLUSH_SYNC, + WAIT_EVENT_SLRU_READ, + WAIT_EVENT_SLRU_SYNC, + WAIT_EVENT_SLRU_WRITE, + WAIT_EVENT_SNAPBUILD_READ, + WAIT_EVENT_SNAPBUILD_SYNC, + WAIT_EVENT_SNAPBUILD_WRITE, + WAIT_EVENT_TIMELINE_HISTORY_FILE_SYNC, + WAIT_EVENT_TIMELINE_HISTORY_FILE_WRITE, + WAIT_EVENT_TIMELINE_HISTORY_READ, + WAIT_EVENT_TIMELINE_HISTORY_SYNC, + WAIT_EVENT_TIMELINE_HISTORY_WRITE, + WAIT_EVENT_TWOPHASE_FILE_READ, + WAIT_EVENT_TWOPHASE_FILE_SYNC, + WAIT_EVENT_TWOPHASE_FILE_WRITE, + WAIT_EVENT_WALSENDER_TIMELINE_HISTORY_READ, + WAIT_EVENT_WAL_BOOTSTRAP_SYNC, + WAIT_EVENT_WAL_BOOTSTRAP_WRITE, + WAIT_EVENT_WAL_COPY_READ, + WAIT_EVENT_WAL_COPY_SYNC, + WAIT_EVENT_WAL_COPY_WRITE, + WAIT_EVENT_WAL_INIT_SYNC, + WAIT_EVENT_WAL_INIT_WRITE, + WAIT_EVENT_WAL_READ, + WAIT_EVENT_WAL_SYNC, + WAIT_EVENT_WAL_SYNC_METHOD_ASSIGN, + WAIT_EVENT_WAL_WRITE +} WaitEventIO; + +/* ---------- + * Command type for progress reporting purposes + * ---------- + */ +typedef enum ProgressCommandType +{ + PROGRESS_COMMAND_INVALID, + PROGRESS_COMMAND_VACUUM, + PROGRESS_COMMAND_ANALYZE, + PROGRESS_COMMAND_CLUSTER, + PROGRESS_COMMAND_CREATE_INDEX, + PROGRESS_COMMAND_BASEBACKUP +} ProgressCommandType; + +#define PGSTAT_NUM_PROGRESS_PARAM 20 + +/* ---------- + * Shared-memory data structures + * ---------- + */ + + +/* + * PgBackendSSLStatus + * + * For each backend, we keep the SSL status in a separate struct, that + * is only filled in if SSL is enabled. + * + * All char arrays must be null-terminated. + */ +typedef struct PgBackendSSLStatus +{ + /* Information about SSL connection */ + int ssl_bits; + bool ssl_compression; + char ssl_version[NAMEDATALEN]; + char ssl_cipher[NAMEDATALEN]; + char ssl_client_dn[NAMEDATALEN]; + + /* + * serial number is max "20 octets" per RFC 5280, so this size should be + * fine + */ + char ssl_client_serial[NAMEDATALEN]; + + char ssl_issuer_dn[NAMEDATALEN]; +} PgBackendSSLStatus; + +/* + * PgBackendGSSStatus + * + * For each backend, we keep the GSS status in a separate struct, that + * is only filled in if GSS is enabled. + * + * All char arrays must be null-terminated. + */ +typedef struct PgBackendGSSStatus +{ + /* Information about GSSAPI connection */ + char gss_princ[NAMEDATALEN]; /* GSSAPI Principal used to auth */ + bool gss_auth; /* If GSSAPI authentication was used */ + bool gss_enc; /* If encryption is being used */ + +} PgBackendGSSStatus; + + +/* ---------- + * PgBackendStatus + * + * Each live backend maintains a PgBackendStatus struct in shared memory + * showing its current activity. (The structs are allocated according to + * BackendId, but that is not critical.) Note that the collector process + * has no involvement in, or even access to, these structs. + * + * Each auxiliary process also maintains a PgBackendStatus struct in shared + * memory. + * ---------- + */ +typedef struct PgBackendStatus +{ + /* + * To avoid locking overhead, we use the following protocol: a backend + * increments st_changecount before modifying its entry, and again after + * finishing a modification. A would-be reader should note the value of + * st_changecount, copy the entry into private memory, then check + * st_changecount again. If the value hasn't changed, and if it's even, + * the copy is valid; otherwise start over. This makes updates cheap + * while reads are potentially expensive, but that's the tradeoff we want. + * + * The above protocol needs memory barriers to ensure that the apparent + * order of execution is as it desires. Otherwise, for example, the CPU + * might rearrange the code so that st_changecount is incremented twice + * before the modification on a machine with weak memory ordering. Hence, + * use the macros defined below for manipulating st_changecount, rather + * than touching it directly. + */ + int st_changecount; + + /* The entry is valid iff st_procpid > 0, unused if st_procpid == 0 */ + int st_procpid; + + /* Type of backends */ + BackendType st_backendType; + + /* Times when current backend, transaction, and activity started */ + TimestampTz st_proc_start_timestamp; + TimestampTz st_xact_start_timestamp; + TimestampTz st_activity_start_timestamp; + TimestampTz st_state_start_timestamp; + + /* Database OID, owning user's OID, connection client address */ + Oid st_databaseid; + Oid st_userid; + SockAddr st_clientaddr; + char *st_clienthostname; /* MUST be null-terminated */ + + /* Information about SSL connection */ + bool st_ssl; + PgBackendSSLStatus *st_sslstatus; + + /* Information about GSSAPI connection */ + bool st_gss; + PgBackendGSSStatus *st_gssstatus; + + /* current state */ + BackendState st_state; + + /* application name; MUST be null-terminated */ + char *st_appname; + + /* + * Current command string; MUST be null-terminated. Note that this string + * possibly is truncated in the middle of a multi-byte character. As + * activity strings are stored more frequently than read, that allows to + * move the cost of correct truncation to the display side. Use + * pgstat_clip_activity() to truncate correctly. + */ + char *st_activity_raw; + + /* + * Command progress reporting. Any command which wishes can advertise + * that it is running by setting st_progress_command, + * st_progress_command_target, and st_progress_param[]. + * st_progress_command_target should be the OID of the relation which the + * command targets (we assume there's just one, as this is meant for + * utility commands), but the meaning of each element in the + * st_progress_param array is command-specific. + */ + ProgressCommandType st_progress_command; + Oid st_progress_command_target; + int64 st_progress_param[PGSTAT_NUM_PROGRESS_PARAM]; +} PgBackendStatus; + +/* + * Macros to load and store st_changecount with appropriate memory barriers. + * + * Use PGSTAT_BEGIN_WRITE_ACTIVITY() before, and PGSTAT_END_WRITE_ACTIVITY() + * after, modifying the current process's PgBackendStatus data. Note that, + * since there is no mechanism for cleaning up st_changecount after an error, + * THESE MACROS FORM A CRITICAL SECTION. Any error between them will be + * promoted to PANIC, causing a database restart to clean up shared memory! + * Hence, keep the critical section as short and straight-line as possible. + * Aside from being safer, that minimizes the window in which readers will + * have to loop. + * + * Reader logic should follow this sketch: + * + * for (;;) + * { + * int before_ct, after_ct; + * + * pgstat_begin_read_activity(beentry, before_ct); + * ... copy beentry data to local memory ... + * pgstat_end_read_activity(beentry, after_ct); + * if (pgstat_read_activity_complete(before_ct, after_ct)) + * break; + * CHECK_FOR_INTERRUPTS(); + * } + * + * For extra safety, we generally use volatile beentry pointers, although + * the memory barriers should theoretically be sufficient. + */ +#define PGSTAT_BEGIN_WRITE_ACTIVITY(beentry) \ + do { \ + START_CRIT_SECTION(); \ + (beentry)->st_changecount++; \ + pg_write_barrier(); \ + } while (0) + +#define PGSTAT_END_WRITE_ACTIVITY(beentry) \ + do { \ + pg_write_barrier(); \ + (beentry)->st_changecount++; \ + Assert(((beentry)->st_changecount & 1) == 0); \ + END_CRIT_SECTION(); \ + } while (0) + +#define pgstat_begin_read_activity(beentry, before_changecount) \ + do { \ + (before_changecount) = (beentry)->st_changecount; \ + pg_read_barrier(); \ + } while (0) + +#define pgstat_end_read_activity(beentry, after_changecount) \ + do { \ + pg_read_barrier(); \ + (after_changecount) = (beentry)->st_changecount; \ + } while (0) + +#define pgstat_read_activity_complete(before_changecount, after_changecount) \ + ((before_changecount) == (after_changecount) && \ + ((before_changecount) & 1) == 0) + + +/* ---------- + * LocalPgBackendStatus + * + * When we build the backend status array, we use LocalPgBackendStatus to be + * able to add new values to the struct when needed without adding new fields + * to the shared memory. It contains the backend status as a first member. + * ---------- + */ +typedef struct LocalPgBackendStatus +{ + /* + * Local version of the backend status entry. + */ + PgBackendStatus backendStatus; + + /* + * The xid of the current transaction if available, InvalidTransactionId + * if not. + */ + TransactionId backend_xid; + + /* + * The xmin of the current session if available, InvalidTransactionId if + * not. + */ + TransactionId backend_xmin; +} LocalPgBackendStatus; + +/* + * Working state needed to accumulate per-function-call timing statistics. + */ +typedef struct PgStat_FunctionCallUsage +{ + /* Link to function's hashtable entry (must still be there at exit!) */ + /* NULL means we are not tracking the current function call */ + PgStat_FunctionCounts *fs; + /* Total time previously charged to function, as of function start */ + instr_time save_f_total_time; + /* Backend-wide total time as of function start */ + instr_time save_total; + /* system clock as of function start */ + instr_time f_start; +} PgStat_FunctionCallUsage; + + +/* ---------- + * GUC parameters + * ---------- + */ +extern PGDLLIMPORT bool pgstat_track_activities; +extern PGDLLIMPORT bool pgstat_track_counts; +extern PGDLLIMPORT int pgstat_track_functions; +extern PGDLLIMPORT int pgstat_track_activity_query_size; +extern char *pgstat_stat_directory; +extern char *pgstat_stat_tmpname; +extern char *pgstat_stat_filename; + +/* + * BgWriter statistics counters are updated directly by bgwriter and bufmgr + */ +extern PgStat_MsgBgWriter BgWriterStats; + +/* + * Updated by pgstat_count_buffer_*_time macros + */ +extern PgStat_Counter pgStatBlockReadTime; +extern PgStat_Counter pgStatBlockWriteTime; + +/* ---------- + * Functions called from postmaster + * ---------- + */ +extern Size BackendStatusShmemSize(void); +extern void CreateSharedBackendStatus(void); + +extern void pgstat_init(void); +extern int pgstat_start(void); +extern void pgstat_reset_all(void); +extern void allow_immediate_pgstat_restart(void); + +#ifdef EXEC_BACKEND +extern void PgstatCollectorMain(int argc, char *argv[]) pg_attribute_noreturn(); +#endif + + +/* ---------- + * Functions called from backends + * ---------- + */ +extern void pgstat_ping(void); + +extern void pgstat_report_stat(bool force); +extern void pgstat_vacuum_stat(void); +extern void pgstat_drop_database(Oid databaseid); + +extern void pgstat_clear_snapshot(void); +extern void pgstat_reset_counters(void); +extern void pgstat_reset_shared_counters(const char *); +extern void pgstat_reset_single_counter(Oid objectid, PgStat_Single_Reset_Type type); +extern void pgstat_reset_slru_counter(const char *); + +extern void pgstat_report_autovac(Oid dboid); +extern void pgstat_report_vacuum(Oid tableoid, bool shared, + PgStat_Counter livetuples, PgStat_Counter deadtuples); +extern void pgstat_report_analyze(Relation rel, + PgStat_Counter livetuples, PgStat_Counter deadtuples, + bool resetcounter); + +extern void pgstat_report_recovery_conflict(int reason); +extern void pgstat_report_deadlock(void); +extern void pgstat_report_checksum_failures_in_db(Oid dboid, int failurecount); +extern void pgstat_report_checksum_failure(void); + +extern void pgstat_initialize(void); +extern void pgstat_bestart(void); + +extern void pgstat_report_activity(BackendState state, const char *cmd_str); +extern void pgstat_report_tempfile(size_t filesize); +extern void pgstat_report_appname(const char *appname); +extern void pgstat_report_xact_timestamp(TimestampTz tstamp); +extern const char *pgstat_get_wait_event(uint32 wait_event_info); +extern const char *pgstat_get_wait_event_type(uint32 wait_event_info); +extern const char *pgstat_get_backend_current_activity(int pid, bool checkUser); +extern const char *pgstat_get_crashed_backend_activity(int pid, char *buffer, + int buflen); + +extern void pgstat_progress_start_command(ProgressCommandType cmdtype, + Oid relid); +extern void pgstat_progress_update_param(int index, int64 val); +extern void pgstat_progress_update_multi_param(int nparam, const int *index, + const int64 *val); +extern void pgstat_progress_end_command(void); + +extern PgStat_TableStatus *find_tabstat_entry(Oid rel_id); +extern PgStat_BackendFunctionEntry *find_funcstat_entry(Oid func_id); + +extern void pgstat_initstats(Relation rel); + +extern char *pgstat_clip_activity(const char *raw_activity); + +/* ---------- + * pgstat_report_wait_start() - + * + * Called from places where server process needs to wait. This is called + * to report wait event information. The wait information is stored + * as 4-bytes where first byte represents the wait event class (type of + * wait, for different types of wait, refer WaitClass) and the next + * 3-bytes represent the actual wait event. Currently 2-bytes are used + * for wait event which is sufficient for current usage, 1-byte is + * reserved for future usage. + * + * NB: this *must* be able to survive being called before MyProc has been + * initialized. + * ---------- + */ +static inline void +pgstat_report_wait_start(uint32 wait_event_info) +{ + volatile PGPROC *proc = MyProc; + + if (!pgstat_track_activities || !proc) + return; + + /* + * Since this is a four-byte field which is always read and written as + * four-bytes, updates are atomic. + */ + proc->wait_event_info = wait_event_info; +} + +/* ---------- + * pgstat_report_wait_end() - + * + * Called to report end of a wait. + * + * NB: this *must* be able to survive being called before MyProc has been + * initialized. + * ---------- + */ +static inline void +pgstat_report_wait_end(void) +{ + volatile PGPROC *proc = MyProc; + + if (!pgstat_track_activities || !proc) + return; + + /* + * Since this is a four-byte field which is always read and written as + * four-bytes, updates are atomic. + */ + proc->wait_event_info = 0; +} + +/* nontransactional event counts are simple enough to inline */ + +#define pgstat_count_heap_scan(rel) \ + do { \ + if ((rel)->pgstat_info != NULL) \ + (rel)->pgstat_info->t_counts.t_numscans++; \ + } while (0) +#define pgstat_count_heap_getnext(rel) \ + do { \ + if ((rel)->pgstat_info != NULL) \ + (rel)->pgstat_info->t_counts.t_tuples_returned++; \ + } while (0) +#define pgstat_count_heap_fetch(rel) \ + do { \ + if ((rel)->pgstat_info != NULL) \ + (rel)->pgstat_info->t_counts.t_tuples_fetched++; \ + } while (0) +#define pgstat_count_index_scan(rel) \ + do { \ + if ((rel)->pgstat_info != NULL) \ + (rel)->pgstat_info->t_counts.t_numscans++; \ + } while (0) +#define pgstat_count_index_tuples(rel, n) \ + do { \ + if ((rel)->pgstat_info != NULL) \ + (rel)->pgstat_info->t_counts.t_tuples_returned += (n); \ + } while (0) +#define pgstat_count_buffer_read(rel) \ + do { \ + if ((rel)->pgstat_info != NULL) \ + (rel)->pgstat_info->t_counts.t_blocks_fetched++; \ + } while (0) +#define pgstat_count_buffer_hit(rel) \ + do { \ + if ((rel)->pgstat_info != NULL) \ + (rel)->pgstat_info->t_counts.t_blocks_hit++; \ + } while (0) +#define pgstat_count_buffer_read_time(n) \ + (pgStatBlockReadTime += (n)) +#define pgstat_count_buffer_write_time(n) \ + (pgStatBlockWriteTime += (n)) + +extern void pgstat_count_heap_insert(Relation rel, PgStat_Counter n); +extern void pgstat_count_heap_update(Relation rel, bool hot); +extern void pgstat_count_heap_delete(Relation rel); +extern void pgstat_count_truncate(Relation rel); +extern void pgstat_update_heap_dead_tuples(Relation rel, int delta); + +struct FunctionCallInfoBaseData; +extern void pgstat_init_function_usage(struct FunctionCallInfoBaseData *fcinfo, + PgStat_FunctionCallUsage *fcu); +extern void pgstat_end_function_usage(PgStat_FunctionCallUsage *fcu, + bool finalize); + +extern void AtEOXact_PgStat(bool isCommit, bool parallel); +extern void AtEOSubXact_PgStat(bool isCommit, int nestDepth); + +extern void AtPrepare_PgStat(void); +extern void PostPrepare_PgStat(void); + +extern void pgstat_twophase_postcommit(TransactionId xid, uint16 info, + void *recdata, uint32 len); +extern void pgstat_twophase_postabort(TransactionId xid, uint16 info, + void *recdata, uint32 len); + +extern void pgstat_send_archiver(const char *xlog, bool failed); +extern void pgstat_send_bgwriter(void); + +/* ---------- + * Support functions for the SQL-callable functions to + * generate the pgstat* views. + * ---------- + */ +extern PgStat_StatDBEntry *pgstat_fetch_stat_dbentry(Oid dbid); +extern PgStat_StatTabEntry *pgstat_fetch_stat_tabentry(Oid relid); +extern PgBackendStatus *pgstat_fetch_stat_beentry(int beid); +extern LocalPgBackendStatus *pgstat_fetch_stat_local_beentry(int beid); +extern PgStat_StatFuncEntry *pgstat_fetch_stat_funcentry(Oid funcid); +extern int pgstat_fetch_stat_numbackends(void); +extern PgStat_ArchiverStats *pgstat_fetch_stat_archiver(void); +extern PgStat_GlobalStats *pgstat_fetch_global(void); +extern PgStat_SLRUStats *pgstat_fetch_slru(void); + +extern void pgstat_count_slru_page_zeroed(int slru_idx); +extern void pgstat_count_slru_page_hit(int slru_idx); +extern void pgstat_count_slru_page_read(int slru_idx); +extern void pgstat_count_slru_page_written(int slru_idx); +extern void pgstat_count_slru_page_exists(int slru_idx); +extern void pgstat_count_slru_flush(int slru_idx); +extern void pgstat_count_slru_truncate(int slru_idx); +extern const char *pgstat_slru_name(int slru_idx); +extern int pgstat_slru_index(const char *name); + +#endif /* PGSTAT_H */ diff --git a/contrib/libs/postgresql/src/include/pgtar.h b/contrib/libs/postgresql/src/include/pgtar.h new file mode 100644 index 0000000000..0a875903a7 --- /dev/null +++ b/contrib/libs/postgresql/src/include/pgtar.h @@ -0,0 +1,26 @@ +/*------------------------------------------------------------------------- + * + * pgtar.h + * Functions for manipulating tarfile datastructures (src/port/tar.c) + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/pgtar.h + * + *------------------------------------------------------------------------- + */ + +enum tarError +{ + TAR_OK = 0, + TAR_NAME_TOO_LONG, + TAR_SYMLINK_TOO_LONG +}; + +extern enum tarError tarCreateHeader(char *h, const char *filename, const char *linktarget, + pgoff_t size, mode_t mode, uid_t uid, gid_t gid, time_t mtime); +extern uint64 read_tar_number(const char *s, int len); +extern void print_tar_number(char *s, int len, uint64 val); +extern int tarChecksum(char *header); diff --git a/contrib/libs/postgresql/src/include/pgtime.h b/contrib/libs/postgresql/src/include/pgtime.h new file mode 100644 index 0000000000..0fc76d0e60 --- /dev/null +++ b/contrib/libs/postgresql/src/include/pgtime.h @@ -0,0 +1,84 @@ +/*------------------------------------------------------------------------- + * + * pgtime.h + * PostgreSQL internal timezone library + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * + * IDENTIFICATION + * src/include/pgtime.h + * + *------------------------------------------------------------------------- + */ +#ifndef _PGTIME_H +#define _PGTIME_H + + +/* + * The API of this library is generally similar to the corresponding + * C library functions, except that we use pg_time_t which (we hope) is + * 64 bits wide, and which is most definitely signed not unsigned. + */ + +typedef int64 pg_time_t; + +struct pg_tm +{ + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; /* origin 1, not 0! */ + int tm_year; /* relative to 1900 */ + int tm_wday; + int tm_yday; + int tm_isdst; + long int tm_gmtoff; + const char *tm_zone; +}; + +typedef struct pg_tz pg_tz; +typedef struct pg_tzenum pg_tzenum; + +/* Maximum length of a timezone name (not including trailing null) */ +#define TZ_STRLEN_MAX 255 + +/* these functions are in localtime.c */ + +extern struct pg_tm *pg_localtime(const pg_time_t *timep, const pg_tz *tz); +extern struct pg_tm *pg_gmtime(const pg_time_t *timep); +extern int pg_next_dst_boundary(const pg_time_t *timep, + long int *before_gmtoff, + int *before_isdst, + pg_time_t *boundary, + long int *after_gmtoff, + int *after_isdst, + const pg_tz *tz); +extern bool pg_interpret_timezone_abbrev(const char *abbrev, + const pg_time_t *timep, + long int *gmtoff, + int *isdst, + const pg_tz *tz); +extern bool pg_get_timezone_offset(const pg_tz *tz, long int *gmtoff); +extern const char *pg_get_timezone_name(pg_tz *tz); +extern bool pg_tz_acceptable(pg_tz *tz); + +/* these functions are in strftime.c */ + +extern size_t pg_strftime(char *s, size_t max, const char *format, + const struct pg_tm *tm); + +/* these functions and variables are in pgtz.c */ + +extern PGDLLIMPORT pg_tz *session_timezone; +extern pg_tz *log_timezone; + +extern void pg_timezone_initialize(void); +extern pg_tz *pg_tzset(const char *tzname); +extern pg_tz *pg_tzset_offset(long gmtoffset); + +extern pg_tzenum *pg_tzenumerate_start(void); +extern pg_tz *pg_tzenumerate_next(pg_tzenum *dir); +extern void pg_tzenumerate_end(pg_tzenum *dir); + +#endif /* _PGTIME_H */ diff --git a/contrib/libs/postgresql/src/include/port.h b/contrib/libs/postgresql/src/include/port.h new file mode 100644 index 0000000000..d4c94a4411 --- /dev/null +++ b/contrib/libs/postgresql/src/include/port.h @@ -0,0 +1,528 @@ +/*------------------------------------------------------------------------- + * + * port.h + * Header for src/port/ compatibility functions. + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/port.h + * + *------------------------------------------------------------------------- + */ +#ifndef PG_PORT_H +#define PG_PORT_H + +#include <ctype.h> +#include <netdb.h> +#include <pwd.h> + +/* + * Windows has enough specialized port stuff that we push most of it off + * into another file. + * Note: Some CYGWIN includes might #define WIN32. + */ +#if defined(WIN32) && !defined(__CYGWIN__) +#include "port/win32_port.h" +#endif + +/* socket has a different definition on WIN32 */ +#ifndef WIN32 +typedef int pgsocket; + +#define PGINVALID_SOCKET (-1) +#else +typedef SOCKET pgsocket; + +#define PGINVALID_SOCKET INVALID_SOCKET +#endif + +/* non-blocking */ +extern bool pg_set_noblock(pgsocket sock); +extern bool pg_set_block(pgsocket sock); + +/* Portable path handling for Unix/Win32 (in path.c) */ + +extern bool has_drive_prefix(const char *filename); +extern char *first_dir_separator(const char *filename); +extern char *last_dir_separator(const char *filename); +extern char *first_path_var_separator(const char *pathlist); +extern void join_path_components(char *ret_path, + const char *head, const char *tail); +extern void canonicalize_path(char *path); +extern void make_native_path(char *path); +extern void cleanup_path(char *path); +extern bool path_contains_parent_reference(const char *path); +extern bool path_is_relative_and_below_cwd(const char *path); +extern bool path_is_prefix_of_path(const char *path1, const char *path2); +extern char *make_absolute_path(const char *path); +extern const char *get_progname(const char *argv0); +extern void get_share_path(const char *my_exec_path, char *ret_path); +extern void get_etc_path(const char *my_exec_path, char *ret_path); +extern void get_include_path(const char *my_exec_path, char *ret_path); +extern void get_pkginclude_path(const char *my_exec_path, char *ret_path); +extern void get_includeserver_path(const char *my_exec_path, char *ret_path); +extern void get_lib_path(const char *my_exec_path, char *ret_path); +extern void get_pkglib_path(const char *my_exec_path, char *ret_path); +extern void get_locale_path(const char *my_exec_path, char *ret_path); +extern void get_doc_path(const char *my_exec_path, char *ret_path); +extern void get_html_path(const char *my_exec_path, char *ret_path); +extern void get_man_path(const char *my_exec_path, char *ret_path); +extern bool get_home_path(char *ret_path); +extern void get_parent_directory(char *path); + +/* common/pgfnames.c */ +extern char **pgfnames(const char *path); +extern void pgfnames_cleanup(char **filenames); + +/* + * is_absolute_path + * + * By making this a macro we avoid needing to include path.c in libpq. + */ +#ifndef WIN32 +#define IS_DIR_SEP(ch) ((ch) == '/') + +#define is_absolute_path(filename) \ +( \ + IS_DIR_SEP((filename)[0]) \ +) +#else +#define IS_DIR_SEP(ch) ((ch) == '/' || (ch) == '\\') + +/* See path_is_relative_and_below_cwd() for how we handle 'E:abc'. */ +#define is_absolute_path(filename) \ +( \ + IS_DIR_SEP((filename)[0]) || \ + (isalpha((unsigned char) ((filename)[0])) && (filename)[1] == ':' && \ + IS_DIR_SEP((filename)[2])) \ +) +#endif + +/* Portable locale initialization (in exec.c) */ +extern void set_pglocale_pgservice(const char *argv0, const char *app); + +/* Portable way to find and execute binaries (in exec.c) */ +extern int find_my_exec(const char *argv0, char *retpath); +extern int find_other_exec(const char *argv0, const char *target, + const char *versionstr, char *retpath); +extern char *pipe_read_line(char *cmd, char *line, int maxsize); + +/* Doesn't belong here, but this is used with find_other_exec(), so... */ +#define PG_BACKEND_VERSIONSTR "postgres (PostgreSQL) " PG_VERSION "\n" + + +#if defined(WIN32) || defined(__CYGWIN__) +#define EXE ".exe" +#else +#define EXE "" +#endif + +#if defined(WIN32) && !defined(__CYGWIN__) +#define DEVNULL "nul" +#else +#define DEVNULL "/dev/null" +#endif + +/* Portable delay handling */ +extern void pg_usleep(long microsec); + +/* Portable SQL-like case-independent comparisons and conversions */ +extern int pg_strcasecmp(const char *s1, const char *s2); +extern int pg_strncasecmp(const char *s1, const char *s2, size_t n); +extern unsigned char pg_toupper(unsigned char ch); +extern unsigned char pg_tolower(unsigned char ch); +extern unsigned char pg_ascii_toupper(unsigned char ch); +extern unsigned char pg_ascii_tolower(unsigned char ch); + +/* + * Beginning in v12, we always replace snprintf() and friends with our own + * implementation. This symbol is no longer consulted by the core code, + * but keep it defined anyway in case any extensions are looking at it. + */ +#define USE_REPL_SNPRINTF 1 + +/* + * Versions of libintl >= 0.13 try to replace printf() and friends with + * macros to their own versions that understand the %$ format. We do the + * same, so disable their macros, if they exist. + */ +#ifdef vsnprintf +#undef vsnprintf +#endif +#ifdef snprintf +#undef snprintf +#endif +#ifdef vsprintf +#undef vsprintf +#endif +#ifdef sprintf +#undef sprintf +#endif +#ifdef vfprintf +#undef vfprintf +#endif +#ifdef fprintf +#undef fprintf +#endif +#ifdef vprintf +#undef vprintf +#endif +#ifdef printf +#undef printf +#endif + +extern int pg_vsnprintf(char *str, size_t count, const char *fmt, va_list args); +extern int pg_snprintf(char *str, size_t count, const char *fmt,...) pg_attribute_printf(3, 4); +extern int pg_vsprintf(char *str, const char *fmt, va_list args); +extern int pg_sprintf(char *str, const char *fmt,...) pg_attribute_printf(2, 3); +extern int pg_vfprintf(FILE *stream, const char *fmt, va_list args); +extern int pg_fprintf(FILE *stream, const char *fmt,...) pg_attribute_printf(2, 3); +extern int pg_vprintf(const char *fmt, va_list args); +extern int pg_printf(const char *fmt,...) pg_attribute_printf(1, 2); + +/* + * We use __VA_ARGS__ for printf to prevent replacing references to + * the "printf" format archetype in format() attribute declarations. + * That unfortunately means that taking a function pointer to printf + * will not do what we'd wish. (If you need to do that, you must name + * pg_printf explicitly.) For printf's sibling functions, use + * parameterless macros so that function pointers will work unsurprisingly. + */ +#define vsnprintf pg_vsnprintf +#define snprintf pg_snprintf +#define vsprintf pg_vsprintf +#define sprintf pg_sprintf +#define vfprintf pg_vfprintf +#define fprintf pg_fprintf +#define vprintf pg_vprintf +#define printf(...) pg_printf(__VA_ARGS__) + +/* This is also provided by snprintf.c */ +extern int pg_strfromd(char *str, size_t count, int precision, double value); + +/* Replace strerror() with our own, somewhat more robust wrapper */ +extern char *pg_strerror(int errnum); +#define strerror pg_strerror + +/* Likewise for strerror_r(); note we prefer the GNU API for that */ +extern char *pg_strerror_r(int errnum, char *buf, size_t buflen); +#define strerror_r pg_strerror_r +#define PG_STRERROR_R_BUFLEN 256 /* Recommended buffer size for strerror_r */ + +/* Wrap strsignal(), or provide our own version if necessary */ +extern const char *pg_strsignal(int signum); + +/* Portable prompt handling */ +extern void simple_prompt(const char *prompt, char *destination, size_t destlen, + bool echo); + +extern int pclose_check(FILE *stream); + +/* Global variable holding time zone information. */ +#if defined(WIN32) || defined(__CYGWIN__) +#define TIMEZONE_GLOBAL _timezone +#define TZNAME_GLOBAL _tzname +#else +#define TIMEZONE_GLOBAL timezone +#define TZNAME_GLOBAL tzname +#endif + +#if defined(WIN32) || defined(__CYGWIN__) +/* + * Win32 doesn't have reliable rename/unlink during concurrent access. + */ +extern int pgrename(const char *from, const char *to); +extern int pgunlink(const char *path); + +/* Include this first so later includes don't see these defines */ +#ifdef _MSC_VER +#include <io.h> +#endif + +#define rename(from, to) pgrename(from, to) +#define unlink(path) pgunlink(path) +#endif /* defined(WIN32) || defined(__CYGWIN__) */ + +/* + * Win32 also doesn't have symlinks, but we can emulate them with + * junction points on newer Win32 versions. + * + * Cygwin has its own symlinks which work on Win95/98/ME where + * junction points don't, so use those instead. We have no way of + * knowing what type of system Cygwin binaries will be run on. + * Note: Some CYGWIN includes might #define WIN32. + */ +#if defined(WIN32) && !defined(__CYGWIN__) +extern int pgsymlink(const char *oldpath, const char *newpath); +extern int pgreadlink(const char *path, char *buf, size_t size); +extern bool pgwin32_is_junction(const char *path); + +#define symlink(oldpath, newpath) pgsymlink(oldpath, newpath) +#define readlink(path, buf, size) pgreadlink(path, buf, size) +#endif + +extern bool rmtree(const char *path, bool rmtopdir); + +#if defined(WIN32) && !defined(__CYGWIN__) + +/* + * open() and fopen() replacements to allow deletion of open files and + * passing of other special options. + */ +#define O_DIRECT 0x80000000 +extern int pgwin32_open(const char *, int,...); +extern FILE *pgwin32_fopen(const char *, const char *); +#define open(a,b,c) pgwin32_open(a,b,c) +#define fopen(a,b) pgwin32_fopen(a,b) + +/* + * Mingw-w64 headers #define popen and pclose to _popen and _pclose. We want + * to use our popen wrapper, rather than plain _popen, so override that. For + * consistency, use our version of pclose, too. + */ +#ifdef popen +#undef popen +#endif +#ifdef pclose +#undef pclose +#endif + +/* + * system() and popen() replacements to enclose the command in an extra + * pair of quotes. + */ +extern int pgwin32_system(const char *command); +extern FILE *pgwin32_popen(const char *command, const char *type); + +#define system(a) pgwin32_system(a) +#define popen(a,b) pgwin32_popen(a,b) +#define pclose(a) _pclose(a) + +/* New versions of MingW have gettimeofday, old mingw and msvc don't */ +#ifndef HAVE_GETTIMEOFDAY +/* Last parameter not used */ +extern int gettimeofday(struct timeval *tp, struct timezone *tzp); +#endif +#else /* !WIN32 */ + +/* + * Win32 requires a special close for sockets and pipes, while on Unix + * close() does them all. + */ +#define closesocket close +#endif /* WIN32 */ + +/* + * On Windows, setvbuf() does not support _IOLBF mode, and interprets that + * as _IOFBF. To add insult to injury, setvbuf(file, NULL, _IOFBF, 0) + * crashes outright if "parameter validation" is enabled. Therefore, in + * places where we'd like to select line-buffered mode, we fall back to + * unbuffered mode instead on Windows. Always use PG_IOLBF not _IOLBF + * directly in order to implement this behavior. + */ +#ifndef WIN32 +#define PG_IOLBF _IOLBF +#else +#define PG_IOLBF _IONBF +#endif + +/* + * Default "extern" declarations or macro substitutes for library routines. + * When necessary, these routines are provided by files in src/port/. + */ + +/* Type to use with fseeko/ftello */ +#ifndef WIN32 /* WIN32 is handled in port/win32_port.h */ +#define pgoff_t off_t +#endif + +extern double pg_erand48(unsigned short xseed[3]); +extern long pg_lrand48(void); +extern long pg_jrand48(unsigned short xseed[3]); +extern void pg_srand48(long seed); + +#ifndef HAVE_FLS +extern int fls(int mask); +#endif + +#ifndef HAVE_GETPEEREID +/* On Windows, Perl might have incompatible definitions of uid_t and gid_t. */ +#ifndef PLPERL_HAVE_UID_GID +extern int getpeereid(int sock, uid_t *uid, gid_t *gid); +#endif +#endif + +/* + * Glibc doesn't use the builtin for clang due to a *gcc* bug in a version + * newer than the gcc compatibility clang claims to have. This would cause a + * *lot* of superfluous function calls, therefore revert when using clang. In + * C++ there's issues with libc++ (not libstdc++), so disable as well. + */ +#if defined(__clang__) && !defined(__cplusplus) +/* needs to be separate to not confuse other compilers */ +#if __has_builtin(__builtin_isinf) +/* need to include before, to avoid getting overwritten */ +#include <math.h> +#undef isinf +#define isinf __builtin_isinf +#endif /* __has_builtin(isinf) */ +#endif /* __clang__ && !__cplusplus */ + +#ifndef HAVE_EXPLICIT_BZERO +extern void explicit_bzero(void *buf, size_t len); +#endif + +#ifndef HAVE_STRTOF +extern float strtof(const char *nptr, char **endptr); +#endif + +#ifdef HAVE_BUGGY_STRTOF +extern float pg_strtof(const char *nptr, char **endptr); +#define strtof(a,b) (pg_strtof((a),(b))) +#endif + +#ifndef HAVE_LINK +extern int link(const char *src, const char *dst); +#endif + +#ifndef HAVE_MKDTEMP +extern char *mkdtemp(char *path); +#endif + +#ifndef HAVE_INET_ATON +#include <netinet/in.h> +#include <arpa/inet.h> +extern int inet_aton(const char *cp, struct in_addr *addr); +#endif + +/* + * Windows and older Unix don't have pread(2) and pwrite(2). We have + * replacement functions, but they have slightly different semantics so we'll + * use a name with a pg_ prefix to avoid confusion. + */ +#ifdef HAVE_PREAD +#define pg_pread pread +#else +extern ssize_t pg_pread(int fd, void *buf, size_t nbyte, off_t offset); +#endif + +#ifdef HAVE_PWRITE +#define pg_pwrite pwrite +#else +extern ssize_t pg_pwrite(int fd, const void *buf, size_t nbyte, off_t offset); +#endif + +#if !HAVE_DECL_STRLCAT +extern size_t strlcat(char *dst, const char *src, size_t siz); +#endif + +#if !HAVE_DECL_STRLCPY +extern size_t strlcpy(char *dst, const char *src, size_t siz); +#endif + +#if !HAVE_DECL_STRNLEN +extern size_t strnlen(const char *str, size_t maxlen); +#endif + +#if !defined(HAVE_RANDOM) +extern long random(void); +#endif + +#ifndef HAVE_SETENV +extern int setenv(const char *name, const char *value, int overwrite); +#endif + +#ifndef HAVE_UNSETENV +extern void unsetenv(const char *name); +#endif + +#ifndef HAVE_SRANDOM +extern void srandom(unsigned int seed); +#endif + +#ifndef HAVE_DLOPEN +extern void *dlopen(const char *file, int mode); +extern void *dlsym(void *handle, const char *symbol); +extern int dlclose(void *handle); +extern char *dlerror(void); +#endif + +/* + * In some older systems, the RTLD_NOW flag isn't defined and the mode + * argument to dlopen must always be 1. + */ +#if !HAVE_DECL_RTLD_NOW +#define RTLD_NOW 1 +#endif + +/* + * The RTLD_GLOBAL flag is wanted if available, but it doesn't exist + * everywhere. If it doesn't exist, set it to 0 so it has no effect. + */ +#if !HAVE_DECL_RTLD_GLOBAL +#define RTLD_GLOBAL 0 +#endif + +/* thread.h */ +#ifndef WIN32 +extern int pqGetpwuid(uid_t uid, struct passwd *resultbuf, char *buffer, + size_t buflen, struct passwd **result); +#endif + +extern int pqGethostbyname(const char *name, + struct hostent *resultbuf, + char *buffer, size_t buflen, + struct hostent **result, + int *herrno); + +extern void pg_qsort(void *base, size_t nel, size_t elsize, + int (*cmp) (const void *, const void *)); +extern int pg_qsort_strcmp(const void *a, const void *b); + +#define qsort(a,b,c,d) pg_qsort(a,b,c,d) + +typedef int (*qsort_arg_comparator) (const void *a, const void *b, void *arg); + +extern void qsort_arg(void *base, size_t nel, size_t elsize, + qsort_arg_comparator cmp, void *arg); + +/* port/chklocale.c */ +extern int pg_get_encoding_from_locale(const char *ctype, bool write_message); + +#if defined(WIN32) && !defined(FRONTEND) +extern int pg_codepage_to_encoding(UINT cp); +#endif + +/* port/inet_net_ntop.c */ +extern char *pg_inet_net_ntop(int af, const void *src, int bits, + char *dst, size_t size); + +/* port/pg_strong_random.c */ +extern bool pg_strong_random(void *buf, size_t len); + +/* + * pg_backend_random used to be a wrapper for pg_strong_random before + * Postgres 12 for the backend code. + */ +#define pg_backend_random pg_strong_random + +/* port/pgcheckdir.c */ +extern int pg_check_dir(const char *dir); + +/* port/pgmkdirp.c */ +extern int pg_mkdir_p(char *path, int omode); + +/* port/pqsignal.c */ +typedef void (*pqsigfunc) (int signo); +extern pqsigfunc pqsignal(int signo, pqsigfunc func); + +/* port/quotes.c */ +extern char *escape_single_quotes_ascii(const char *src); + +/* common/wait_error.c */ +extern char *wait_result_to_str(int exit_status); +extern bool wait_result_is_signal(int exit_status, int signum); +extern bool wait_result_is_any_signal(int exit_status, bool include_command_not_found); + +#endif /* PG_PORT_H */ diff --git a/contrib/libs/postgresql/src/include/postgres.h b/contrib/libs/postgresql/src/include/postgres.h new file mode 100644 index 0000000000..c48f47e930 --- /dev/null +++ b/contrib/libs/postgresql/src/include/postgres.h @@ -0,0 +1,764 @@ +/*------------------------------------------------------------------------- + * + * postgres.h + * Primary include file for PostgreSQL server .c files + * + * This should be the first file included by PostgreSQL backend modules. + * Client-side code should include postgres_fe.h instead. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1995, Regents of the University of California + * + * src/include/postgres.h + * + *------------------------------------------------------------------------- + */ +/* + *---------------------------------------------------------------- + * TABLE OF CONTENTS + * + * When adding stuff to this file, please try to put stuff + * into the relevant section, or add new sections as appropriate. + * + * section description + * ------- ------------------------------------------------ + * 1) variable-length datatypes (TOAST support) + * 2) Datum type + support macros + * + * NOTES + * + * In general, this file should contain declarations that are widely needed + * in the backend environment, but are of no interest outside the backend. + * + * Simple type definitions live in c.h, where they are shared with + * postgres_fe.h. We do that since those type definitions are needed by + * frontend modules that want to deal with binary data transmission to or + * from the backend. Type definitions in this file should be for + * representations that never escape the backend, such as Datum or + * TOASTed varlena objects. + * + *---------------------------------------------------------------- + */ +#ifndef POSTGRES_H +#define POSTGRES_H + +#include "c.h" +#include "utils/elog.h" +#include "utils/palloc.h" + +/* ---------------------------------------------------------------- + * Section 1: variable-length datatypes (TOAST support) + * ---------------------------------------------------------------- + */ + +/* + * struct varatt_external is a traditional "TOAST pointer", that is, the + * information needed to fetch a Datum stored out-of-line in a TOAST table. + * The data is compressed if and only if va_extsize < va_rawsize - VARHDRSZ. + * This struct must not contain any padding, because we sometimes compare + * these pointers using memcmp. + * + * Note that this information is stored unaligned within actual tuples, so + * you need to memcpy from the tuple into a local struct variable before + * you can look at these fields! (The reason we use memcmp is to avoid + * having to do that just to detect equality of two TOAST pointers...) + */ +typedef struct varatt_external +{ + int32 va_rawsize; /* Original data size (includes header) */ + int32 va_extsize; /* External saved size (doesn't) */ + Oid va_valueid; /* Unique ID of value within TOAST table */ + Oid va_toastrelid; /* RelID of TOAST table containing it */ +} varatt_external; + +/* + * struct varatt_indirect is a "TOAST pointer" representing an out-of-line + * Datum that's stored in memory, not in an external toast relation. + * The creator of such a Datum is entirely responsible that the referenced + * storage survives for as long as referencing pointer Datums can exist. + * + * Note that just as for struct varatt_external, this struct is stored + * unaligned within any containing tuple. + */ +typedef struct varatt_indirect +{ + struct varlena *pointer; /* Pointer to in-memory varlena */ +} varatt_indirect; + +/* + * struct varatt_expanded is a "TOAST pointer" representing an out-of-line + * Datum that is stored in memory, in some type-specific, not necessarily + * physically contiguous format that is convenient for computation not + * storage. APIs for this, in particular the definition of struct + * ExpandedObjectHeader, are in src/include/utils/expandeddatum.h. + * + * Note that just as for struct varatt_external, this struct is stored + * unaligned within any containing tuple. + */ +typedef struct ExpandedObjectHeader ExpandedObjectHeader; + +typedef struct varatt_expanded +{ + ExpandedObjectHeader *eohptr; +} varatt_expanded; + +/* + * Type tag for the various sorts of "TOAST pointer" datums. The peculiar + * value for VARTAG_ONDISK comes from a requirement for on-disk compatibility + * with a previous notion that the tag field was the pointer datum's length. + */ +typedef enum vartag_external +{ + VARTAG_INDIRECT = 1, + VARTAG_EXPANDED_RO = 2, + VARTAG_EXPANDED_RW = 3, + VARTAG_ONDISK = 18 +} vartag_external; + +/* this test relies on the specific tag values above */ +#define VARTAG_IS_EXPANDED(tag) \ + (((tag) & ~1) == VARTAG_EXPANDED_RO) + +#define VARTAG_SIZE(tag) \ + ((tag) == VARTAG_INDIRECT ? sizeof(varatt_indirect) : \ + VARTAG_IS_EXPANDED(tag) ? sizeof(varatt_expanded) : \ + (tag) == VARTAG_ONDISK ? sizeof(varatt_external) : \ + TrapMacro(true, "unrecognized TOAST vartag")) + +/* + * These structs describe the header of a varlena object that may have been + * TOASTed. Generally, don't reference these structs directly, but use the + * macros below. + * + * We use separate structs for the aligned and unaligned cases because the + * compiler might otherwise think it could generate code that assumes + * alignment while touching fields of a 1-byte-header varlena. + */ +typedef union +{ + struct /* Normal varlena (4-byte length) */ + { + uint32 va_header; + char va_data[FLEXIBLE_ARRAY_MEMBER]; + } va_4byte; + struct /* Compressed-in-line format */ + { + uint32 va_header; + uint32 va_rawsize; /* Original data size (excludes header) */ + char va_data[FLEXIBLE_ARRAY_MEMBER]; /* Compressed data */ + } va_compressed; +} varattrib_4b; + +typedef struct +{ + uint8 va_header; + char va_data[FLEXIBLE_ARRAY_MEMBER]; /* Data begins here */ +} varattrib_1b; + +/* TOAST pointers are a subset of varattrib_1b with an identifying tag byte */ +typedef struct +{ + uint8 va_header; /* Always 0x80 or 0x01 */ + uint8 va_tag; /* Type of datum */ + char va_data[FLEXIBLE_ARRAY_MEMBER]; /* Type-specific data */ +} varattrib_1b_e; + +/* + * Bit layouts for varlena headers on big-endian machines: + * + * 00xxxxxx 4-byte length word, aligned, uncompressed data (up to 1G) + * 01xxxxxx 4-byte length word, aligned, *compressed* data (up to 1G) + * 10000000 1-byte length word, unaligned, TOAST pointer + * 1xxxxxxx 1-byte length word, unaligned, uncompressed data (up to 126b) + * + * Bit layouts for varlena headers on little-endian machines: + * + * xxxxxx00 4-byte length word, aligned, uncompressed data (up to 1G) + * xxxxxx10 4-byte length word, aligned, *compressed* data (up to 1G) + * 00000001 1-byte length word, unaligned, TOAST pointer + * xxxxxxx1 1-byte length word, unaligned, uncompressed data (up to 126b) + * + * The "xxx" bits are the length field (which includes itself in all cases). + * In the big-endian case we mask to extract the length, in the little-endian + * case we shift. Note that in both cases the flag bits are in the physically + * first byte. Also, it is not possible for a 1-byte length word to be zero; + * this lets us disambiguate alignment padding bytes from the start of an + * unaligned datum. (We now *require* pad bytes to be filled with zero!) + * + * In TOAST pointers the va_tag field (see varattrib_1b_e) is used to discern + * the specific type and length of the pointer datum. + */ + +/* + * Endian-dependent macros. These are considered internal --- use the + * external macros below instead of using these directly. + * + * Note: IS_1B is true for external toast records but VARSIZE_1B will return 0 + * for such records. Hence you should usually check for IS_EXTERNAL before + * checking for IS_1B. + */ + +#ifdef WORDS_BIGENDIAN + +#define VARATT_IS_4B(PTR) \ + ((((varattrib_1b *) (PTR))->va_header & 0x80) == 0x00) +#define VARATT_IS_4B_U(PTR) \ + ((((varattrib_1b *) (PTR))->va_header & 0xC0) == 0x00) +#define VARATT_IS_4B_C(PTR) \ + ((((varattrib_1b *) (PTR))->va_header & 0xC0) == 0x40) +#define VARATT_IS_1B(PTR) \ + ((((varattrib_1b *) (PTR))->va_header & 0x80) == 0x80) +#define VARATT_IS_1B_E(PTR) \ + ((((varattrib_1b *) (PTR))->va_header) == 0x80) +#define VARATT_NOT_PAD_BYTE(PTR) \ + (*((uint8 *) (PTR)) != 0) + +/* VARSIZE_4B() should only be used on known-aligned data */ +#define VARSIZE_4B(PTR) \ + (((varattrib_4b *) (PTR))->va_4byte.va_header & 0x3FFFFFFF) +#define VARSIZE_1B(PTR) \ + (((varattrib_1b *) (PTR))->va_header & 0x7F) +#define VARTAG_1B_E(PTR) \ + (((varattrib_1b_e *) (PTR))->va_tag) + +#define SET_VARSIZE_4B(PTR,len) \ + (((varattrib_4b *) (PTR))->va_4byte.va_header = (len) & 0x3FFFFFFF) +#define SET_VARSIZE_4B_C(PTR,len) \ + (((varattrib_4b *) (PTR))->va_4byte.va_header = ((len) & 0x3FFFFFFF) | 0x40000000) +#define SET_VARSIZE_1B(PTR,len) \ + (((varattrib_1b *) (PTR))->va_header = (len) | 0x80) +#define SET_VARTAG_1B_E(PTR,tag) \ + (((varattrib_1b_e *) (PTR))->va_header = 0x80, \ + ((varattrib_1b_e *) (PTR))->va_tag = (tag)) +#else /* !WORDS_BIGENDIAN */ + +#define VARATT_IS_4B(PTR) \ + ((((varattrib_1b *) (PTR))->va_header & 0x01) == 0x00) +#define VARATT_IS_4B_U(PTR) \ + ((((varattrib_1b *) (PTR))->va_header & 0x03) == 0x00) +#define VARATT_IS_4B_C(PTR) \ + ((((varattrib_1b *) (PTR))->va_header & 0x03) == 0x02) +#define VARATT_IS_1B(PTR) \ + ((((varattrib_1b *) (PTR))->va_header & 0x01) == 0x01) +#define VARATT_IS_1B_E(PTR) \ + ((((varattrib_1b *) (PTR))->va_header) == 0x01) +#define VARATT_NOT_PAD_BYTE(PTR) \ + (*((uint8 *) (PTR)) != 0) + +/* VARSIZE_4B() should only be used on known-aligned data */ +#define VARSIZE_4B(PTR) \ + ((((varattrib_4b *) (PTR))->va_4byte.va_header >> 2) & 0x3FFFFFFF) +#define VARSIZE_1B(PTR) \ + ((((varattrib_1b *) (PTR))->va_header >> 1) & 0x7F) +#define VARTAG_1B_E(PTR) \ + (((varattrib_1b_e *) (PTR))->va_tag) + +#define SET_VARSIZE_4B(PTR,len) \ + (((varattrib_4b *) (PTR))->va_4byte.va_header = (((uint32) (len)) << 2)) +#define SET_VARSIZE_4B_C(PTR,len) \ + (((varattrib_4b *) (PTR))->va_4byte.va_header = (((uint32) (len)) << 2) | 0x02) +#define SET_VARSIZE_1B(PTR,len) \ + (((varattrib_1b *) (PTR))->va_header = (((uint8) (len)) << 1) | 0x01) +#define SET_VARTAG_1B_E(PTR,tag) \ + (((varattrib_1b_e *) (PTR))->va_header = 0x01, \ + ((varattrib_1b_e *) (PTR))->va_tag = (tag)) +#endif /* WORDS_BIGENDIAN */ + +#define VARHDRSZ_SHORT offsetof(varattrib_1b, va_data) +#define VARATT_SHORT_MAX 0x7F +#define VARATT_CAN_MAKE_SHORT(PTR) \ + (VARATT_IS_4B_U(PTR) && \ + (VARSIZE(PTR) - VARHDRSZ + VARHDRSZ_SHORT) <= VARATT_SHORT_MAX) +#define VARATT_CONVERTED_SHORT_SIZE(PTR) \ + (VARSIZE(PTR) - VARHDRSZ + VARHDRSZ_SHORT) + +#define VARHDRSZ_EXTERNAL offsetof(varattrib_1b_e, va_data) + +#define VARDATA_4B(PTR) (((varattrib_4b *) (PTR))->va_4byte.va_data) +#define VARDATA_4B_C(PTR) (((varattrib_4b *) (PTR))->va_compressed.va_data) +#define VARDATA_1B(PTR) (((varattrib_1b *) (PTR))->va_data) +#define VARDATA_1B_E(PTR) (((varattrib_1b_e *) (PTR))->va_data) + +#define VARRAWSIZE_4B_C(PTR) \ + (((varattrib_4b *) (PTR))->va_compressed.va_rawsize) + +/* Externally visible macros */ + +/* + * In consumers oblivious to data alignment, call PG_DETOAST_DATUM_PACKED(), + * VARDATA_ANY(), VARSIZE_ANY() and VARSIZE_ANY_EXHDR(). Elsewhere, call + * PG_DETOAST_DATUM(), VARDATA() and VARSIZE(). Directly fetching an int16, + * int32 or wider field in the struct representing the datum layout requires + * aligned data. memcpy() is alignment-oblivious, as are most operations on + * datatypes, such as text, whose layout struct contains only char fields. + * + * Code assembling a new datum should call VARDATA() and SET_VARSIZE(). + * (Datums begin life untoasted.) + * + * Other macros here should usually be used only by tuple assembly/disassembly + * code and code that specifically wants to work with still-toasted Datums. + */ +#define VARDATA(PTR) VARDATA_4B(PTR) +#define VARSIZE(PTR) VARSIZE_4B(PTR) + +#define VARSIZE_SHORT(PTR) VARSIZE_1B(PTR) +#define VARDATA_SHORT(PTR) VARDATA_1B(PTR) + +#define VARTAG_EXTERNAL(PTR) VARTAG_1B_E(PTR) +#define VARSIZE_EXTERNAL(PTR) (VARHDRSZ_EXTERNAL + VARTAG_SIZE(VARTAG_EXTERNAL(PTR))) +#define VARDATA_EXTERNAL(PTR) VARDATA_1B_E(PTR) + +#define VARATT_IS_COMPRESSED(PTR) VARATT_IS_4B_C(PTR) +#define VARATT_IS_EXTERNAL(PTR) VARATT_IS_1B_E(PTR) +#define VARATT_IS_EXTERNAL_ONDISK(PTR) \ + (VARATT_IS_EXTERNAL(PTR) && VARTAG_EXTERNAL(PTR) == VARTAG_ONDISK) +#define VARATT_IS_EXTERNAL_INDIRECT(PTR) \ + (VARATT_IS_EXTERNAL(PTR) && VARTAG_EXTERNAL(PTR) == VARTAG_INDIRECT) +#define VARATT_IS_EXTERNAL_EXPANDED_RO(PTR) \ + (VARATT_IS_EXTERNAL(PTR) && VARTAG_EXTERNAL(PTR) == VARTAG_EXPANDED_RO) +#define VARATT_IS_EXTERNAL_EXPANDED_RW(PTR) \ + (VARATT_IS_EXTERNAL(PTR) && VARTAG_EXTERNAL(PTR) == VARTAG_EXPANDED_RW) +#define VARATT_IS_EXTERNAL_EXPANDED(PTR) \ + (VARATT_IS_EXTERNAL(PTR) && VARTAG_IS_EXPANDED(VARTAG_EXTERNAL(PTR))) +#define VARATT_IS_EXTERNAL_NON_EXPANDED(PTR) \ + (VARATT_IS_EXTERNAL(PTR) && !VARTAG_IS_EXPANDED(VARTAG_EXTERNAL(PTR))) +#define VARATT_IS_SHORT(PTR) VARATT_IS_1B(PTR) +#define VARATT_IS_EXTENDED(PTR) (!VARATT_IS_4B_U(PTR)) + +#define SET_VARSIZE(PTR, len) SET_VARSIZE_4B(PTR, len) +#define SET_VARSIZE_SHORT(PTR, len) SET_VARSIZE_1B(PTR, len) +#define SET_VARSIZE_COMPRESSED(PTR, len) SET_VARSIZE_4B_C(PTR, len) + +#define SET_VARTAG_EXTERNAL(PTR, tag) SET_VARTAG_1B_E(PTR, tag) + +#define VARSIZE_ANY(PTR) \ + (VARATT_IS_1B_E(PTR) ? VARSIZE_EXTERNAL(PTR) : \ + (VARATT_IS_1B(PTR) ? VARSIZE_1B(PTR) : \ + VARSIZE_4B(PTR))) + +/* Size of a varlena data, excluding header */ +#define VARSIZE_ANY_EXHDR(PTR) \ + (VARATT_IS_1B_E(PTR) ? VARSIZE_EXTERNAL(PTR)-VARHDRSZ_EXTERNAL : \ + (VARATT_IS_1B(PTR) ? VARSIZE_1B(PTR)-VARHDRSZ_SHORT : \ + VARSIZE_4B(PTR)-VARHDRSZ)) + +/* caution: this will not work on an external or compressed-in-line Datum */ +/* caution: this will return a possibly unaligned pointer */ +#define VARDATA_ANY(PTR) \ + (VARATT_IS_1B(PTR) ? VARDATA_1B(PTR) : VARDATA_4B(PTR)) + + +/* ---------------------------------------------------------------- + * Section 2: Datum type + support macros + * ---------------------------------------------------------------- + */ + +/* + * A Datum contains either a value of a pass-by-value type or a pointer to a + * value of a pass-by-reference type. Therefore, we require: + * + * sizeof(Datum) == sizeof(void *) == 4 or 8 + * + * The macros below and the analogous macros for other types should be used to + * convert between a Datum and the appropriate C type. + */ + +typedef uintptr_t Datum; + +/* + * A NullableDatum is used in places where both a Datum and its nullness needs + * to be stored. This can be more efficient than storing datums and nullness + * in separate arrays, due to better spatial locality, even if more space may + * be wasted due to padding. + */ +typedef struct NullableDatum +{ +#define FIELDNO_NULLABLE_DATUM_DATUM 0 + Datum value; +#define FIELDNO_NULLABLE_DATUM_ISNULL 1 + bool isnull; + /* due to alignment padding this could be used for flags for free */ +} NullableDatum; + +#define SIZEOF_DATUM SIZEOF_VOID_P + +/* + * DatumGetBool + * Returns boolean value of a datum. + * + * Note: any nonzero value will be considered true. + */ + +#define DatumGetBool(X) ((bool) ((X) != 0)) + +/* + * BoolGetDatum + * Returns datum representation for a boolean. + * + * Note: any nonzero value will be considered true. + */ + +#define BoolGetDatum(X) ((Datum) ((X) ? 1 : 0)) + +/* + * DatumGetChar + * Returns character value of a datum. + */ + +#define DatumGetChar(X) ((char) (X)) + +/* + * CharGetDatum + * Returns datum representation for a character. + */ + +#define CharGetDatum(X) ((Datum) (X)) + +/* + * Int8GetDatum + * Returns datum representation for an 8-bit integer. + */ + +#define Int8GetDatum(X) ((Datum) (X)) + +/* + * DatumGetUInt8 + * Returns 8-bit unsigned integer value of a datum. + */ + +#define DatumGetUInt8(X) ((uint8) (X)) + +/* + * UInt8GetDatum + * Returns datum representation for an 8-bit unsigned integer. + */ + +#define UInt8GetDatum(X) ((Datum) (X)) + +/* + * DatumGetInt16 + * Returns 16-bit integer value of a datum. + */ + +#define DatumGetInt16(X) ((int16) (X)) + +/* + * Int16GetDatum + * Returns datum representation for a 16-bit integer. + */ + +#define Int16GetDatum(X) ((Datum) (X)) + +/* + * DatumGetUInt16 + * Returns 16-bit unsigned integer value of a datum. + */ + +#define DatumGetUInt16(X) ((uint16) (X)) + +/* + * UInt16GetDatum + * Returns datum representation for a 16-bit unsigned integer. + */ + +#define UInt16GetDatum(X) ((Datum) (X)) + +/* + * DatumGetInt32 + * Returns 32-bit integer value of a datum. + */ + +#define DatumGetInt32(X) ((int32) (X)) + +/* + * Int32GetDatum + * Returns datum representation for a 32-bit integer. + */ + +#define Int32GetDatum(X) ((Datum) (X)) + +/* + * DatumGetUInt32 + * Returns 32-bit unsigned integer value of a datum. + */ + +#define DatumGetUInt32(X) ((uint32) (X)) + +/* + * UInt32GetDatum + * Returns datum representation for a 32-bit unsigned integer. + */ + +#define UInt32GetDatum(X) ((Datum) (X)) + +/* + * DatumGetObjectId + * Returns object identifier value of a datum. + */ + +#define DatumGetObjectId(X) ((Oid) (X)) + +/* + * ObjectIdGetDatum + * Returns datum representation for an object identifier. + */ + +#define ObjectIdGetDatum(X) ((Datum) (X)) + +/* + * DatumGetTransactionId + * Returns transaction identifier value of a datum. + */ + +#define DatumGetTransactionId(X) ((TransactionId) (X)) + +/* + * TransactionIdGetDatum + * Returns datum representation for a transaction identifier. + */ + +#define TransactionIdGetDatum(X) ((Datum) (X)) + +/* + * MultiXactIdGetDatum + * Returns datum representation for a multixact identifier. + */ + +#define MultiXactIdGetDatum(X) ((Datum) (X)) + +/* + * DatumGetCommandId + * Returns command identifier value of a datum. + */ + +#define DatumGetCommandId(X) ((CommandId) (X)) + +/* + * CommandIdGetDatum + * Returns datum representation for a command identifier. + */ + +#define CommandIdGetDatum(X) ((Datum) (X)) + +/* + * DatumGetPointer + * Returns pointer value of a datum. + */ + +#define DatumGetPointer(X) ((Pointer) (X)) + +/* + * PointerGetDatum + * Returns datum representation for a pointer. + */ + +#define PointerGetDatum(X) ((Datum) (X)) + +/* + * DatumGetCString + * Returns C string (null-terminated string) value of a datum. + * + * Note: C string is not a full-fledged Postgres type at present, + * but type input functions use this conversion for their inputs. + */ + +#define DatumGetCString(X) ((char *) DatumGetPointer(X)) + +/* + * CStringGetDatum + * Returns datum representation for a C string (null-terminated string). + * + * Note: C string is not a full-fledged Postgres type at present, + * but type output functions use this conversion for their outputs. + * Note: CString is pass-by-reference; caller must ensure the pointed-to + * value has adequate lifetime. + */ + +#define CStringGetDatum(X) PointerGetDatum(X) + +/* + * DatumGetName + * Returns name value of a datum. + */ + +#define DatumGetName(X) ((Name) DatumGetPointer(X)) + +/* + * NameGetDatum + * Returns datum representation for a name. + * + * Note: Name is pass-by-reference; caller must ensure the pointed-to + * value has adequate lifetime. + */ + +#define NameGetDatum(X) CStringGetDatum(NameStr(*(X))) + +/* + * DatumGetInt64 + * Returns 64-bit integer value of a datum. + * + * Note: this macro hides whether int64 is pass by value or by reference. + */ + +#ifdef USE_FLOAT8_BYVAL +#define DatumGetInt64(X) ((int64) (X)) +#else +#define DatumGetInt64(X) (* ((int64 *) DatumGetPointer(X))) +#endif + +/* + * Int64GetDatum + * Returns datum representation for a 64-bit integer. + * + * Note: if int64 is pass by reference, this function returns a reference + * to palloc'd space. + */ + +#ifdef USE_FLOAT8_BYVAL +#define Int64GetDatum(X) ((Datum) (X)) +#else +extern Datum Int64GetDatum(int64 X); +#endif + +/* + * DatumGetUInt64 + * Returns 64-bit unsigned integer value of a datum. + * + * Note: this macro hides whether int64 is pass by value or by reference. + */ + +#ifdef USE_FLOAT8_BYVAL +#define DatumGetUInt64(X) ((uint64) (X)) +#else +#define DatumGetUInt64(X) (* ((uint64 *) DatumGetPointer(X))) +#endif + +/* + * UInt64GetDatum + * Returns datum representation for a 64-bit unsigned integer. + * + * Note: if int64 is pass by reference, this function returns a reference + * to palloc'd space. + */ + +#ifdef USE_FLOAT8_BYVAL +#define UInt64GetDatum(X) ((Datum) (X)) +#else +#define UInt64GetDatum(X) Int64GetDatum((int64) (X)) +#endif + +/* + * Float <-> Datum conversions + * + * These have to be implemented as inline functions rather than macros, when + * passing by value, because many machines pass int and float function + * parameters/results differently; so we need to play weird games with unions. + */ + +/* + * DatumGetFloat4 + * Returns 4-byte floating point value of a datum. + */ +static inline float4 +DatumGetFloat4(Datum X) +{ + union + { + int32 value; + float4 retval; + } myunion; + + myunion.value = DatumGetInt32(X); + return myunion.retval; +} + +/* + * Float4GetDatum + * Returns datum representation for a 4-byte floating point number. + */ +static inline Datum +Float4GetDatum(float4 X) +{ + union + { + float4 value; + int32 retval; + } myunion; + + myunion.value = X; + return Int32GetDatum(myunion.retval); +} + +/* + * DatumGetFloat8 + * Returns 8-byte floating point value of a datum. + * + * Note: this macro hides whether float8 is pass by value or by reference. + */ + +#ifdef USE_FLOAT8_BYVAL +static inline float8 +DatumGetFloat8(Datum X) +{ + union + { + int64 value; + float8 retval; + } myunion; + + myunion.value = DatumGetInt64(X); + return myunion.retval; +} +#else +#define DatumGetFloat8(X) (* ((float8 *) DatumGetPointer(X))) +#endif + +/* + * Float8GetDatum + * Returns datum representation for an 8-byte floating point number. + * + * Note: if float8 is pass by reference, this function returns a reference + * to palloc'd space. + */ + +#ifdef USE_FLOAT8_BYVAL +static inline Datum +Float8GetDatum(float8 X) +{ + union + { + float8 value; + int64 retval; + } myunion; + + myunion.value = X; + return Int64GetDatum(myunion.retval); +} +#else +extern Datum Float8GetDatum(float8 X); +#endif + + +/* + * Int64GetDatumFast + * Float8GetDatumFast + * + * These macros are intended to allow writing code that does not depend on + * whether int64 and float8 are pass-by-reference types, while not + * sacrificing performance when they are. The argument must be a variable + * that will exist and have the same value for as long as the Datum is needed. + * In the pass-by-ref case, the address of the variable is taken to use as + * the Datum. In the pass-by-val case, these will be the same as the non-Fast + * macros. + */ + +#ifdef USE_FLOAT8_BYVAL +#define Int64GetDatumFast(X) Int64GetDatum(X) +#define Float8GetDatumFast(X) Float8GetDatum(X) +#else +#define Int64GetDatumFast(X) PointerGetDatum(&(X)) +#define Float8GetDatumFast(X) PointerGetDatum(&(X)) +#endif + +#endif /* POSTGRES_H */ diff --git a/contrib/libs/postgresql/src/include/postgres_ext.h b/contrib/libs/postgresql/src/include/postgres_ext.h new file mode 100644 index 0000000000..fdb61b7cf5 --- /dev/null +++ b/contrib/libs/postgresql/src/include/postgres_ext.h @@ -0,0 +1,74 @@ +/*------------------------------------------------------------------------- + * + * postgres_ext.h + * + * This file contains declarations of things that are visible everywhere + * in PostgreSQL *and* are visible to clients of frontend interface libraries. + * For example, the Oid type is part of the API of libpq and other libraries. + * + * Declarations which are specific to a particular interface should + * go in the header file for that interface (such as libpq-fe.h). This + * file is only for fundamental Postgres declarations. + * + * User-written C functions don't count as "external to Postgres." + * Those function much as local modifications to the backend itself, and + * use header files that are otherwise internal to Postgres to interface + * with the backend. + * + * src/include/postgres_ext.h + * + *------------------------------------------------------------------------- + */ + +#ifndef POSTGRES_EXT_H +#define POSTGRES_EXT_H + +#include "pg_config_ext.h" + +/* + * Object ID is a fundamental type in Postgres. + */ +typedef unsigned int Oid; + +#ifdef __cplusplus +#define InvalidOid (Oid(0)) +#else +#define InvalidOid ((Oid) 0) +#endif + +#define OID_MAX UINT_MAX +/* you will need to include <limits.h> to use the above #define */ + +#define atooid(x) ((Oid) strtoul((x), NULL, 10)) +/* the above needs <stdlib.h> */ + + +/* Define a signed 64-bit integer type for use in client API declarations. */ +typedef PG_INT64_TYPE pg_int64; + + +/* + * Identifiers of error message fields. Kept here to keep common + * between frontend and backend, and also to export them to libpq + * applications. + */ +#define PG_DIAG_SEVERITY 'S' +#define PG_DIAG_SEVERITY_NONLOCALIZED 'V' +#define PG_DIAG_SQLSTATE 'C' +#define PG_DIAG_MESSAGE_PRIMARY 'M' +#define PG_DIAG_MESSAGE_DETAIL 'D' +#define PG_DIAG_MESSAGE_HINT 'H' +#define PG_DIAG_STATEMENT_POSITION 'P' +#define PG_DIAG_INTERNAL_POSITION 'p' +#define PG_DIAG_INTERNAL_QUERY 'q' +#define PG_DIAG_CONTEXT 'W' +#define PG_DIAG_SCHEMA_NAME 's' +#define PG_DIAG_TABLE_NAME 't' +#define PG_DIAG_COLUMN_NAME 'c' +#define PG_DIAG_DATATYPE_NAME 'd' +#define PG_DIAG_CONSTRAINT_NAME 'n' +#define PG_DIAG_SOURCE_FILE 'F' +#define PG_DIAG_SOURCE_LINE 'L' +#define PG_DIAG_SOURCE_FUNCTION 'R' + +#endif /* POSTGRES_EXT_H */ diff --git a/contrib/libs/postgresql/src/include/postgres_fe.h b/contrib/libs/postgresql/src/include/postgres_fe.h new file mode 100644 index 0000000000..e99258f2d6 --- /dev/null +++ b/contrib/libs/postgresql/src/include/postgres_fe.h @@ -0,0 +1,29 @@ +/*------------------------------------------------------------------------- + * + * postgres_fe.h + * Primary include file for PostgreSQL client-side .c files + * + * This should be the first file included by PostgreSQL client libraries and + * application programs --- but not by backend modules, which should include + * postgres.h. + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1995, Regents of the University of California + * + * src/include/postgres_fe.h + * + *------------------------------------------------------------------------- + */ +#ifndef POSTGRES_FE_H +#define POSTGRES_FE_H + +#ifndef FRONTEND +#define FRONTEND 1 +#endif + +#include "c.h" + +#include "common/fe_memutils.h" + +#endif /* POSTGRES_FE_H */ diff --git a/contrib/libs/postgresql/src/include/rusagestub.h b/contrib/libs/postgresql/src/include/rusagestub.h new file mode 100644 index 0000000000..3a812a29bc --- /dev/null +++ b/contrib/libs/postgresql/src/include/rusagestub.h @@ -0,0 +1,34 @@ +/*------------------------------------------------------------------------- + * + * rusagestub.h + * Stubs for getrusage(3). + * + * + * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group + * Portions Copyright (c) 1994, Regents of the University of California + * + * src/include/rusagestub.h + * + *------------------------------------------------------------------------- + */ +#ifndef RUSAGESTUB_H +#define RUSAGESTUB_H + +#include <sys/time.h> /* for struct timeval */ +#ifndef WIN32 +#include <sys/times.h> /* for struct tms */ +#endif +#include <limits.h> /* for CLK_TCK */ + +#define RUSAGE_SELF 0 +#define RUSAGE_CHILDREN (-1) + +struct rusage +{ + struct timeval ru_utime; /* user time used */ + struct timeval ru_stime; /* system time used */ +}; + +extern int getrusage(int who, struct rusage *rusage); + +#endif /* RUSAGESTUB_H */ diff --git a/contrib/libs/postgresql/src/include/windowapi.h b/contrib/libs/postgresql/src/include/windowapi.h new file mode 100644 index 0000000000..e8c9fc54d8 --- /dev/null +++ b/contrib/libs/postgresql/src/include/windowapi.h @@ -0,0 +1,64 @@ +/*------------------------------------------------------------------------- + * + * windowapi.h + * API for window functions to extract data from their window + * + * A window function does not receive its arguments in the normal way + * (and therefore the concept of strictness is irrelevant). Instead it + * receives a "WindowObject", which it can fetch with PG_WINDOW_OBJECT() + * (note V1 calling convention must be used). Correct call context can + * be tested with WindowObjectIsValid(). Although argument values are + * not passed, the call is correctly set up so that PG_NARGS() can be + * used and argument type information can be obtained with + * get_fn_expr_argtype(), get_fn_expr_arg_stable(), etc. + * + * Operations on the WindowObject allow the window function to find out + * the current row number, total number of rows in the partition, etc + * and to evaluate its argument expression(s) at various rows in the + * window partition. See the header comments for each WindowObject API + * function in nodeWindowAgg.c for details. + * + * + * Portions Copyright (c) 2000-2020, PostgreSQL Global Development Group + * + * src/include/windowapi.h + * + *------------------------------------------------------------------------- + */ +#ifndef WINDOWAPI_H +#define WINDOWAPI_H + +/* values of "seektype" */ +#define WINDOW_SEEK_CURRENT 0 +#define WINDOW_SEEK_HEAD 1 +#define WINDOW_SEEK_TAIL 2 + +/* this struct is private in nodeWindowAgg.c */ +typedef struct WindowObjectData *WindowObject; + +#define PG_WINDOW_OBJECT() ((WindowObject) fcinfo->context) + +#define WindowObjectIsValid(winobj) \ + ((winobj) != NULL && IsA(winobj, WindowObjectData)) + +extern void *WinGetPartitionLocalMemory(WindowObject winobj, Size sz); + +extern int64 WinGetCurrentPosition(WindowObject winobj); +extern int64 WinGetPartitionRowCount(WindowObject winobj); + +extern void WinSetMarkPosition(WindowObject winobj, int64 markpos); + +extern bool WinRowsArePeers(WindowObject winobj, int64 pos1, int64 pos2); + +extern Datum WinGetFuncArgInPartition(WindowObject winobj, int argno, + int relpos, int seektype, bool set_mark, + bool *isnull, bool *isout); + +extern Datum WinGetFuncArgInFrame(WindowObject winobj, int argno, + int relpos, int seektype, bool set_mark, + bool *isnull, bool *isout); + +extern Datum WinGetFuncArgCurrent(WindowObject winobj, int argno, + bool *isnull); + +#endif /* WINDOWAPI_H */ diff --git a/contrib/libs/postgresql/ya.make b/contrib/libs/postgresql/ya.make new file mode 100644 index 0000000000..fdefae7428 --- /dev/null +++ b/contrib/libs/postgresql/ya.make @@ -0,0 +1,839 @@ +# Generated by devtools/yamaker from nixpkgs 21.11. + +LIBRARY(postgres) + +OWNER(g:cpp-contrib) + +VERSION(13.5) + +ORIGINAL_SOURCE(mirror://postgresql/source/v13.5/postgresql-13.5.tar.bz2) + +LICENSE( + Apache-2.0 AND + BSD-2-Clause-Views AND + BSD-3-Clause AND + BSL-1.0 AND + Bison-exception-2.2 AND + GPL-1.0-or-later AND + GPL-3.0-or-later AND + ISC AND + LicenseRef-scancode-generic-exception AND + LicenseRef-scancode-proprietary-license AND + LicenseRef-scancode-warranty-disclaimer AND + MIT AND + Martin-Birgmeier AND + PostgreSQL AND + Public-Domain AND + Spencer-99 AND + TCL +) + +LICENSE_TEXTS(.yandex_meta/licenses.list.txt) + +PEERDIR( + contrib/libs/icu + contrib/libs/libc_compat + contrib/libs/libiconv + contrib/libs/libxml + contrib/libs/openssl +) + +ADDINCL( + contrib/libs/libiconv/include + contrib/libs/postgresql/src/backend/bootstrap + contrib/libs/postgresql/src/backend/parser + contrib/libs/postgresql/src/backend/replication + contrib/libs/postgresql/src/backend/replication/logical + contrib/libs/postgresql/src/backend/utils/adt + contrib/libs/postgresql/src/backend/utils/misc + contrib/libs/postgresql/src/backend/utils/sort + contrib/libs/postgresql/src/common + contrib/libs/postgresql/src/include + contrib/libs/postgresql/src/port +) + +NO_COMPILER_WARNINGS() + +NO_RUNTIME() + +CFLAGS( + -DDLSUFFIX=\".so\" +) + +SRCS( + src/backend/access/brin/brin.c + src/backend/access/brin/brin_inclusion.c + src/backend/access/brin/brin_minmax.c + src/backend/access/brin/brin_pageops.c + src/backend/access/brin/brin_revmap.c + src/backend/access/brin/brin_tuple.c + src/backend/access/brin/brin_validate.c + src/backend/access/brin/brin_xlog.c + src/backend/access/common/attmap.c + src/backend/access/common/bufmask.c + src/backend/access/common/detoast.c + src/backend/access/common/heaptuple.c + src/backend/access/common/indextuple.c + src/backend/access/common/printsimple.c + src/backend/access/common/printtup.c + src/backend/access/common/relation.c + src/backend/access/common/reloptions.c + src/backend/access/common/scankey.c + src/backend/access/common/session.c + src/backend/access/common/toast_internals.c + src/backend/access/common/tupconvert.c + src/backend/access/common/tupdesc.c + src/backend/access/gin/ginarrayproc.c + src/backend/access/gin/ginbtree.c + src/backend/access/gin/ginbulk.c + src/backend/access/gin/gindatapage.c + src/backend/access/gin/ginentrypage.c + src/backend/access/gin/ginfast.c + src/backend/access/gin/ginget.c + src/backend/access/gin/gininsert.c + src/backend/access/gin/ginlogic.c + src/backend/access/gin/ginpostinglist.c + src/backend/access/gin/ginscan.c + src/backend/access/gin/ginutil.c + src/backend/access/gin/ginvacuum.c + src/backend/access/gin/ginvalidate.c + src/backend/access/gin/ginxlog.c + src/backend/access/gist/gist.c + src/backend/access/gist/gistbuild.c + src/backend/access/gist/gistbuildbuffers.c + src/backend/access/gist/gistget.c + src/backend/access/gist/gistproc.c + src/backend/access/gist/gistscan.c + src/backend/access/gist/gistsplit.c + src/backend/access/gist/gistutil.c + src/backend/access/gist/gistvacuum.c + src/backend/access/gist/gistvalidate.c + src/backend/access/gist/gistxlog.c + src/backend/access/hash/hash.c + src/backend/access/hash/hash_xlog.c + src/backend/access/hash/hashfunc.c + src/backend/access/hash/hashinsert.c + src/backend/access/hash/hashovfl.c + src/backend/access/hash/hashpage.c + src/backend/access/hash/hashsearch.c + src/backend/access/hash/hashsort.c + src/backend/access/hash/hashutil.c + src/backend/access/hash/hashvalidate.c + src/backend/access/heap/heapam.c + src/backend/access/heap/heapam_handler.c + src/backend/access/heap/heapam_visibility.c + src/backend/access/heap/heaptoast.c + src/backend/access/heap/hio.c + src/backend/access/heap/pruneheap.c + src/backend/access/heap/rewriteheap.c + src/backend/access/heap/syncscan.c + src/backend/access/heap/vacuumlazy.c + src/backend/access/heap/visibilitymap.c + src/backend/access/index/amapi.c + src/backend/access/index/amvalidate.c + src/backend/access/index/genam.c + src/backend/access/index/indexam.c + src/backend/access/nbtree/nbtcompare.c + src/backend/access/nbtree/nbtdedup.c + src/backend/access/nbtree/nbtinsert.c + src/backend/access/nbtree/nbtpage.c + src/backend/access/nbtree/nbtree.c + src/backend/access/nbtree/nbtsearch.c + src/backend/access/nbtree/nbtsort.c + src/backend/access/nbtree/nbtsplitloc.c + src/backend/access/nbtree/nbtutils.c + src/backend/access/nbtree/nbtvalidate.c + src/backend/access/nbtree/nbtxlog.c + src/backend/access/rmgrdesc/brindesc.c + src/backend/access/rmgrdesc/clogdesc.c + src/backend/access/rmgrdesc/committsdesc.c + src/backend/access/rmgrdesc/dbasedesc.c + src/backend/access/rmgrdesc/genericdesc.c + src/backend/access/rmgrdesc/gindesc.c + src/backend/access/rmgrdesc/gistdesc.c + src/backend/access/rmgrdesc/hashdesc.c + src/backend/access/rmgrdesc/heapdesc.c + src/backend/access/rmgrdesc/logicalmsgdesc.c + src/backend/access/rmgrdesc/mxactdesc.c + src/backend/access/rmgrdesc/nbtdesc.c + src/backend/access/rmgrdesc/relmapdesc.c + src/backend/access/rmgrdesc/replorigindesc.c + src/backend/access/rmgrdesc/seqdesc.c + src/backend/access/rmgrdesc/smgrdesc.c + src/backend/access/rmgrdesc/spgdesc.c + src/backend/access/rmgrdesc/standbydesc.c + src/backend/access/rmgrdesc/tblspcdesc.c + src/backend/access/rmgrdesc/xactdesc.c + src/backend/access/rmgrdesc/xlogdesc.c + src/backend/access/spgist/spgdoinsert.c + src/backend/access/spgist/spginsert.c + src/backend/access/spgist/spgkdtreeproc.c + src/backend/access/spgist/spgproc.c + src/backend/access/spgist/spgquadtreeproc.c + src/backend/access/spgist/spgscan.c + src/backend/access/spgist/spgtextproc.c + src/backend/access/spgist/spgutils.c + src/backend/access/spgist/spgvacuum.c + src/backend/access/spgist/spgvalidate.c + src/backend/access/spgist/spgxlog.c + src/backend/access/table/table.c + src/backend/access/table/tableam.c + src/backend/access/table/tableamapi.c + src/backend/access/table/toast_helper.c + src/backend/access/tablesample/bernoulli.c + src/backend/access/tablesample/system.c + src/backend/access/tablesample/tablesample.c + src/backend/access/transam/clog.c + src/backend/access/transam/commit_ts.c + src/backend/access/transam/generic_xlog.c + src/backend/access/transam/multixact.c + src/backend/access/transam/parallel.c + src/backend/access/transam/rmgr.c + src/backend/access/transam/slru.c + src/backend/access/transam/subtrans.c + src/backend/access/transam/timeline.c + src/backend/access/transam/transam.c + src/backend/access/transam/twophase.c + src/backend/access/transam/twophase_rmgr.c + src/backend/access/transam/varsup.c + src/backend/access/transam/xact.c + src/backend/access/transam/xlog.c + src/backend/access/transam/xlogarchive.c + src/backend/access/transam/xlogfuncs.c + src/backend/access/transam/xloginsert.c + src/backend/access/transam/xlogreader.c + src/backend/access/transam/xlogutils.c + src/backend/bootstrap/bootparse.c + src/backend/bootstrap/bootstrap.c + src/backend/catalog/aclchk.c + src/backend/catalog/catalog.c + src/backend/catalog/dependency.c + src/backend/catalog/heap.c + src/backend/catalog/index.c + src/backend/catalog/indexing.c + src/backend/catalog/namespace.c + src/backend/catalog/objectaccess.c + src/backend/catalog/objectaddress.c + src/backend/catalog/partition.c + src/backend/catalog/pg_aggregate.c + src/backend/catalog/pg_cast.c + src/backend/catalog/pg_collation.c + src/backend/catalog/pg_constraint.c + src/backend/catalog/pg_conversion.c + src/backend/catalog/pg_db_role_setting.c + src/backend/catalog/pg_depend.c + src/backend/catalog/pg_enum.c + src/backend/catalog/pg_inherits.c + src/backend/catalog/pg_largeobject.c + src/backend/catalog/pg_namespace.c + src/backend/catalog/pg_operator.c + src/backend/catalog/pg_proc.c + src/backend/catalog/pg_publication.c + src/backend/catalog/pg_range.c + src/backend/catalog/pg_shdepend.c + src/backend/catalog/pg_subscription.c + src/backend/catalog/pg_type.c + src/backend/catalog/storage.c + src/backend/catalog/toasting.c + src/backend/commands/aggregatecmds.c + src/backend/commands/alter.c + src/backend/commands/amcmds.c + src/backend/commands/analyze.c + src/backend/commands/async.c + src/backend/commands/cluster.c + src/backend/commands/collationcmds.c + src/backend/commands/comment.c + src/backend/commands/constraint.c + src/backend/commands/conversioncmds.c + src/backend/commands/copy.c + src/backend/commands/createas.c + src/backend/commands/dbcommands.c + src/backend/commands/define.c + src/backend/commands/discard.c + src/backend/commands/dropcmds.c + src/backend/commands/event_trigger.c + src/backend/commands/explain.c + src/backend/commands/extension.c + src/backend/commands/foreigncmds.c + src/backend/commands/functioncmds.c + src/backend/commands/indexcmds.c + src/backend/commands/lockcmds.c + src/backend/commands/matview.c + src/backend/commands/opclasscmds.c + src/backend/commands/operatorcmds.c + src/backend/commands/policy.c + src/backend/commands/portalcmds.c + src/backend/commands/prepare.c + src/backend/commands/proclang.c + src/backend/commands/publicationcmds.c + src/backend/commands/schemacmds.c + src/backend/commands/seclabel.c + src/backend/commands/sequence.c + src/backend/commands/statscmds.c + src/backend/commands/subscriptioncmds.c + src/backend/commands/tablecmds.c + src/backend/commands/tablespace.c + src/backend/commands/trigger.c + src/backend/commands/tsearchcmds.c + src/backend/commands/typecmds.c + src/backend/commands/user.c + src/backend/commands/vacuum.c + src/backend/commands/variable.c + src/backend/commands/view.c + src/backend/executor/execAmi.c + src/backend/executor/execCurrent.c + src/backend/executor/execExpr.c + src/backend/executor/execExprInterp.c + src/backend/executor/execGrouping.c + src/backend/executor/execIndexing.c + src/backend/executor/execJunk.c + src/backend/executor/execMain.c + src/backend/executor/execParallel.c + src/backend/executor/execPartition.c + src/backend/executor/execProcnode.c + src/backend/executor/execReplication.c + src/backend/executor/execSRF.c + src/backend/executor/execScan.c + src/backend/executor/execTuples.c + src/backend/executor/execUtils.c + src/backend/executor/functions.c + src/backend/executor/instrument.c + src/backend/executor/nodeAgg.c + src/backend/executor/nodeAppend.c + src/backend/executor/nodeBitmapAnd.c + src/backend/executor/nodeBitmapHeapscan.c + src/backend/executor/nodeBitmapIndexscan.c + src/backend/executor/nodeBitmapOr.c + src/backend/executor/nodeCtescan.c + src/backend/executor/nodeCustom.c + src/backend/executor/nodeForeignscan.c + src/backend/executor/nodeFunctionscan.c + src/backend/executor/nodeGather.c + src/backend/executor/nodeGatherMerge.c + src/backend/executor/nodeGroup.c + src/backend/executor/nodeHash.c + src/backend/executor/nodeHashjoin.c + src/backend/executor/nodeIncrementalSort.c + src/backend/executor/nodeIndexonlyscan.c + src/backend/executor/nodeIndexscan.c + src/backend/executor/nodeLimit.c + src/backend/executor/nodeLockRows.c + src/backend/executor/nodeMaterial.c + src/backend/executor/nodeMergeAppend.c + src/backend/executor/nodeMergejoin.c + src/backend/executor/nodeModifyTable.c + src/backend/executor/nodeNamedtuplestorescan.c + src/backend/executor/nodeNestloop.c + src/backend/executor/nodeProjectSet.c + src/backend/executor/nodeRecursiveunion.c + src/backend/executor/nodeResult.c + src/backend/executor/nodeSamplescan.c + src/backend/executor/nodeSeqscan.c + src/backend/executor/nodeSetOp.c + src/backend/executor/nodeSort.c + src/backend/executor/nodeSubplan.c + src/backend/executor/nodeSubqueryscan.c + src/backend/executor/nodeTableFuncscan.c + src/backend/executor/nodeTidscan.c + src/backend/executor/nodeUnique.c + src/backend/executor/nodeValuesscan.c + src/backend/executor/nodeWindowAgg.c + src/backend/executor/nodeWorktablescan.c + src/backend/executor/spi.c + src/backend/executor/tqueue.c + src/backend/executor/tstoreReceiver.c + src/backend/foreign/foreign.c + src/backend/jit/jit.c + src/backend/lib/binaryheap.c + src/backend/lib/bipartite_match.c + src/backend/lib/bloomfilter.c + src/backend/lib/dshash.c + src/backend/lib/hyperloglog.c + src/backend/lib/ilist.c + src/backend/lib/integerset.c + src/backend/lib/knapsack.c + src/backend/lib/pairingheap.c + src/backend/lib/rbtree.c + src/backend/libpq/auth-scram.c + src/backend/libpq/auth.c + src/backend/libpq/be-fsstubs.c + src/backend/libpq/be-secure-common.c + src/backend/libpq/be-secure-openssl.c + src/backend/libpq/be-secure.c + src/backend/libpq/crypt.c + src/backend/libpq/hba.c + src/backend/libpq/ifaddr.c + src/backend/libpq/pqcomm.c + src/backend/libpq/pqformat.c + src/backend/libpq/pqmq.c + src/backend/libpq/pqsignal.c + src/backend/nodes/bitmapset.c + src/backend/nodes/copyfuncs.c + src/backend/nodes/equalfuncs.c + src/backend/nodes/extensible.c + src/backend/nodes/list.c + src/backend/nodes/makefuncs.c + src/backend/nodes/nodeFuncs.c + src/backend/nodes/nodes.c + src/backend/nodes/outfuncs.c + src/backend/nodes/params.c + src/backend/nodes/print.c + src/backend/nodes/read.c + src/backend/nodes/readfuncs.c + src/backend/nodes/tidbitmap.c + src/backend/nodes/value.c + src/backend/optimizer/geqo/geqo_copy.c + src/backend/optimizer/geqo/geqo_cx.c + src/backend/optimizer/geqo/geqo_erx.c + src/backend/optimizer/geqo/geqo_eval.c + src/backend/optimizer/geqo/geqo_main.c + src/backend/optimizer/geqo/geqo_misc.c + src/backend/optimizer/geqo/geqo_mutation.c + src/backend/optimizer/geqo/geqo_ox1.c + src/backend/optimizer/geqo/geqo_ox2.c + src/backend/optimizer/geqo/geqo_pmx.c + src/backend/optimizer/geqo/geqo_pool.c + src/backend/optimizer/geqo/geqo_px.c + src/backend/optimizer/geqo/geqo_random.c + src/backend/optimizer/geqo/geqo_recombination.c + src/backend/optimizer/geqo/geqo_selection.c + src/backend/optimizer/path/allpaths.c + src/backend/optimizer/path/clausesel.c + src/backend/optimizer/path/costsize.c + src/backend/optimizer/path/equivclass.c + src/backend/optimizer/path/indxpath.c + src/backend/optimizer/path/joinpath.c + src/backend/optimizer/path/joinrels.c + src/backend/optimizer/path/pathkeys.c + src/backend/optimizer/path/tidpath.c + src/backend/optimizer/plan/analyzejoins.c + src/backend/optimizer/plan/createplan.c + src/backend/optimizer/plan/initsplan.c + src/backend/optimizer/plan/planagg.c + src/backend/optimizer/plan/planmain.c + src/backend/optimizer/plan/planner.c + src/backend/optimizer/plan/setrefs.c + src/backend/optimizer/plan/subselect.c + src/backend/optimizer/prep/prepjointree.c + src/backend/optimizer/prep/prepqual.c + src/backend/optimizer/prep/preptlist.c + src/backend/optimizer/prep/prepunion.c + src/backend/optimizer/util/appendinfo.c + src/backend/optimizer/util/clauses.c + src/backend/optimizer/util/inherit.c + src/backend/optimizer/util/joininfo.c + src/backend/optimizer/util/orclauses.c + src/backend/optimizer/util/paramassign.c + src/backend/optimizer/util/pathnode.c + src/backend/optimizer/util/placeholder.c + src/backend/optimizer/util/plancat.c + src/backend/optimizer/util/predtest.c + src/backend/optimizer/util/relnode.c + src/backend/optimizer/util/restrictinfo.c + src/backend/optimizer/util/tlist.c + src/backend/optimizer/util/var.c + src/backend/parser/analyze.c + src/backend/parser/gram.c + src/backend/parser/parse_agg.c + src/backend/parser/parse_clause.c + src/backend/parser/parse_coerce.c + src/backend/parser/parse_collate.c + src/backend/parser/parse_cte.c + src/backend/parser/parse_enr.c + src/backend/parser/parse_expr.c + src/backend/parser/parse_func.c + src/backend/parser/parse_node.c + src/backend/parser/parse_oper.c + src/backend/parser/parse_param.c + src/backend/parser/parse_relation.c + src/backend/parser/parse_target.c + src/backend/parser/parse_type.c + src/backend/parser/parse_utilcmd.c + src/backend/parser/parser.c + src/backend/parser/scan.c + src/backend/parser/scansup.c + src/backend/partitioning/partbounds.c + src/backend/partitioning/partdesc.c + src/backend/partitioning/partprune.c + src/backend/port/atomics.c + src/backend/postmaster/autovacuum.c + src/backend/postmaster/bgworker.c + src/backend/postmaster/bgwriter.c + src/backend/postmaster/checkpointer.c + src/backend/postmaster/fork_process.c + src/backend/postmaster/interrupt.c + src/backend/postmaster/pgarch.c + src/backend/postmaster/pgstat.c + src/backend/postmaster/postmaster.c + src/backend/postmaster/startup.c + src/backend/postmaster/syslogger.c + src/backend/postmaster/walwriter.c + src/backend/regex/regcomp.c + src/backend/regex/regerror.c + src/backend/regex/regexec.c + src/backend/regex/regexport.c + src/backend/regex/regfree.c + src/backend/regex/regprefix.c + src/backend/replication/backup_manifest.c + src/backend/replication/basebackup.c + src/backend/replication/logical/decode.c + src/backend/replication/logical/launcher.c + src/backend/replication/logical/logical.c + src/backend/replication/logical/logicalfuncs.c + src/backend/replication/logical/message.c + src/backend/replication/logical/origin.c + src/backend/replication/logical/proto.c + src/backend/replication/logical/relation.c + src/backend/replication/logical/reorderbuffer.c + src/backend/replication/logical/snapbuild.c + src/backend/replication/logical/tablesync.c + src/backend/replication/logical/worker.c + src/backend/replication/repl_gram.c + src/backend/replication/slot.c + src/backend/replication/slotfuncs.c + src/backend/replication/syncrep.c + src/backend/replication/syncrep_gram.c + src/backend/replication/walreceiver.c + src/backend/replication/walreceiverfuncs.c + src/backend/replication/walsender.c + src/backend/rewrite/rewriteDefine.c + src/backend/rewrite/rewriteHandler.c + src/backend/rewrite/rewriteManip.c + src/backend/rewrite/rewriteRemove.c + src/backend/rewrite/rewriteSupport.c + src/backend/rewrite/rowsecurity.c + src/backend/statistics/dependencies.c + src/backend/statistics/extended_stats.c + src/backend/statistics/mcv.c + src/backend/statistics/mvdistinct.c + src/backend/storage/buffer/buf_init.c + src/backend/storage/buffer/buf_table.c + src/backend/storage/buffer/bufmgr.c + src/backend/storage/buffer/freelist.c + src/backend/storage/buffer/localbuf.c + src/backend/storage/file/buffile.c + src/backend/storage/file/copydir.c + src/backend/storage/file/fd.c + src/backend/storage/file/reinit.c + src/backend/storage/file/sharedfileset.c + src/backend/storage/freespace/freespace.c + src/backend/storage/freespace/fsmpage.c + src/backend/storage/freespace/indexfsm.c + src/backend/storage/ipc/barrier.c + src/backend/storage/ipc/dsm.c + src/backend/storage/ipc/dsm_impl.c + src/backend/storage/ipc/ipc.c + src/backend/storage/ipc/ipci.c + src/backend/storage/ipc/latch.c + src/backend/storage/ipc/pmsignal.c + src/backend/storage/ipc/procarray.c + src/backend/storage/ipc/procsignal.c + src/backend/storage/ipc/shm_mq.c + src/backend/storage/ipc/shm_toc.c + src/backend/storage/ipc/shmem.c + src/backend/storage/ipc/shmqueue.c + src/backend/storage/ipc/signalfuncs.c + src/backend/storage/ipc/sinval.c + src/backend/storage/ipc/sinvaladt.c + src/backend/storage/ipc/standby.c + src/backend/storage/large_object/inv_api.c + src/backend/storage/lmgr/condition_variable.c + src/backend/storage/lmgr/deadlock.c + src/backend/storage/lmgr/lmgr.c + src/backend/storage/lmgr/lock.c + src/backend/storage/lmgr/lwlock.c + src/backend/storage/lmgr/lwlocknames.c + src/backend/storage/lmgr/predicate.c + src/backend/storage/lmgr/proc.c + src/backend/storage/lmgr/s_lock.c + src/backend/storage/lmgr/spin.c + src/backend/storage/page/bufpage.c + src/backend/storage/page/checksum.c + src/backend/storage/page/itemptr.c + src/backend/storage/smgr/md.c + src/backend/storage/smgr/smgr.c + src/backend/storage/sync/sync.c + src/backend/tcop/cmdtag.c + src/backend/tcop/dest.c + src/backend/tcop/fastpath.c + src/backend/tcop/postgres.c + src/backend/tcop/pquery.c + src/backend/tcop/utility.c + src/backend/tsearch/dict.c + src/backend/tsearch/dict_ispell.c + src/backend/tsearch/dict_simple.c + src/backend/tsearch/dict_synonym.c + src/backend/tsearch/dict_thesaurus.c + src/backend/tsearch/regis.c + src/backend/tsearch/spell.c + src/backend/tsearch/to_tsany.c + src/backend/tsearch/ts_locale.c + src/backend/tsearch/ts_parse.c + src/backend/tsearch/ts_selfuncs.c + src/backend/tsearch/ts_typanalyze.c + src/backend/tsearch/ts_utils.c + src/backend/tsearch/wparser.c + src/backend/tsearch/wparser_def.c + src/backend/utils/adt/acl.c + src/backend/utils/adt/amutils.c + src/backend/utils/adt/array_expanded.c + src/backend/utils/adt/array_selfuncs.c + src/backend/utils/adt/array_typanalyze.c + src/backend/utils/adt/array_userfuncs.c + src/backend/utils/adt/arrayfuncs.c + src/backend/utils/adt/arrayutils.c + src/backend/utils/adt/ascii.c + src/backend/utils/adt/bool.c + src/backend/utils/adt/cash.c + src/backend/utils/adt/char.c + src/backend/utils/adt/cryptohashes.c + src/backend/utils/adt/date.c + src/backend/utils/adt/datetime.c + src/backend/utils/adt/datum.c + src/backend/utils/adt/dbsize.c + src/backend/utils/adt/domains.c + src/backend/utils/adt/encode.c + src/backend/utils/adt/enum.c + src/backend/utils/adt/expandeddatum.c + src/backend/utils/adt/expandedrecord.c + src/backend/utils/adt/float.c + src/backend/utils/adt/format_type.c + src/backend/utils/adt/formatting.c + src/backend/utils/adt/genfile.c + src/backend/utils/adt/geo_ops.c + src/backend/utils/adt/geo_selfuncs.c + src/backend/utils/adt/geo_spgist.c + src/backend/utils/adt/inet_cidr_ntop.c + src/backend/utils/adt/inet_net_pton.c + src/backend/utils/adt/int.c + src/backend/utils/adt/int8.c + src/backend/utils/adt/json.c + src/backend/utils/adt/jsonb.c + src/backend/utils/adt/jsonb_gin.c + src/backend/utils/adt/jsonb_op.c + src/backend/utils/adt/jsonb_util.c + src/backend/utils/adt/jsonfuncs.c + src/backend/utils/adt/jsonpath.c + src/backend/utils/adt/jsonpath_exec.c + src/backend/utils/adt/jsonpath_gram.c + src/backend/utils/adt/like.c + src/backend/utils/adt/like_support.c + src/backend/utils/adt/lockfuncs.c + src/backend/utils/adt/mac.c + src/backend/utils/adt/mac8.c + src/backend/utils/adt/misc.c + src/backend/utils/adt/name.c + src/backend/utils/adt/network.c + src/backend/utils/adt/network_gist.c + src/backend/utils/adt/network_selfuncs.c + src/backend/utils/adt/network_spgist.c + src/backend/utils/adt/numeric.c + src/backend/utils/adt/numutils.c + src/backend/utils/adt/oid.c + src/backend/utils/adt/oracle_compat.c + src/backend/utils/adt/orderedsetaggs.c + src/backend/utils/adt/partitionfuncs.c + src/backend/utils/adt/pg_locale.c + src/backend/utils/adt/pg_lsn.c + src/backend/utils/adt/pg_upgrade_support.c + src/backend/utils/adt/pgstatfuncs.c + src/backend/utils/adt/pseudotypes.c + src/backend/utils/adt/quote.c + src/backend/utils/adt/rangetypes.c + src/backend/utils/adt/rangetypes_gist.c + src/backend/utils/adt/rangetypes_selfuncs.c + src/backend/utils/adt/rangetypes_spgist.c + src/backend/utils/adt/rangetypes_typanalyze.c + src/backend/utils/adt/regexp.c + src/backend/utils/adt/regproc.c + src/backend/utils/adt/ri_triggers.c + src/backend/utils/adt/rowtypes.c + src/backend/utils/adt/ruleutils.c + src/backend/utils/adt/selfuncs.c + src/backend/utils/adt/tid.c + src/backend/utils/adt/timestamp.c + src/backend/utils/adt/trigfuncs.c + src/backend/utils/adt/tsginidx.c + src/backend/utils/adt/tsgistidx.c + src/backend/utils/adt/tsquery.c + src/backend/utils/adt/tsquery_cleanup.c + src/backend/utils/adt/tsquery_gist.c + src/backend/utils/adt/tsquery_op.c + src/backend/utils/adt/tsquery_rewrite.c + src/backend/utils/adt/tsquery_util.c + src/backend/utils/adt/tsrank.c + src/backend/utils/adt/tsvector.c + src/backend/utils/adt/tsvector_op.c + src/backend/utils/adt/tsvector_parser.c + src/backend/utils/adt/uuid.c + src/backend/utils/adt/varbit.c + src/backend/utils/adt/varchar.c + src/backend/utils/adt/varlena.c + src/backend/utils/adt/version.c + src/backend/utils/adt/windowfuncs.c + src/backend/utils/adt/xid.c + src/backend/utils/adt/xid8funcs.c + src/backend/utils/adt/xml.c + src/backend/utils/cache/attoptcache.c + src/backend/utils/cache/catcache.c + src/backend/utils/cache/evtcache.c + src/backend/utils/cache/inval.c + src/backend/utils/cache/lsyscache.c + src/backend/utils/cache/partcache.c + src/backend/utils/cache/plancache.c + src/backend/utils/cache/relcache.c + src/backend/utils/cache/relfilenodemap.c + src/backend/utils/cache/relmapper.c + src/backend/utils/cache/spccache.c + src/backend/utils/cache/syscache.c + src/backend/utils/cache/ts_cache.c + src/backend/utils/cache/typcache.c + src/backend/utils/error/assert.c + src/backend/utils/error/elog.c + src/backend/utils/fmgr/dfmgr.c + src/backend/utils/fmgr/fmgr.c + src/backend/utils/fmgr/funcapi.c + src/backend/utils/fmgrtab.c + src/backend/utils/hash/dynahash.c + src/backend/utils/hash/pg_crc.c + src/backend/utils/init/globals.c + src/backend/utils/init/miscinit.c + src/backend/utils/init/postinit.c + src/backend/utils/mb/conv.c + src/backend/utils/mb/mbutils.c + src/backend/utils/mb/stringinfo_mb.c + src/backend/utils/mb/wstrcmp.c + src/backend/utils/mb/wstrncmp.c + src/backend/utils/misc/guc.c + src/backend/utils/misc/help_config.c + src/backend/utils/misc/pg_config.c + src/backend/utils/misc/pg_controldata.c + src/backend/utils/misc/pg_rusage.c + src/backend/utils/misc/ps_status.c + src/backend/utils/misc/queryenvironment.c + src/backend/utils/misc/rls.c + src/backend/utils/misc/sampling.c + src/backend/utils/misc/superuser.c + src/backend/utils/misc/timeout.c + src/backend/utils/misc/tzparser.c + src/backend/utils/mmgr/aset.c + src/backend/utils/mmgr/dsa.c + src/backend/utils/mmgr/freepage.c + src/backend/utils/mmgr/generation.c + src/backend/utils/mmgr/mcxt.c + src/backend/utils/mmgr/memdebug.c + src/backend/utils/mmgr/portalmem.c + src/backend/utils/mmgr/slab.c + src/backend/utils/resowner/resowner.c + src/backend/utils/sort/logtape.c + src/backend/utils/sort/sharedtuplestore.c + src/backend/utils/sort/sortsupport.c + src/backend/utils/sort/tuplesort.c + src/backend/utils/sort/tuplestore.c + src/backend/utils/time/combocid.c + src/backend/utils/time/snapmgr.c + src/common/archive.c + src/common/base64.c + src/common/checksum_helper.c + src/common/config_info.c + src/common/controldata_utils.c + src/common/d2s.c + src/common/encnames.c + src/common/exec.c + src/common/f2s.c + src/common/file_perm.c + src/common/hashfn.c + src/common/ip.c + src/common/jsonapi.c + src/common/keywords.c + src/common/kwlookup.c + src/common/link-canary.c + src/common/md5.c + src/common/pg_lzcompress.c + src/common/pgfnames.c + src/common/protocol_openssl.c + src/common/psprintf.c + src/common/relpath.c + src/common/rmtree.c + src/common/saslprep.c + src/common/scram-common.c + src/common/sha2_openssl.c + src/common/string.c + src/common/stringinfo.c + src/common/unicode_norm.c + src/common/username.c + src/common/wait_error.c + src/common/wchar.c + src/port/chklocale.c + src/port/erand48.c + src/port/fls.c + src/port/getpeereid.c + src/port/inet_net_ntop.c + src/port/noblock.c + src/port/path.c + src/port/pg_bitutils.c + src/port/pg_crc32c_sb8.c + src/port/pg_crc32c_sse42.c + src/port/pg_crc32c_sse42_choose.c + src/port/pg_strong_random.c + src/port/pgcheckdir.c + src/port/pgmkdirp.c + src/port/pgsleep.c + src/port/pgstrcasecmp.c + src/port/pgstrsignal.c + src/port/pqsignal.c + src/port/qsort.c + src/port/qsort_arg.c + src/port/quotes.c + src/port/snprintf.c + src/port/sprompt.c + src/port/strerror.c + src/port/tar.c + src/port/thread.c + src/timezone/localtime.c + src/timezone/pgtz.c + src/timezone/strftime.c +) + +IF (OS_LINUX OR OS_DARWIN) + SRCS( + src/backend/port/posix_sema.c + src/backend/port/sysv_shmem.c + ) +ELSEIF (OS_WINDOWS) + ADDINCL( + contrib/libs/postgresql/src/include/port + contrib/libs/postgresql/src/include/port/win32 + contrib/libs/postgresql/src/include/port/win32_msvc + ) + SRCS( + src/backend/port/win32/crashdump.c + src/backend/port/win32/signal.c + src/backend/port/win32/socket.c + src/backend/port/win32/timer.c + src/backend/port/win32_sema.c + src/backend/port/win32_shmem.c + src/port/dirmod.c + src/port/dlopen.c + src/port/getaddrinfo.c + src/port/getopt.c + src/port/getrusage.c + src/port/gettimeofday.c + src/port/inet_aton.c + src/port/kill.c + src/port/open.c + src/port/pread.c + src/port/pwrite.c + src/port/system.c + src/port/win32env.c + src/port/win32error.c + src/port/win32security.c + src/port/win32setlocale.c + ) +ENDIF() + +END() + +RECURSE( + bin/postgresql +) diff --git a/ydb/library/yql/parser/pg_catalog/CMakeLists.txt b/ydb/library/yql/parser/pg_catalog/CMakeLists.txt index ef53f0db3e..c4eed486c1 100644 --- a/ydb/library/yql/parser/pg_catalog/CMakeLists.txt +++ b/ydb/library/yql/parser/pg_catalog/CMakeLists.txt @@ -24,36 +24,36 @@ target_link_libraries(yql-parser-pg_catalog.global PUBLIC library-cpp-resource ) target_sources(yql-parser-pg_catalog.global PRIVATE - ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/9bfc0ed24fcfb8e096ec43a8430d7185.cpp - ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/03528211297024b3dbd6ad7bd8089f55.cpp - ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/4bdffcfe6e5c28b12f6f249d751c6cc5.cpp - ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/13089390d5c6426a6f6417928fe4445c.cpp + ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/99bdd9e510834dd355c2457fcccc53d5.cpp + ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/f1a4bc0ed0162412cffb7ad89af053b9.cpp + ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/1ecd65c896f36a3990d870644a6da9c8.cpp + ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/46b25697572e7e60703079b71cd18295.cpp ) resources(yql-parser-pg_catalog.global - ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/9bfc0ed24fcfb8e096ec43a8430d7185.cpp + ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/99bdd9e510834dd355c2457fcccc53d5.cpp INPUTS - ${CMAKE_SOURCE_DIR}/ydb/library/yql/parser/pg_catalog/pg_operator.dat + ${CMAKE_SOURCE_DIR}/contrib/libs/postgresql/src/include/catalog/pg_operator.dat KEYS pg_operator.dat ) resources(yql-parser-pg_catalog.global - ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/03528211297024b3dbd6ad7bd8089f55.cpp + ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/f1a4bc0ed0162412cffb7ad89af053b9.cpp INPUTS - ${CMAKE_SOURCE_DIR}/ydb/library/yql/parser/pg_catalog/pg_proc.dat + ${CMAKE_SOURCE_DIR}/contrib/libs/postgresql/src/include/catalog/pg_proc.dat KEYS pg_proc.dat ) resources(yql-parser-pg_catalog.global - ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/4bdffcfe6e5c28b12f6f249d751c6cc5.cpp + ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/1ecd65c896f36a3990d870644a6da9c8.cpp INPUTS - ${CMAKE_SOURCE_DIR}/ydb/library/yql/parser/pg_catalog/pg_type.dat + ${CMAKE_SOURCE_DIR}/contrib/libs/postgresql/src/include/catalog/pg_type.dat KEYS pg_type.dat ) resources(yql-parser-pg_catalog.global - ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/13089390d5c6426a6f6417928fe4445c.cpp + ${CMAKE_BINARY_DIR}/ydb/library/yql/parser/pg_catalog/46b25697572e7e60703079b71cd18295.cpp INPUTS - ${CMAKE_SOURCE_DIR}/ydb/library/yql/parser/pg_catalog/pg_cast.dat + ${CMAKE_SOURCE_DIR}/contrib/libs/postgresql/src/include/catalog/pg_cast.dat KEYS pg_cast.dat ) diff --git a/ydb/library/yql/parser/pg_catalog/ya.make b/ydb/library/yql/parser/pg_catalog/ya.make index edd9301f9c..d4e8f7f8e5 100644 --- a/ydb/library/yql/parser/pg_catalog/ya.make +++ b/ydb/library/yql/parser/pg_catalog/ya.make @@ -2,10 +2,10 @@ LIBRARY() OWNER(g:yql) -RESOURCE(pg_operator.dat pg_operator.dat) -RESOURCE(pg_proc.dat pg_proc.dat) -RESOURCE(pg_type.dat pg_type.dat) -RESOURCE(pg_cast.dat pg_cast.dat) +RESOURCE(../../../../../contrib/libs/postgresql/src/include/catalog/pg_operator.dat pg_operator.dat) +RESOURCE(../../../../../contrib/libs/postgresql/src/include/catalog/pg_proc.dat pg_proc.dat) +RESOURCE(../../../../../contrib/libs/postgresql/src/include/catalog/pg_type.dat pg_type.dat) +RESOURCE(../../../../../contrib/libs/postgresql/src/include/catalog/pg_cast.dat pg_cast.dat) SRCS( catalog.cpp |