This is an automated email from the ASF dual-hosted git repository. shoaib88 pushed a commit to branch master in repository https://gitbox.apache.org/repos/asf/age.git
commit edfa9cb57d6e942f6bec4aaae68f91a5ad2a2c7b Author: Shoaib <[email protected]> AuthorDate: Fri Oct 20 14:38:34 2023 +0200 Converted SQL mail into multiple files. --- .gitignore | 1 + Makefile | 12 +- age--1.4.0.sql => backup/age--1.4.0.sql.old | 0 sql/01_age_main.sql | 377 +++++++ sql/02_age_agtype.sql | 1062 +++++++++++++++++++ sql/11_agtype_comparison.sql | 1460 +++++++++++++++++++++++++++ sql/12_agtype_access.sql | 170 ++++ sql/13_agtype_operators.sql | 55 + sql/14_agtype_exists.sql | 119 +++ sql/15_agtype_gin.sql | 80 ++ sql/16_agtype_graphid.sql | 148 +++ sql/17_agtype_coercions.sql | 143 +++ sql/18_agtype_string.sql | 53 + sql/20_age_query.sql | 68 ++ sql/41_age_scalar.sql | 205 ++++ sql/42_age_string.sql | 104 ++ sql/43_age_trig.sql | 181 ++++ sql/44_age_aggregate.sql | 218 ++++ sql/45_agtype_typecast.sql | 236 +++++ 19 files changed, 4689 insertions(+), 3 deletions(-) diff --git a/.gitignore b/.gitignore index ac4fd622..7a75f8cb 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,7 @@ *.o *.so build.sh +age--*.*.*.sql .idea .deps .DS_Store diff --git a/Makefile b/Makefile index 69a1e56c..67810311 100644 --- a/Makefile +++ b/Makefile @@ -17,7 +17,7 @@ MODULE_big = age - +age_sql = age--1.4.0.sql OBJS = src/backend/age.o \ src/backend/catalog/ag_catalog.o \ @@ -75,7 +75,13 @@ OBJS = src/backend/age.o \ EXTENSION = age -DATA = age--1.4.0.sql +SQLS = $(wildcard sql/*.sql) + +$(age_sql): + @cat $(SQLS) > $@ + + +DATA = $(age_sql) # sorted in dependency order REGRESS = scan \ @@ -110,7 +116,7 @@ ag_regress_dir = $(srcdir)/regress REGRESS_OPTS = --load-extension=age --inputdir=$(ag_regress_dir) --outputdir=$(ag_regress_dir) --temp-instance=$(ag_regress_dir)/instance --port=61958 --encoding=UTF-8 --temp-config $(ag_regress_dir)/age_regression.conf ag_regress_out = instance/ log/ results/ regression.* -EXTRA_CLEAN = $(addprefix $(ag_regress_dir)/, $(ag_regress_out)) src/backend/parser/cypher_gram.c src/include/parser/cypher_gram_def.h src/include/parser/cypher_kwlist_d.h +EXTRA_CLEAN = $(addprefix $(ag_regress_dir)/, $(ag_regress_out)) src/backend/parser/cypher_gram.c src/include/parser/cypher_gram_def.h src/include/parser/cypher_kwlist_d.h $(age_sql) GEN_KEYWORDLIST = $(PERL) -I ./tools/ ./tools/gen_keywordlist.pl GEN_KEYWORDLIST_DEPS = ./tools/gen_keywordlist.pl tools/PerfectHash.pm diff --git a/age--1.4.0.sql b/backup/age--1.4.0.sql.old similarity index 100% rename from age--1.4.0.sql rename to backup/age--1.4.0.sql.old diff --git a/sql/01_age_main.sql b/sql/01_age_main.sql new file mode 100644 index 00000000..ed50915f --- /dev/null +++ b/sql/01_age_main.sql @@ -0,0 +1,377 @@ +/* + * 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); + +-- include content of the ag_graph table into the pg_dump output +SELECT pg_catalog.pg_extension_config_dump('ag_graph', ''); + +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, + seq_name name NOT NULL, + CONSTRAINT fk_graph_oid + FOREIGN KEY(graph) + REFERENCES ag_graph(graphid) +); + +-- include content of the ag_label table into the pg_dump output +SELECT pg_catalog.pg_extension_config_dump('ag_label', ''); + +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); + +CREATE UNIQUE INDEX ag_label_seq_name_graph_index + ON ag_label + USING btree (seq_name, graph); + +-- +-- 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 + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.graphid_out(graphid) + RETURNS cstring + LANGUAGE c + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +-- sort support +CREATE FUNCTION ag_catalog.graphid_btree_sort(internal) + RETURNS void + LANGUAGE c + IMMUTABLE +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 + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog._extract_label_id(graphid) + RETURNS label_id + LANGUAGE c + STABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; diff --git a/sql/02_age_agtype.sql b/sql/02_age_agtype.sql new file mode 100644 index 00000000..499464d7 --- /dev/null +++ b/sql/02_age_agtype.sql @@ -0,0 +1,1062 @@ +/* + * 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. + */ + + -- +-- 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 + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.agtype_out(agtype) + RETURNS cstring + LANGUAGE c + IMMUTABLE +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.agtype_concat(agtype, agtype) + RETURNS agtype + LANGUAGE c + STABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE OPERATOR || ( + FUNCTION = ag_catalog.agtype_concat, + 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); + diff --git a/sql/11_agtype_comparison.sql b/sql/11_agtype_comparison.sql new file mode 100644 index 00000000..711226c8 --- /dev/null +++ b/sql/11_agtype_comparison.sql @@ -0,0 +1,1460 @@ +/* + * 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. + */ + + -- +-- agtype - comparison operators (=, <>, <, >, <=, >=) +-- + +CREATE FUNCTION ag_catalog.agtype_eq(agtype, agtype) + RETURNS boolean + LANGUAGE c + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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); + diff --git a/sql/12_agtype_access.sql b/sql/12_agtype_access.sql new file mode 100644 index 00000000..509cf5a7 --- /dev/null +++ b/sql/12_agtype_access.sql @@ -0,0 +1,170 @@ +/* + * 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. + */ + +-- +-- 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_object_field_agtype(agtype, agtype) + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +-- get agtype object field or array element +CREATE OPERATOR -> ( + LEFTARG = agtype, + RIGHTARG = agtype, + FUNCTION = ag_catalog.agtype_object_field_agtype +); + +CREATE FUNCTION ag_catalog.agtype_object_field_text_agtype(agtype, agtype) + RETURNS text + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +-- get agtype object field or array element as text +CREATE OPERATOR ->> ( + LEFTARG = agtype, + RIGHTARG = agtype, + FUNCTION = ag_catalog.agtype_object_field_text_agtype +); + +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 +); + +CREATE FUNCTION ag_catalog.agtype_extract_path(agtype, agtype) + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +-- return the extracted path as agtype +CREATE OPERATOR #> ( + LEFTARG = agtype, + RIGHTARG = agtype, + FUNCTION = ag_catalog.agtype_extract_path +); + +CREATE FUNCTION ag_catalog.agtype_extract_path_text(agtype, agtype) + RETURNS text + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +-- return the extracted path as text +CREATE OPERATOR #>> ( + LEFTARG = agtype, + RIGHTARG = agtype, + FUNCTION = ag_catalog.agtype_extract_path_text +); + +-- +-- 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 + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.agtype_in_operator(agtype, agtype) + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + diff --git a/sql/13_agtype_operators.sql b/sql/13_agtype_operators.sql new file mode 100644 index 00000000..7b08b7df --- /dev/null +++ b/sql/13_agtype_operators.sql @@ -0,0 +1,55 @@ +/* + * 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. + */ + + -- +-- Contains operators @> <@ +-- +CREATE FUNCTION ag_catalog.agtype_contains(agtype, agtype) + RETURNS boolean + LANGUAGE c + IMMUTABLE +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 + IMMUTABLE +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 +); diff --git a/sql/14_agtype_exists.sql b/sql/14_agtype_exists.sql new file mode 100644 index 00000000..fe6150d6 --- /dev/null +++ b/sql/14_agtype_exists.sql @@ -0,0 +1,119 @@ +/* + * 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. + */ + +-- +-- 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_agtype(agtype, agtype) + RETURNS boolean + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE OPERATOR ? ( + LEFTARG = agtype, + RIGHTARG = agtype, + FUNCTION = ag_catalog.agtype_exists_agtype, + 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_any_agtype(agtype, agtype) + RETURNS boolean + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE OPERATOR ?| ( + LEFTARG = agtype, + RIGHTARG = agtype, + FUNCTION = ag_catalog.agtype_exists_any_agtype, + 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 +); + +CREATE FUNCTION ag_catalog.agtype_exists_all_agtype(agtype, agtype) + RETURNS boolean + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE OPERATOR ?& ( + LEFTARG = agtype, + RIGHTARG = agtype, + FUNCTION = ag_catalog.agtype_exists_all_agtype, + RESTRICT = contsel, + JOIN = contjoinsel +); diff --git a/sql/15_agtype_gin.sql b/sql/15_agtype_gin.sql new file mode 100644 index 00000000..44dd53bb --- /dev/null +++ b/sql/15_agtype_gin.sql @@ -0,0 +1,80 @@ +/* + * 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. + */ + +-- +-- 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, agtype), + OPERATOR 10 ?|(agtype, agtype), + OPERATOR 11 ?&(agtype, agtype), + 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; diff --git a/sql/16_agtype_graphid.sql b/sql/16_agtype_graphid.sql new file mode 100644 index 00000000..4e05943a --- /dev/null +++ b/sql/16_agtype_graphid.sql @@ -0,0 +1,148 @@ +/* + * 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. + */ + +-- +-- graph id conversion function +-- +CREATE FUNCTION ag_catalog.graphid_to_agtype(graphid) + RETURNS agtype + LANGUAGE c + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +CALLED ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.agtype_build_map() + RETURNS agtype + LANGUAGE c + IMMUTABLE +CALLED ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME', 'agtype_build_map_noargs'; + +CREATE FUNCTION ag_catalog.agtype_build_map_nonull(VARIADIC "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +CALLED ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +-- +-- 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("any") + RETURNS agtype + LANGUAGE c + VOLATILE +CALLED ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +-- +-- agtype - list literal (`[expr, ...]`) +-- + +CREATE FUNCTION ag_catalog.agtype_build_list(VARIADIC "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +CALLED ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.agtype_build_list() + RETURNS agtype + LANGUAGE c + IMMUTABLE +CALLED ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME', 'agtype_build_list_noargs'; + diff --git a/sql/17_agtype_coercions.sql b/sql/17_agtype_coercions.sql new file mode 100644 index 00000000..031a808e --- /dev/null +++ b/sql/17_agtype_coercions.sql @@ -0,0 +1,143 @@ +/* + * 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. + */ + + -- +-- agtype - type coercions +-- +-- agtype -> text (explicit) +CREATE FUNCTION ag_catalog.agtype_to_text(agtype) + RETURNS text + LANGUAGE c + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +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"); diff --git a/sql/18_agtype_string.sql b/sql/18_agtype_string.sql new file mode 100644 index 00000000..8e2b6360 --- /dev/null +++ b/sql/18_agtype_string.sql @@ -0,0 +1,53 @@ +/* + * 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. + */ + + -- +-- 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 + IMMUTABLE +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'; diff --git a/sql/20_age_query.sql b/sql/20_age_query.sql new file mode 100644 index 00000000..9de79c23 --- /dev/null +++ b/sql/20_age_query.sql @@ -0,0 +1,68 @@ +/* + * 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. + */ + +-- +-- 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'; +-- +-- End +-- diff --git a/sql/41_age_scalar.sql b/sql/41_age_scalar.sql new file mode 100644 index 00000000..77f7689a --- /dev/null +++ b/sql/41_age_scalar.sql @@ -0,0 +1,205 @@ +/* + * 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. + */ + +-- +-- Scalar Functions +-- + +CREATE FUNCTION ag_catalog.age_id(agtype) + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_start_id(agtype) + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_end_id(agtype) + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_head(agtype) + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_last(agtype) + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_tail(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_properties(agtype) + RETURNS agtype + LANGUAGE c + IMMUTABLE +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 + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_toboolean(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_tobooleanlist(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_tofloat(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_tofloatlist(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_tointeger(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_tointegerlist(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_tostring(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_tostringlist(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_size(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +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_isempty(agtype) + RETURNS boolean + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +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'; diff --git a/sql/42_age_string.sql b/sql/42_age_string.sql new file mode 100644 index 00000000..deafd94c --- /dev/null +++ b/sql/42_age_string.sql @@ -0,0 +1,104 @@ +/* + * 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. + */ + +-- +-- String functions +-- +CREATE FUNCTION ag_catalog.age_reverse(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_toupper(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_tolower(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_ltrim(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_rtrim(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_trim(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +RETURNS NULL ON NULL INPUT +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_right(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_left(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_substring(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_split(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_replace(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; diff --git a/sql/43_age_trig.sql b/sql/43_age_trig.sql new file mode 100644 index 00000000..7c8d177c --- /dev/null +++ b/sql/43_age_trig.sql @@ -0,0 +1,181 @@ +/* + * 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. + */ + +-- +-- Trig functions - radian input +-- +CREATE FUNCTION ag_catalog.age_sin(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_cos(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_tan(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_cot(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_asin(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_acos(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_atan(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_atan2(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_degrees(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_radians(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_round(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_ceil(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_floor(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_abs(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_sign(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_log(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_log10(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_e() + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_pi() + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_rand() + RETURNS agtype + LANGUAGE c + PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_exp(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_sqrt(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_timestamp() + RETURNS agtype + LANGUAGE c + STABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; diff --git a/sql/44_age_aggregate.sql b/sql/44_age_aggregate.sql new file mode 100644 index 00000000..a8ea425c --- /dev/null +++ b/sql/44_age_aggregate.sql @@ -0,0 +1,218 @@ +/* + * 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. + */ + +-- +-- 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 +); diff --git a/sql/45_agtype_typecast.sql b/sql/45_agtype_typecast.sql new file mode 100644 index 00000000..08e27fb3 --- /dev/null +++ b/sql/45_agtype_typecast.sql @@ -0,0 +1,236 @@ +/* + * 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. + */ + +-- +-- function for typecasting an agtype value to another agtype value +-- +CREATE FUNCTION ag_catalog.agtype_typecast_int(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.agtype_typecast_numeric(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.agtype_typecast_float(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.agtype_typecast_bool(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.agtype_typecast_vertex(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.agtype_typecast_edge(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.agtype_typecast_path(variadic "any") + RETURNS agtype + LANGUAGE c + IMMUTABLE +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 + IMMUTABLE +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 + IMMUTABLE +PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_unnest(agtype) + RETURNS SETOF agtype +LANGUAGE c +IMMUTABLE +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.create_complete_graph(graph_name name, nodes int, + edge_label name, + node_label name = NULL) + RETURNS void + LANGUAGE c + CALLED ON NULL INPUT + PARALLEL SAFE +AS 'MODULE_PATHNAME'; + +CREATE FUNCTION ag_catalog.age_create_barbell_graph(graph_name name, + graph_size int, + bridge_size int, + node_label name = NULL, + node_properties agtype = NULL, + edge_label name = NULL, + edge_properties agtype = NULL) + RETURNS void + LANGUAGE c + CALLED ON NULL INPUT + 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 +--
