[AGE Packaging] Windows Inno Setup Installer (#926)
* Add control, dll, sql files and assets
* Add inno installer script
* Add readme and update .iss script
---------
Co-authored-by: Sarthak <sarthak.8858@gmail.com>
diff --git a/windows/Inno Installer/README.md b/windows/Inno Installer/README.md
new file mode 100644
index 0000000..be77511
--- /dev/null
+++ b/windows/Inno Installer/README.md
@@ -0,0 +1,8 @@
+## Apache AGE Windows Installer
+
+- Download the Inno Installer from the [Inno Setup](https://jrsoftware.org/isdl.php) website and go through the installation process.
+
+- Open the Inno Setup Compiler and click on the **File > Open**.
+- Select the `apache-age-<version>.iss` file from the **windows\Inno Installer** folder.
+- Click on the **Build > Compile** button to compile the installer and create a exe file.
+- The installer exe setup will be created in the **windows\Inno Installer** folder.
\ No newline at end of file
diff --git a/windows/Inno Installer/age--1.1.1.sql b/windows/Inno Installer/age--1.1.1.sql
new file mode 100644
index 0000000..367f5d9
--- /dev/null
+++ b/windows/Inno Installer/age--1.1.1.sql
@@ -0,0 +1,4173 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION age" to load this file. \quit
+
+--
+-- catalog tables
+--
+
+
+CREATE TABLE ag_graph (
+ graphid oid NOT NULL,
+ name name NOT NULL,
+ namespace regnamespace NOT NULL
+);
+
+CREATE UNIQUE INDEX ag_graph_graphid_index ON ag_graph USING btree (graphid);
+
+CREATE UNIQUE INDEX ag_graph_name_index ON ag_graph USING btree (name);
+
+CREATE UNIQUE INDEX ag_graph_namespace_index
+ON ag_graph
+USING btree (namespace);
+
+-- 0 is an invalid label ID
+CREATE DOMAIN label_id AS int NOT NULL CHECK (VALUE > 0 AND VALUE <= 65535);
+
+CREATE DOMAIN label_kind AS "char" NOT NULL CHECK (VALUE = 'v' OR VALUE = 'e');
+
+CREATE TABLE ag_label (
+
+ name name NOT NULL,
+ graph oid NOT NULL,
+ id label_id,
+ kind label_kind,
+ relation regclass NOT NULL,
+ CONSTRAINT fk_graph_oid
+ FOREIGN KEY(graph)
+ REFERENCES ag_graph(graphid)
+);
+
+CREATE UNIQUE INDEX ag_label_name_graph_index
+ON ag_label
+USING btree (name, graph);
+
+CREATE UNIQUE INDEX ag_label_graph_oid_index
+ON ag_label
+USING btree (graph, id);
+
+CREATE UNIQUE INDEX ag_label_relation_index ON ag_label USING btree (relation);
+
+--
+-- catalog lookup functions
+--
+
+CREATE FUNCTION ag_catalog._label_id(graph_name name, label_name name)
+RETURNS label_id
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+--
+-- utility functions
+--
+
+CREATE FUNCTION ag_catalog.create_graph(graph_name name)
+RETURNS void
+LANGUAGE c
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.drop_graph(graph_name name, cascade boolean = false)
+RETURNS void
+LANGUAGE c
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.create_vlabel(graph_name name, label_name name)
+ RETURNS void
+ LANGUAGE c
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.create_elabel(graph_name name, label_name name)
+ RETURNS void
+ LANGUAGE c
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.alter_graph(graph_name name, operation cstring, new_value name)
+RETURNS void
+LANGUAGE c
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.drop_label(graph_name name, label_name name,
+ force boolean = false)
+RETURNS void
+LANGUAGE c
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.load_labels_from_file(graph_name name,
+ label_name name,
+ file_path text,
+ id_field_exists bool default true)
+ RETURNS void
+ LANGUAGE c
+ AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.load_edges_from_file(graph_name name,
+ label_name name,
+ file_path text)
+ RETURNS void
+ LANGUAGE c
+ AS 'MODULE_PATHNAME';
+
+--
+-- graphid type
+--
+
+-- define graphid as a shell type first
+CREATE TYPE graphid;
+
+CREATE FUNCTION ag_catalog.graphid_in(cstring)
+RETURNS graphid
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.graphid_out(graphid)
+RETURNS cstring
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- binary I/O functions
+CREATE FUNCTION ag_catalog.graphid_send(graphid)
+RETURNS bytea
+LANGUAGE c
+IMMUTABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.graphid_recv(internal)
+RETURNS graphid
+LANGUAGE c
+IMMUTABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE TYPE graphid (
+ INPUT = ag_catalog.graphid_in,
+ OUTPUT = ag_catalog.graphid_out,
+ SEND = ag_catalog.graphid_send,
+ RECEIVE = ag_catalog.graphid_recv,
+ INTERNALLENGTH = 8,
+ PASSEDBYVALUE,
+ ALIGNMENT = float8,
+ STORAGE = plain
+);
+
+--
+-- graphid - comparison operators (=, <>, <, >, <=, >=)
+--
+
+CREATE FUNCTION ag_catalog.graphid_eq(graphid, graphid)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.graphid_eq,
+ LEFTARG = graphid,
+ RIGHTARG = graphid,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel,
+ HASHES,
+ MERGES
+);
+
+CREATE FUNCTION ag_catalog.graphid_ne(graphid, graphid)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.graphid_ne,
+ LEFTARG = graphid,
+ RIGHTARG = graphid,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.graphid_lt(graphid, graphid)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.graphid_lt,
+ LEFTARG = graphid,
+ RIGHTARG = graphid,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.graphid_gt(graphid, graphid)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.graphid_gt,
+ LEFTARG = graphid,
+ RIGHTARG = graphid,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.graphid_le(graphid, graphid)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.graphid_le,
+ LEFTARG = graphid,
+ RIGHTARG = graphid,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.graphid_ge(graphid, graphid)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.graphid_ge,
+ LEFTARG = graphid,
+ RIGHTARG = graphid,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+--
+-- graphid - B-tree support functions
+--
+
+-- comparison support
+CREATE FUNCTION ag_catalog.graphid_btree_cmp(graphid, graphid)
+RETURNS int
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- sort support
+CREATE FUNCTION ag_catalog.graphid_btree_sort(internal)
+RETURNS void
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+--
+-- define operator classes for graphid
+--
+
+-- B-tree strategies
+-- 1: less than
+-- 2: less than or equal
+-- 3: equal
+-- 4: greater than or equal
+-- 5: greater than
+--
+-- B-tree support functions
+-- 1: compare two keys and return an integer less than zero, zero, or greater
+-- than zero, indicating whether the first key is less than, equal to, or
+-- greater than the second
+-- 2: return the addresses of C-callable sort support function(s) (optional)
+-- 3: compare a test value to a base value plus/minus an offset, and return
+-- true or false according to the comparison result (optional)
+CREATE OPERATOR CLASS graphid_ops DEFAULT FOR TYPE graphid USING btree AS
+ OPERATOR 1 <,
+ OPERATOR 2 <=,
+ OPERATOR 3 =,
+ OPERATOR 4 >=,
+ OPERATOR 5 >,
+ FUNCTION 1 ag_catalog.graphid_btree_cmp (graphid, graphid),
+ FUNCTION 2 ag_catalog.graphid_btree_sort (internal);
+
+--
+-- graphid functions
+--
+
+CREATE FUNCTION ag_catalog._graphid(label_id int, entry_id bigint)
+RETURNS graphid
+LANGUAGE c
+IMMUTABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog._label_name(graph_oid oid, graphid)
+RETURNS cstring
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog._extract_label_id(graphid)
+RETURNS label_id
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+--
+-- agtype type and its support functions
+--
+
+-- define agtype as a shell type first
+CREATE TYPE agtype;
+
+CREATE FUNCTION ag_catalog.agtype_in(cstring)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_out(agtype)
+RETURNS cstring
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- binary I/O functions
+CREATE FUNCTION ag_catalog.agtype_send(agtype)
+RETURNS bytea
+LANGUAGE c
+IMMUTABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_recv(internal)
+RETURNS agtype
+LANGUAGE c
+IMMUTABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE TYPE agtype (
+ INPUT = ag_catalog.agtype_in,
+ OUTPUT = ag_catalog.agtype_out,
+ SEND = ag_catalog.agtype_send,
+ RECEIVE = ag_catalog.agtype_recv,
+ LIKE = jsonb
+);
+
+--
+-- agtype - mathematical operators (+, -, *, /, %, ^)
+--
+
+CREATE FUNCTION ag_catalog.agtype_add(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_add,
+ LEFTARG = agtype,
+ RIGHTARG = agtype,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_add(agtype, smallint)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_any_add,
+ LEFTARG = agtype,
+ RIGHTARG = smallint,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_add(smallint, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_any_add,
+ LEFTARG = smallint,
+ RIGHTARG = agtype,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_add(agtype, integer)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_any_add,
+ LEFTARG = agtype,
+ RIGHTARG = integer,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_add(integer, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_any_add,
+ LEFTARG = integer,
+ RIGHTARG = agtype,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_add(agtype, bigint)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_any_add,
+ LEFTARG = agtype,
+ RIGHTARG = bigint,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_add(bigint, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_any_add,
+ LEFTARG = bigint,
+ RIGHTARG = agtype,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_add(agtype, real)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_any_add,
+ LEFTARG = agtype,
+ RIGHTARG = real,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_add(real, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_any_add,
+ LEFTARG = real,
+ RIGHTARG = agtype,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_add(agtype, double precision)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_any_add,
+ LEFTARG = agtype,
+ RIGHTARG = double precision,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_add(double precision, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_any_add,
+ LEFTARG = double precision,
+ RIGHTARG = agtype,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_add(agtype, numeric)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_any_add,
+ LEFTARG = agtype,
+ RIGHTARG = numeric,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_add(numeric, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR + (
+ FUNCTION = ag_catalog.agtype_any_add,
+ LEFTARG = numeric,
+ RIGHTARG = agtype,
+ COMMUTATOR = +
+);
+
+CREATE FUNCTION ag_catalog.agtype_sub(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_sub,
+ LEFTARG = agtype,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_sub(agtype, smallint)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_any_sub,
+ LEFTARG = agtype,
+ RIGHTARG = smallint
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_sub(smallint, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_any_sub,
+ LEFTARG = smallint,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_sub(agtype, integer)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_any_sub,
+ LEFTARG = agtype,
+ RIGHTARG = integer
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_sub(integer, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_any_sub,
+ LEFTARG = integer,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_sub(agtype, bigint)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_any_sub,
+ LEFTARG = agtype,
+ RIGHTARG = bigint
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_sub(bigint, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_any_sub,
+ LEFTARG = bigint,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_sub(agtype, real)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_any_sub,
+ LEFTARG = agtype,
+ RIGHTARG = real
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_sub(real, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_any_sub,
+ LEFTARG = real,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_sub(agtype, double precision)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_any_sub,
+ LEFTARG = agtype,
+ RIGHTARG = double precision
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_sub(double precision, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_any_sub,
+ LEFTARG = double precision,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_sub(agtype, numeric)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_any_sub,
+ LEFTARG = agtype,
+ RIGHTARG = numeric
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_sub(numeric, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_any_sub,
+ LEFTARG = numeric,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_neg(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR - (
+ FUNCTION = ag_catalog.agtype_neg,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_mul(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_mul,
+ LEFTARG = agtype,
+ RIGHTARG = agtype,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mul(agtype, smallint)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_any_mul,
+ LEFTARG = agtype,
+ RIGHTARG = smallint,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mul(smallint, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_any_mul,
+ LEFTARG = smallint,
+ RIGHTARG = agtype,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mul(agtype, integer)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_any_mul,
+ LEFTARG = agtype,
+ RIGHTARG = integer,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mul(integer, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_any_mul,
+ LEFTARG = integer,
+ RIGHTARG = agtype,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mul(agtype, bigint)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_any_mul,
+ LEFTARG = agtype,
+ RIGHTARG = bigint,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mul(bigint, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_any_mul,
+ LEFTARG = bigint,
+ RIGHTARG = agtype,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mul(agtype, real)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_any_mul,
+ LEFTARG = agtype,
+ RIGHTARG = real,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mul(real, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_any_mul,
+ LEFTARG = real,
+ RIGHTARG = agtype,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mul(agtype, double precision)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_any_mul,
+ LEFTARG = agtype,
+ RIGHTARG = double precision,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mul(double precision, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_any_mul,
+ LEFTARG = double precision,
+ RIGHTARG = agtype,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mul(agtype, numeric)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_any_mul,
+ LEFTARG = agtype,
+ RIGHTARG = numeric,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mul(numeric, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR * (
+ FUNCTION = ag_catalog.agtype_any_mul,
+ LEFTARG = numeric,
+ RIGHTARG = agtype,
+ COMMUTATOR = *
+);
+
+CREATE FUNCTION ag_catalog.agtype_div(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_div,
+ LEFTARG = agtype,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_div(agtype, smallint)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_any_div,
+ LEFTARG = agtype,
+ RIGHTARG = smallint
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_div(smallint, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_any_div,
+ LEFTARG = smallint,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_div(agtype, integer)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_any_div,
+ LEFTARG = agtype,
+ RIGHTARG = integer
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_div(integer, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_any_div,
+ LEFTARG = integer,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_div(agtype, bigint)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_any_div,
+ LEFTARG = agtype,
+ RIGHTARG = bigint
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_div(bigint, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_any_div,
+ LEFTARG = bigint,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_div(agtype, real)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_any_div,
+ LEFTARG = agtype,
+ RIGHTARG = real
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_div(real, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_any_div,
+ LEFTARG = real,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_div(agtype, double precision)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_any_div,
+ LEFTARG = agtype,
+ RIGHTARG = double precision
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_div(double precision, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_any_div,
+ LEFTARG = double precision,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_div(agtype, numeric)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_any_div,
+ LEFTARG = agtype,
+ RIGHTARG = numeric
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_div(numeric, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR / (
+ FUNCTION = ag_catalog.agtype_any_div,
+ LEFTARG = numeric,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_mod(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_mod,
+ LEFTARG = agtype,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mod(agtype, smallint)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_any_mod,
+ LEFTARG = agtype,
+ RIGHTARG = smallint
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mod(smallint, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_any_mod,
+ LEFTARG = smallint,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mod(agtype, integer)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_any_mod,
+ LEFTARG = agtype,
+ RIGHTARG = integer
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mod(integer, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_any_mod,
+ LEFTARG = integer,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mod(agtype, bigint)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_any_mod,
+ LEFTARG = agtype,
+ RIGHTARG = bigint
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mod(bigint, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_any_mod,
+ LEFTARG = bigint,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mod(agtype, real)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_any_mod,
+ LEFTARG = agtype,
+ RIGHTARG = real
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mod(real, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_any_mod,
+ LEFTARG = real,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mod(agtype, double precision)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_any_mod,
+ LEFTARG = agtype,
+ RIGHTARG = double precision
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mod(double precision, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_any_mod,
+ LEFTARG = double precision,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mod(agtype, numeric)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_any_mod,
+ LEFTARG = agtype,
+ RIGHTARG = numeric
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_mod(numeric, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR % (
+ FUNCTION = ag_catalog.agtype_any_mod,
+ LEFTARG = numeric,
+ RIGHTARG = agtype
+);
+
+CREATE FUNCTION ag_catalog.agtype_pow(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR ^ (
+ FUNCTION = ag_catalog.agtype_pow,
+ LEFTARG = agtype,
+ RIGHTARG = agtype
+);
+
+
+CREATE FUNCTION ag_catalog.graphid_hash_cmp(graphid)
+RETURNS INTEGER
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR CLASS graphid_ops_hash
+ DEFAULT
+ FOR TYPE graphid
+ USING hash AS
+ OPERATOR 1 =,
+ FUNCTION 1 ag_catalog.graphid_hash_cmp(graphid);
+
+--
+-- agtype - comparison operators (=, <>, <, >, <=, >=)
+--
+
+CREATE FUNCTION ag_catalog.agtype_eq(agtype, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_eq,
+ LEFTARG = agtype,
+ RIGHTARG = agtype,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel,
+ HASHES
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_eq(agtype, smallint)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_any_eq,
+ LEFTARG = agtype,
+ RIGHTARG = smallint,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_eq(smallint, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_any_eq,
+ LEFTARG = smallint,
+ RIGHTARG = agtype,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_eq(agtype, integer)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_any_eq,
+ LEFTARG = agtype,
+ RIGHTARG = integer,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_eq(integer, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_any_eq,
+ LEFTARG = integer,
+ RIGHTARG = agtype,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_eq(agtype, bigint)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_any_eq,
+ LEFTARG = agtype,
+ RIGHTARG = bigint,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_eq(bigint, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_any_eq,
+ LEFTARG = bigint,
+ RIGHTARG = agtype,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_eq(agtype, real)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_any_eq,
+ LEFTARG = agtype,
+ RIGHTARG = real,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_eq(real, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_any_eq,
+ LEFTARG = real,
+ RIGHTARG = agtype,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_eq(agtype, double precision)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_any_eq,
+ LEFTARG = agtype,
+ RIGHTARG = double precision,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_eq(double precision, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_any_eq,
+ LEFTARG = double precision,
+ RIGHTARG = agtype,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_eq(agtype, numeric)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_any_eq,
+ LEFTARG = agtype,
+ RIGHTARG = numeric,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_eq(numeric, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR = (
+ FUNCTION = ag_catalog.agtype_any_eq,
+ LEFTARG = numeric,
+ RIGHTARG = agtype,
+ COMMUTATOR = =,
+ NEGATOR = <>,
+ RESTRICT = eqsel,
+ JOIN = eqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_ne(agtype, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_ne,
+ LEFTARG = agtype,
+ RIGHTARG = agtype,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ne(agtype, smallint)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_any_ne,
+ LEFTARG = agtype,
+ RIGHTARG = smallint,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ne(smallint, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_any_ne,
+ LEFTARG = smallint,
+ RIGHTARG = agtype,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ne(agtype, integer)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_any_ne,
+ LEFTARG = agtype,
+ RIGHTARG = integer,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ne(integer, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_any_ne,
+ LEFTARG = integer,
+ RIGHTARG = agtype,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ne(agtype, bigint)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_any_ne,
+ LEFTARG = agtype,
+ RIGHTARG = bigint,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ne(bigint, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_any_ne,
+ LEFTARG = bigint,
+ RIGHTARG = agtype,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ne(agtype, real)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_any_ne,
+ LEFTARG = agtype,
+ RIGHTARG = real,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ne(real, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_any_ne,
+ LEFTARG = real,
+ RIGHTARG = agtype,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ne(agtype, double precision)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_any_ne,
+ LEFTARG = agtype,
+ RIGHTARG = double precision,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ne(double precision, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_any_ne,
+ LEFTARG = double precision,
+ RIGHTARG = agtype,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ne(agtype, numeric)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_any_ne,
+ LEFTARG = agtype,
+ RIGHTARG = numeric,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ne(numeric, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <> (
+ FUNCTION = ag_catalog.agtype_any_ne,
+ LEFTARG = numeric,
+ RIGHTARG = agtype,
+ COMMUTATOR = <>,
+ NEGATOR = =,
+ RESTRICT = neqsel,
+ JOIN = neqjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_lt(agtype, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_lt,
+ LEFTARG = agtype,
+ RIGHTARG = agtype,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_lt(agtype, smallint)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_any_lt,
+ LEFTARG = agtype,
+ RIGHTARG = smallint,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_lt(smallint, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_any_lt,
+ LEFTARG = smallint,
+ RIGHTARG = agtype,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_lt(agtype, integer)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_any_lt,
+ LEFTARG = agtype,
+ RIGHTARG = integer,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_lt(integer, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_any_lt,
+ LEFTARG = integer,
+ RIGHTARG = agtype,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_lt(agtype, bigint)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_any_lt,
+ LEFTARG = agtype,
+ RIGHTARG = bigint,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_lt(bigint, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_any_lt,
+ LEFTARG = bigint,
+ RIGHTARG = agtype,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_lt(agtype, real)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_any_lt,
+ LEFTARG = agtype,
+ RIGHTARG = real,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_lt(real, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_any_lt,
+ LEFTARG = real,
+ RIGHTARG = agtype,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_lt(agtype, double precision)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_any_lt,
+ LEFTARG = agtype,
+ RIGHTARG = double precision,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_lt(double precision, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_any_lt,
+ LEFTARG = double precision,
+ RIGHTARG = agtype,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_lt(agtype, numeric)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_any_lt,
+ LEFTARG = agtype,
+ RIGHTARG = numeric,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_lt(numeric, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR < (
+ FUNCTION = ag_catalog.agtype_any_lt,
+ LEFTARG = numeric,
+ RIGHTARG = agtype,
+ COMMUTATOR = >,
+ NEGATOR = >=,
+ RESTRICT = scalarltsel,
+ JOIN = scalarltjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_gt(agtype, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_gt,
+ LEFTARG = agtype,
+ RIGHTARG = agtype,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_gt(agtype, smallint)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_any_gt,
+ LEFTARG = agtype,
+ RIGHTARG = smallint,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_gt(smallint, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_any_gt,
+ LEFTARG = smallint,
+ RIGHTARG = agtype,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_gt(agtype, integer)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_any_gt,
+ LEFTARG = agtype,
+ RIGHTARG = integer,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_gt(integer, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_any_gt,
+ LEFTARG = integer,
+ RIGHTARG = agtype,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_gt(agtype, bigint)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_any_gt,
+ LEFTARG = agtype,
+ RIGHTARG = bigint,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_gt(bigint, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_any_gt,
+ LEFTARG = bigint,
+ RIGHTARG = agtype,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_gt(agtype, real)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_any_gt,
+ LEFTARG = agtype,
+ RIGHTARG = real,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_gt(real, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_any_gt,
+ LEFTARG = real,
+ RIGHTARG = agtype,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_gt(agtype, double precision)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_any_gt,
+ LEFTARG = agtype,
+ RIGHTARG = double precision,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_gt(double precision, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_any_gt,
+ LEFTARG = double precision,
+ RIGHTARG = agtype,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_gt(agtype, numeric)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_any_gt,
+ LEFTARG = agtype,
+ RIGHTARG = numeric,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_gt(numeric, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR > (
+ FUNCTION = ag_catalog.agtype_any_gt,
+ LEFTARG = numeric,
+ RIGHTARG = agtype,
+ COMMUTATOR = <,
+ NEGATOR = <=,
+ RESTRICT = scalargtsel,
+ JOIN = scalargtjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_le(agtype, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_le,
+ LEFTARG = agtype,
+ RIGHTARG = agtype,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_le(agtype, smallint)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_any_le,
+ LEFTARG = agtype,
+ RIGHTARG = smallint,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_le(smallint, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_any_le,
+ LEFTARG = smallint,
+ RIGHTARG = agtype,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_le(agtype, integer)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_any_le,
+ LEFTARG = agtype,
+ RIGHTARG = integer,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_le(integer, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_any_le,
+ LEFTARG = integer,
+ RIGHTARG = agtype,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_le(agtype, bigint)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_any_le,
+ LEFTARG = agtype,
+ RIGHTARG = bigint,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_le(bigint, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_any_le,
+ LEFTARG = bigint,
+ RIGHTARG = agtype,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_le(agtype, real)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_any_le,
+ LEFTARG = agtype,
+ RIGHTARG = real,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_le(real, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_any_le,
+ LEFTARG = real,
+ RIGHTARG = agtype,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_le(agtype, double precision)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_any_le,
+ LEFTARG = agtype,
+ RIGHTARG = double precision,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_le(double precision, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_any_le,
+ LEFTARG = double precision,
+ RIGHTARG = agtype,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_le(agtype, numeric)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_any_le,
+ LEFTARG = agtype,
+ RIGHTARG = numeric,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_le(numeric, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <= (
+ FUNCTION = ag_catalog.agtype_any_le,
+ LEFTARG = numeric,
+ RIGHTARG = agtype,
+ COMMUTATOR = >=,
+ NEGATOR = >,
+ RESTRICT = scalarlesel,
+ JOIN = scalarlejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_ge(agtype, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_ge,
+ LEFTARG = agtype,
+ RIGHTARG = agtype,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ge(agtype, smallint)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_any_ge,
+ LEFTARG = agtype,
+ RIGHTARG = smallint,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ge(smallint, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_any_ge,
+ LEFTARG = smallint,
+ RIGHTARG = agtype,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ge(agtype, integer)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_any_ge,
+ LEFTARG = agtype,
+ RIGHTARG = integer,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ge(integer, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_any_ge,
+ LEFTARG = integer,
+ RIGHTARG = agtype,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ge(agtype, bigint)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_any_ge,
+ LEFTARG = agtype,
+ RIGHTARG = bigint,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ge(bigint, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_any_ge,
+ LEFTARG = bigint,
+ RIGHTARG = agtype,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ge(agtype, real)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_any_ge,
+ LEFTARG = agtype,
+ RIGHTARG = real,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ge(real, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_any_ge,
+ LEFTARG = real,
+ RIGHTARG = agtype,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ge(agtype, double precision)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_any_ge,
+ LEFTARG = agtype,
+ RIGHTARG = double precision,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ge(double precision, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_any_ge,
+ LEFTARG = double precision,
+ RIGHTARG = agtype,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ge(agtype, numeric)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_any_ge,
+ LEFTARG = agtype,
+ RIGHTARG = numeric,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_any_ge(numeric, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR >= (
+ FUNCTION = ag_catalog.agtype_any_ge,
+ LEFTARG = numeric,
+ RIGHTARG = agtype,
+ COMMUTATOR = <=,
+ NEGATOR = <,
+ RESTRICT = scalargesel,
+ JOIN = scalargejoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_btree_cmp(agtype, agtype)
+RETURNS INTEGER
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR CLASS agtype_ops_btree
+ DEFAULT
+ FOR TYPE agtype
+ USING btree AS
+ OPERATOR 1 <,
+ OPERATOR 2 <=,
+ OPERATOR 3 =,
+ OPERATOR 4 >,
+ OPERATOR 5 >=,
+ FUNCTION 1 ag_catalog.agtype_btree_cmp(agtype, agtype);
+
+CREATE FUNCTION ag_catalog.agtype_hash_cmp(agtype)
+RETURNS INTEGER
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR CLASS agtype_ops_hash
+ DEFAULT
+ FOR TYPE agtype
+ USING hash AS
+ OPERATOR 1 =,
+ FUNCTION 1 ag_catalog.agtype_hash_cmp(agtype);
+
+--
+-- agtype - access operators ( ->, ->> )
+--
+
+CREATE FUNCTION ag_catalog.agtype_object_field(agtype, text)
+RETURNS agtype
+LANGUAGE c
+IMMUTABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- get agtype object field
+CREATE OPERATOR -> (
+ LEFTARG = agtype,
+ RIGHTARG = text,
+ FUNCTION = ag_catalog.agtype_object_field
+);
+
+CREATE FUNCTION ag_catalog.agtype_object_field_text(agtype, text)
+RETURNS text
+LANGUAGE c
+IMMUTABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- get agtype object field as text
+CREATE OPERATOR ->> (
+ LEFTARG = agtype,
+ RIGHTARG = text,
+ FUNCTION = ag_catalog.agtype_object_field_text
+);
+
+CREATE FUNCTION ag_catalog.agtype_array_element(agtype, int4)
+RETURNS agtype
+LANGUAGE c
+IMMUTABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- get agtype array element
+CREATE OPERATOR -> (
+ LEFTARG = agtype,
+ RIGHTARG = int4,
+ FUNCTION = ag_catalog.agtype_array_element
+);
+
+CREATE FUNCTION ag_catalog.agtype_array_element_text(agtype, int4)
+RETURNS text
+LANGUAGE c
+IMMUTABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- get agtype array element as text
+CREATE OPERATOR ->> (
+ LEFTARG = agtype,
+ RIGHTARG = int4,
+ FUNCTION = ag_catalog.agtype_array_element_text
+);
+
+--
+-- Contains operators @> <@
+--
+CREATE FUNCTION ag_catalog.agtype_contains(agtype, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR @> (
+ LEFTARG = agtype,
+ RIGHTARG = agtype,
+ FUNCTION = ag_catalog.agtype_contains,
+ COMMUTATOR = '<@',
+ RESTRICT = contsel,
+ JOIN = contjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_contained_by(agtype, agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR <@ (
+ LEFTARG = agtype,
+ RIGHTARG = agtype,
+ FUNCTION = ag_catalog.agtype_contained_by,
+ COMMUTATOR = '@>',
+ RESTRICT = contsel,
+ JOIN = contjoinsel
+);
+
+--
+-- Key Existence Operators ? ?| ?&
+--
+CREATE FUNCTION ag_catalog.agtype_exists(agtype, text)
+RETURNS boolean
+LANGUAGE c
+IMMUTABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR ? (
+ LEFTARG = agtype,
+ RIGHTARG = text,
+ FUNCTION = ag_catalog.agtype_exists,
+ COMMUTATOR = '?',
+ RESTRICT = contsel,
+ JOIN = contjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_exists_any(agtype, text[])
+RETURNS boolean
+LANGUAGE c
+IMMUTABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR ?| (
+ LEFTARG = agtype,
+ RIGHTARG = text[],
+ FUNCTION = ag_catalog.agtype_exists_any,
+ RESTRICT = contsel,
+ JOIN = contjoinsel
+);
+
+CREATE FUNCTION ag_catalog.agtype_exists_all(agtype, text[])
+RETURNS boolean
+LANGUAGE c
+IMMUTABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE OPERATOR ?& (
+ LEFTARG = agtype,
+ RIGHTARG = text[],
+ FUNCTION = ag_catalog.agtype_exists_all,
+ RESTRICT = contsel,
+ JOIN = contjoinsel
+);
+
+--
+-- agtype GIN support
+--
+CREATE FUNCTION ag_catalog.gin_compare_agtype(text, text)
+RETURNS int
+AS 'MODULE_PATHNAME'
+LANGUAGE C
+IMMUTABLE
+STRICT
+PARALLEL SAFE;
+
+CREATE FUNCTION gin_extract_agtype(agtype, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C
+IMMUTABLE
+STRICT
+PARALLEL SAFE;
+
+CREATE FUNCTION ag_catalog.gin_extract_agtype_query(agtype, internal, int2,
+ internal, internal)
+RETURNS internal
+AS 'MODULE_PATHNAME'
+LANGUAGE C
+IMMUTABLE
+STRICT
+PARALLEL SAFE;
+
+CREATE FUNCTION ag_catalog.gin_consistent_agtype(internal, int2, agtype, int4,
+ internal, internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C
+IMMUTABLE
+STRICT
+PARALLEL SAFE;
+
+CREATE FUNCTION ag_catalog.gin_triconsistent_agtype(internal, int2, agtype, int4,
+ internal, internal, internal)
+RETURNS bool
+AS 'MODULE_PATHNAME'
+LANGUAGE C
+IMMUTABLE
+STRICT
+PARALLEL SAFE;
+
+CREATE OPERATOR CLASS ag_catalog.gin_agtype_ops
+DEFAULT FOR TYPE agtype USING gin AS
+ OPERATOR 7 @>,
+ OPERATOR 9 ?(agtype, text),
+ OPERATOR 10 ?|(agtype, text[]),
+ OPERATOR 11 ?&(agtype, text[]),
+ FUNCTION 1 ag_catalog.gin_compare_agtype(text,text),
+ FUNCTION 2 ag_catalog.gin_extract_agtype(agtype, internal),
+ FUNCTION 3 ag_catalog.gin_extract_agtype_query(agtype, internal, int2,
+ internal, internal),
+ FUNCTION 4 ag_catalog.gin_consistent_agtype(internal, int2, agtype, int4,
+ internal, internal),
+ FUNCTION 6 ag_catalog.gin_triconsistent_agtype(internal, int2, agtype, int4,
+ internal, internal, internal),
+STORAGE text;
+
+--
+-- graph id conversion function
+--
+CREATE FUNCTION ag_catalog.graphid_to_agtype(graphid)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE CAST (graphid AS agtype)
+WITH FUNCTION ag_catalog.graphid_to_agtype(graphid);
+
+CREATE FUNCTION ag_catalog.agtype_to_graphid(agtype)
+RETURNS graphid
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE CAST (agtype AS graphid)
+WITH FUNCTION ag_catalog.agtype_to_graphid(agtype)
+AS IMPLICIT;
+
+
+--
+-- agtype - path
+--
+CREATE FUNCTION ag_catalog._agtype_build_path(VARIADIC "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+CALLED ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+--
+-- agtype - vertex
+--
+CREATE FUNCTION ag_catalog._agtype_build_vertex(graphid, cstring, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+CALLED ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+--
+-- agtype - edge
+--
+CREATE FUNCTION ag_catalog._agtype_build_edge(graphid, graphid, graphid, cstring, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+CALLED ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog._ag_enforce_edge_uniqueness(VARIADIC "any")
+RETURNS bool
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+as 'MODULE_PATHNAME';
+
+--
+-- agtype - map literal (`{key: expr, ...}`)
+--
+
+CREATE FUNCTION ag_catalog.agtype_build_map(VARIADIC "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+CALLED ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_build_map()
+RETURNS agtype
+LANGUAGE c
+STABLE
+CALLED ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME', 'agtype_build_map_noargs';
+
+--
+-- There are times when the optimizer might eliminate
+-- functions we need. Wrap the function with this to
+-- prevent that from happening
+--
+CREATE FUNCTION ag_catalog.agtype_volatile_wrapper(agt agtype)
+RETURNS agtype AS $return_value$
+BEGIN
+ RETURN agt;
+END;
+$return_value$ LANGUAGE plpgsql
+VOLATILE
+CALLED ON NULL INPUT
+PARALLEL SAFE;
+
+--
+-- agtype - list literal (`[expr, ...]`)
+--
+
+CREATE FUNCTION ag_catalog.agtype_build_list(VARIADIC "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+CALLED ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_build_list()
+RETURNS agtype
+LANGUAGE c
+STABLE
+CALLED ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME', 'agtype_build_list_noargs';
+
+--
+-- agtype - type coercions
+--
+-- agtype -> text (explicit)
+CREATE FUNCTION ag_catalog.agtype_to_text(agtype)
+RETURNS text
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE CAST (agtype AS text)
+WITH FUNCTION ag_catalog.agtype_to_text(agtype);
+
+-- agtype -> boolean (implicit)
+CREATE FUNCTION ag_catalog.agtype_to_bool(agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE CAST (agtype AS boolean)
+WITH FUNCTION ag_catalog.agtype_to_bool(agtype)
+AS IMPLICIT;
+
+-- boolean -> agtype (explicit)
+CREATE FUNCTION ag_catalog.bool_to_agtype(boolean)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE CAST (boolean AS agtype)
+WITH FUNCTION ag_catalog.bool_to_agtype(boolean);
+
+-- float8 -> agtype (explicit)
+CREATE FUNCTION ag_catalog.float8_to_agtype(float8)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE CAST (float8 AS agtype)
+WITH FUNCTION ag_catalog.float8_to_agtype(float8);
+
+-- agtype -> float8 (implicit)
+CREATE FUNCTION ag_catalog.agtype_to_float8(agtype)
+RETURNS float8
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE CAST (agtype AS float8)
+WITH FUNCTION ag_catalog.agtype_to_float8(agtype);
+
+-- int8 -> agtype (explicit)
+CREATE FUNCTION ag_catalog.int8_to_agtype(int8)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE CAST (int8 AS agtype)
+WITH FUNCTION ag_catalog.int8_to_agtype(int8);
+
+-- agtype -> int8
+CREATE FUNCTION ag_catalog.agtype_to_int8(variadic "any")
+RETURNS bigint
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE CAST (agtype AS bigint)
+WITH FUNCTION ag_catalog.agtype_to_int8(variadic "any")
+AS ASSIGNMENT;
+
+-- agtype -> int4
+CREATE FUNCTION ag_catalog.agtype_to_int4(variadic "any")
+RETURNS int
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE CAST (agtype AS int)
+WITH FUNCTION ag_catalog.agtype_to_int4(variadic "any");
+
+-- agtype -> int2
+CREATE FUNCTION ag_catalog.agtype_to_int2(variadic "any")
+RETURNS smallint
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE CAST (agtype AS smallint)
+WITH FUNCTION ag_catalog.agtype_to_int2(variadic "any");
+
+-- agtype -> int4[]
+CREATE FUNCTION ag_catalog.agtype_to_int4_array(variadic "any")
+ RETURNS int[]
+ LANGUAGE c
+ STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE CAST (agtype AS int[])
+ WITH FUNCTION ag_catalog.agtype_to_int4_array(variadic "any");
+--
+-- agtype - access operators
+--
+
+-- for series of `map.key` and `container[expr]`
+CREATE FUNCTION ag_catalog.agtype_access_operator(VARIADIC agtype[])
+RETURNS agtype
+LANGUAGE c
+IMMUTABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_access_slice(agtype, agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_in_operator(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+--
+-- agtype - string matching (`STARTS WITH`, `ENDS WITH`, `CONTAINS`, & =~)
+--
+
+CREATE FUNCTION ag_catalog.agtype_string_match_starts_with(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_string_match_ends_with(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_string_match_contains(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_eq_tilde(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+--
+-- functions for updating clauses
+--
+
+-- This function is defined as a VOLATILE function to prevent the optimizer
+-- from pulling up Query's for CREATE clauses.
+CREATE FUNCTION ag_catalog._cypher_create_clause(internal)
+RETURNS void
+LANGUAGE c
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog._cypher_set_clause(internal)
+RETURNS void
+LANGUAGE c
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog._cypher_delete_clause(internal)
+RETURNS void
+LANGUAGE c
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog._cypher_merge_clause(internal)
+RETURNS void
+LANGUAGE c
+AS 'MODULE_PATHNAME';
+
+--
+-- query functions
+--
+CREATE FUNCTION ag_catalog.cypher(graph_name name = NULL,
+ query_string cstring = NULL,
+ params agtype = NULL)
+RETURNS SETOF record
+LANGUAGE c
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.get_cypher_keywords(OUT word text, OUT catcode "char",
+ OUT catdesc text)
+RETURNS SETOF record
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+COST 10
+ROWS 60
+AS 'MODULE_PATHNAME';
+
+--
+-- Scalar Functions
+--
+CREATE FUNCTION ag_catalog.age_id(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_start_id(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_end_id(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_head(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_last(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_properties(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_startnode(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_endnode(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_length(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_toboolean(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_tofloat(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_tointeger(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_tostring(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_size(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_type(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_exists(agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_label(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+--
+-- String functions
+--
+CREATE FUNCTION ag_catalog.age_reverse(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_toupper(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_tolower(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_ltrim(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_rtrim(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_trim(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_right(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_left(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_substring(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_split(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_replace(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+--
+-- Trig functions - radian input
+--
+CREATE FUNCTION ag_catalog.age_sin(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_cos(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_tan(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_cot(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_asin(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_acos(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_atan(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_atan2(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_degrees(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_radians(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_round(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_ceil(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_floor(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_abs(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_sign(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_log(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_log10(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_e()
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_exp(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_sqrt(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_timestamp()
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+--
+-- aggregate function components for stdev(internal, agtype)
+-- and stdevp(internal, agtype)
+--
+-- wrapper for the stdev final function to pass 0 instead of null
+CREATE FUNCTION ag_catalog.age_float8_stddev_samp_aggfinalfn(_float8)
+RETURNS agtype
+LANGUAGE c
+IMMUTABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- wrapper for the float8_accum to use agtype input
+CREATE FUNCTION ag_catalog.age_agtype_float8_accum(_float8, agtype)
+RETURNS _float8
+LANGUAGE c
+IMMUTABLE
+STRICT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- aggregate definition for age_stdev(agtype)
+CREATE AGGREGATE ag_catalog.age_stdev(agtype)
+(
+ stype = _float8,
+ sfunc = ag_catalog.age_agtype_float8_accum,
+ finalfunc = ag_catalog.age_float8_stddev_samp_aggfinalfn,
+ combinefunc = float8_combine,
+ finalfunc_modify = read_only,
+ initcond = '{0,0,0}',
+ parallel = safe
+);
+
+-- wrapper for the stdevp final function to pass 0 instead of null
+CREATE FUNCTION ag_catalog.age_float8_stddev_pop_aggfinalfn(_float8)
+RETURNS agtype
+LANGUAGE c
+IMMUTABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- aggregate definition for age_stdevp(agtype)
+CREATE AGGREGATE ag_catalog.age_stdevp(agtype)
+(
+ stype = _float8,
+ sfunc = age_agtype_float8_accum,
+ finalfunc = ag_catalog.age_float8_stddev_pop_aggfinalfn,
+ combinefunc = float8_combine,
+ finalfunc_modify = read_only,
+ initcond = '{0,0,0}',
+ parallel = safe
+);
+
+--
+-- aggregate function components for avg(agtype) and sum(agtype)
+--
+-- aggregate definition for avg(agytpe)
+CREATE AGGREGATE ag_catalog.age_avg(agtype)
+(
+ stype = _float8,
+ sfunc = ag_catalog.age_agtype_float8_accum,
+ finalfunc = float8_avg,
+ combinefunc = float8_combine,
+ finalfunc_modify = read_only,
+ initcond = '{0,0,0}',
+ parallel = safe
+);
+
+-- sum aggtransfn
+CREATE FUNCTION ag_catalog.age_agtype_sum(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+IMMUTABLE
+STRICT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- aggregate definition for sum(agytpe)
+CREATE AGGREGATE ag_catalog.age_sum(agtype)
+(
+ stype = agtype,
+ sfunc = ag_catalog.age_agtype_sum,
+ combinefunc = ag_catalog.age_agtype_sum,
+ finalfunc_modify = read_only,
+ parallel = safe
+);
+
+--
+-- aggregate functions for min(variadic "any") and max(variadic "any")
+--
+-- max transfer function
+CREATE FUNCTION ag_catalog.age_agtype_larger_aggtransfn(agtype, variadic "any")
+RETURNS agtype
+LANGUAGE c
+IMMUTABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- aggregate definition for max(variadic "any")
+CREATE AGGREGATE ag_catalog.age_max(variadic "any")
+(
+ stype = agtype,
+ sfunc = ag_catalog.age_agtype_larger_aggtransfn,
+ combinefunc = ag_catalog.age_agtype_larger_aggtransfn,
+ finalfunc_modify = read_only,
+ parallel = safe
+);
+
+-- min transfer function
+CREATE FUNCTION ag_catalog.age_agtype_smaller_aggtransfn(agtype, variadic "any")
+RETURNS agtype
+LANGUAGE c
+IMMUTABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- aggregate definition for min(variadic "any")
+CREATE AGGREGATE ag_catalog.age_min(variadic "any")
+(
+ stype = agtype,
+ sfunc = ag_catalog.age_agtype_smaller_aggtransfn,
+ combinefunc = ag_catalog.age_agtype_smaller_aggtransfn,
+ finalfunc_modify = read_only,
+ parallel = safe
+);
+
+--
+-- aggregate functions percentileCont(internal, agtype) and
+-- percentileDisc(internal, agtype)
+--
+-- percentile transfer function
+CREATE FUNCTION ag_catalog.age_percentile_aggtransfn(internal, agtype, agtype)
+RETURNS internal
+LANGUAGE c
+IMMUTABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- percentile_cont final function
+CREATE FUNCTION ag_catalog.age_percentile_cont_aggfinalfn(internal)
+RETURNS agtype
+LANGUAGE c
+IMMUTABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- percentile_disc final function
+CREATE FUNCTION ag_catalog.age_percentile_disc_aggfinalfn(internal)
+RETURNS agtype
+LANGUAGE c
+IMMUTABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- aggregate definition for _percentilecont(agtype, agytpe)
+CREATE AGGREGATE ag_catalog.age_percentilecont(agtype, agtype)
+(
+ stype = internal,
+ sfunc = ag_catalog.age_percentile_aggtransfn,
+ finalfunc = ag_catalog.age_percentile_cont_aggfinalfn,
+ parallel = safe
+);
+
+-- aggregate definition for percentiledisc(agtype, agytpe)
+CREATE AGGREGATE ag_catalog.age_percentiledisc(agtype, agtype)
+(
+ stype = internal,
+ sfunc = ag_catalog.age_percentile_aggtransfn,
+ finalfunc = ag_catalog.age_percentile_disc_aggfinalfn,
+ parallel = safe
+);
+
+--
+-- aggregate functions for collect(variadic "any")
+--
+-- collect transfer function
+CREATE FUNCTION ag_catalog.age_collect_aggtransfn(internal, variadic "any")
+RETURNS internal
+LANGUAGE c
+IMMUTABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- collect final function
+CREATE FUNCTION ag_catalog.age_collect_aggfinalfn(internal)
+RETURNS agtype
+LANGUAGE c
+IMMUTABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- aggregate definition for age_collect(variadic "any")
+CREATE AGGREGATE ag_catalog.age_collect(variadic "any")
+(
+ stype = internal,
+ sfunc = ag_catalog.age_collect_aggtransfn,
+ finalfunc = ag_catalog.age_collect_aggfinalfn,
+ parallel = safe
+);
+
+--
+-- function for typecasting an agtype value to another agtype value
+--
+CREATE FUNCTION ag_catalog.agtype_typecast_int(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_typecast_numeric(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_typecast_float(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_typecast_vertex(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_typecast_edge(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.agtype_typecast_path(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- original VLE function definition
+CREATE FUNCTION ag_catalog.age_vle(IN agtype, IN agtype, IN agtype, IN agtype,
+ IN agtype, IN agtype, IN agtype,
+ OUT edges agtype)
+RETURNS SETOF agtype
+LANGUAGE C
+STABLE
+CALLED ON NULL INPUT
+PARALLEL UNSAFE -- might be safe
+AS 'MODULE_PATHNAME';
+
+-- This is an overloaded function definition to allow for the VLE local context
+-- caching mechanism to coexist with the previous VLE version.
+CREATE FUNCTION ag_catalog.age_vle(IN agtype, IN agtype, IN agtype, IN agtype,
+ IN agtype, IN agtype, IN agtype, IN agtype,
+ OUT edges agtype)
+RETURNS SETOF agtype
+LANGUAGE C
+STABLE
+CALLED ON NULL INPUT
+PARALLEL UNSAFE -- might be safe
+AS 'MODULE_PATHNAME';
+
+-- function to build an edge for a VLE match
+CREATE FUNCTION ag_catalog.age_build_vle_match_edge(agtype, agtype)
+RETURNS agtype
+LANGUAGE C
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- function to match a terminal vle edge
+CREATE FUNCTION ag_catalog.age_match_vle_terminal_edge(variadic "any")
+RETURNS boolean
+LANGUAGE C
+STABLE
+CALLED ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+
+-- function to create an AGTV_PATH from a VLE_path_container
+CREATE FUNCTION ag_catalog.age_materialize_vle_path(agtype)
+RETURNS agtype
+LANGUAGE C
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- function to create an AGTV_ARRAY of edges from a VLE_path_container
+CREATE FUNCTION ag_catalog.age_materialize_vle_edges(agtype)
+RETURNS agtype
+LANGUAGE C
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_match_vle_edge_to_id_qual(variadic "any")
+RETURNS boolean
+LANGUAGE C
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+
+CREATE FUNCTION ag_catalog.age_match_two_vle_edges(agtype, agtype)
+RETURNS boolean
+LANGUAGE C
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+-- list functions
+CREATE FUNCTION ag_catalog.age_keys(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_labels(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_nodes(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+RETURNS NULL ON NULL INPUT
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_relationships(agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_range(variadic "any")
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_unnest(agtype, block_types boolean = false)
+ RETURNS SETOF agtype
+ LANGUAGE c
+ STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_vertex_stats(agtype, agtype)
+RETURNS agtype
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_delete_global_graphs(agtype)
+RETURNS boolean
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+CREATE FUNCTION ag_catalog.age_prepare_cypher(cstring, cstring)
+RETURNS boolean
+LANGUAGE c
+STABLE
+PARALLEL SAFE
+AS 'MODULE_PATHNAME';
+
+--
+-- End
+--
diff --git a/windows/Inno Installer/age.control b/windows/Inno Installer/age.control
new file mode 100644
index 0000000..f72364d
--- /dev/null
+++ b/windows/Inno Installer/age.control
@@ -0,0 +1,22 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+default_version = '1.1.1'
+comment = 'AGE database extension'
+module_pathname = '$libdir/age'
+
+schema = 'ag_catalog'
diff --git a/windows/Inno Installer/age.dll b/windows/Inno Installer/age.dll
new file mode 100644
index 0000000..4770388
--- /dev/null
+++ b/windows/Inno Installer/age.dll
Binary files differ
diff --git a/windows/Inno Installer/apache-age-1.1.1.1.iss b/windows/Inno Installer/apache-age-1.1.1.1.iss
new file mode 100644
index 0000000..f4eae83
--- /dev/null
+++ b/windows/Inno Installer/apache-age-1.1.1.1.iss
@@ -0,0 +1,28 @@
+[Setup]
+AppName=Apache Age
+AppVersion=1.1.1
+AppPublisher=Apache
+DefaultDirName=C:/PROGRA~1/POSTGR~1/12/lib
+DefaultGroupName=PostgreSQL Extensions
+OutputDir=.
+OutputBaseFilename=apache-age-1.1.1
+Compression=lzma2/ultra64
+SolidCompression=yes
+LicenseFile="license.txt"
+WizardSmallImageFile=logo.bmp
+SetupIconFile=appicon.ico
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+
+[Files]
+
+Source: "age.dll"; DestDir: "C:/PROGRA~1/POSTGR~1/12/lib"
+Source: "age--1.1.1.sql"; DestDir: "C:/PROGRA~1/POSTGR~1/12/share/extension"
+Source: "age.control"; DestDir: "C:/PROGRA~1/POSTGR~1/12/share/extension"
+Source: "logo.bmp"; DestDir: "{app}"; Flags: dontcopy
+Source: "appicon.ico"; DestDir: "{app}"; Flags: dontcopy
+Source: "license.txt"; DestDir: "{app}"; Flags: isreadme
+
+[Icons]
+Name: "{group}\Uninstall AGE"; Filename: "{uninstallexe}"
diff --git a/windows/Inno Installer/appicon.ico b/windows/Inno Installer/appicon.ico
new file mode 100644
index 0000000..7a0d6ee
--- /dev/null
+++ b/windows/Inno Installer/appicon.ico
Binary files differ
diff --git a/windows/Inno Installer/license.txt b/windows/Inno Installer/license.txt
new file mode 100644
index 0000000..a9c9ef5
--- /dev/null
+++ b/windows/Inno Installer/license.txt
@@ -0,0 +1,230 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+
+
+
+
+For PostgreSQL Database Management System:
+
+(formerly known as Postgres, then as Postgres95)
+
+Portions Copyright (c) 1996-2010, The 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/windows/Inno Installer/logo.bmp b/windows/Inno Installer/logo.bmp
new file mode 100644
index 0000000..94b52d0
--- /dev/null
+++ b/windows/Inno Installer/logo.bmp
Binary files differ
