admin/raven
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Browse Source
This commit is contained in:
John Cardinal
2021-12-02 17:19:29 +00:00
parent e79637203a
commit e6ec151bc2
1460 changed files with 0 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
dist/win-x64/postgres-standalone/share/extension/adminpack--1.0--1.1.sql vendored Normal file
View File

@@ -0,0 +1,6 @@
/* contrib/adminpack/adminpack--1.0--1.1.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION adminpack UPDATE TO '1.1'" to load this file. \quit
REVOKE EXECUTE ON FUNCTION pg_catalog.pg_logfile_rotate() FROM PUBLIC;

53
dist/win-x64/postgres-standalone/share/extension/adminpack--1.0.sql vendored Normal file
View File

@@ -0,0 +1,53 @@
/* contrib/adminpack/adminpack--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION adminpack" to load this file. \quit
/* ***********************************************
* Administrative functions for PostgreSQL
* *********************************************** */
/* generic file access functions */
CREATE FUNCTION pg_catalog.pg_file_write(text, text, bool)
RETURNS bigint
AS 'MODULE_PATHNAME', 'pg_file_write'
LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pg_catalog.pg_file_rename(text, text, text)
RETURNS bool
AS 'MODULE_PATHNAME', 'pg_file_rename'
LANGUAGE C VOLATILE;
CREATE FUNCTION pg_catalog.pg_file_rename(text, text)
RETURNS bool
AS 'SELECT pg_catalog.pg_file_rename($1, $2, NULL::pg_catalog.text);'
LANGUAGE SQL VOLATILE STRICT;
CREATE FUNCTION pg_catalog.pg_file_unlink(text)
RETURNS bool
AS 'MODULE_PATHNAME', 'pg_file_unlink'
LANGUAGE C VOLATILE STRICT;
CREATE FUNCTION pg_catalog.pg_logdir_ls()
RETURNS setof record
AS 'MODULE_PATHNAME', 'pg_logdir_ls'
LANGUAGE C VOLATILE STRICT;
/* Renaming of existing backend functions for pgAdmin compatibility */
CREATE FUNCTION pg_catalog.pg_file_read(text, bigint, bigint)
RETURNS text
AS 'pg_read_file'
LANGUAGE INTERNAL VOLATILE STRICT;
CREATE FUNCTION pg_catalog.pg_file_length(text)
RETURNS bigint
AS 'SELECT size FROM pg_catalog.pg_stat_file($1)'
LANGUAGE SQL VOLATILE STRICT;
CREATE FUNCTION pg_catalog.pg_logfile_rotate()
RETURNS int4
AS 'pg_rotate_logfile'
LANGUAGE INTERNAL VOLATILE STRICT;

51
dist/win-x64/postgres-standalone/share/extension/adminpack--1.1--2.0.sql vendored Normal file
View File

@@ -0,0 +1,51 @@
/* contrib/adminpack/adminpack--1.1--2.0.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION adminpack UPDATE TO '2.0'" to load this file. \quit
/* ***********************************************
* Administrative functions for PostgreSQL
* *********************************************** */
/* generic file access functions */
CREATE OR REPLACE FUNCTION pg_catalog.pg_file_write(text, text, bool)
RETURNS bigint
AS 'MODULE_PATHNAME', 'pg_file_write_v1_1'
LANGUAGE C VOLATILE STRICT;
REVOKE EXECUTE ON FUNCTION pg_catalog.pg_file_write(text, text, bool) FROM PUBLIC;
CREATE OR REPLACE FUNCTION pg_catalog.pg_file_rename(text, text, text)
RETURNS bool
AS 'MODULE_PATHNAME', 'pg_file_rename_v1_1'
LANGUAGE C VOLATILE;
REVOKE EXECUTE ON FUNCTION pg_catalog.pg_file_rename(text, text, text) FROM PUBLIC;
CREATE OR REPLACE FUNCTION pg_catalog.pg_file_rename(text, text)
RETURNS bool
AS 'SELECT pg_catalog.pg_file_rename($1, $2, NULL::pg_catalog.text);'
LANGUAGE SQL VOLATILE STRICT;
CREATE OR REPLACE FUNCTION pg_catalog.pg_file_unlink(text)
RETURNS bool
AS 'MODULE_PATHNAME', 'pg_file_unlink_v1_1'
LANGUAGE C VOLATILE STRICT;
REVOKE EXECUTE ON FUNCTION pg_catalog.pg_file_unlink(text) FROM PUBLIC;
CREATE OR REPLACE FUNCTION pg_catalog.pg_logdir_ls()
RETURNS setof record
AS 'MODULE_PATHNAME', 'pg_logdir_ls_v1_1'
LANGUAGE C VOLATILE STRICT;
REVOKE EXECUTE ON FUNCTION pg_catalog.pg_logdir_ls() FROM PUBLIC;
/* These functions are now in the backend and callers should update to use those */
DROP FUNCTION pg_file_read(text, bigint, bigint);
DROP FUNCTION pg_file_length(text);
DROP FUNCTION pg_logfile_rotate();

17
dist/win-x64/postgres-standalone/share/extension/adminpack--2.0--2.1.sql vendored Normal file
View File

@@ -0,0 +1,17 @@
/* contrib/adminpack/adminpack--2.0--2.1.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION adminpack UPDATE TO '2.1'" to load this file. \quit
/* ***********************************************
* Administrative functions for PostgreSQL
* *********************************************** */
/* generic file access functions */
CREATE OR REPLACE FUNCTION pg_catalog.pg_file_sync(text)
RETURNS void
AS 'MODULE_PATHNAME', 'pg_file_sync'
LANGUAGE C VOLATILE STRICT;
REVOKE EXECUTE ON FUNCTION pg_catalog.pg_file_sync(text) FROM PUBLIC;

6
dist/win-x64/postgres-standalone/share/extension/adminpack.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# adminpack extension
comment = 'administrative functions for PostgreSQL'
default_version = '2.1'
module_pathname = '$libdir/adminpack'
relocatable = false
schema = pg_catalog

29
dist/win-x64/postgres-standalone/share/extension/amcheck--1.0--1.1.sql vendored Normal file
View File

@@ -0,0 +1,29 @@
/* contrib/amcheck/amcheck--1.0--1.1.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "ALTER EXTENSION amcheck UPDATE TO '1.1'" to load this file. \quit
-- In order to avoid issues with dependencies when updating amcheck to 1.1,
-- create new, overloaded versions of the 1.0 functions
--
-- bt_index_check()
--
CREATE FUNCTION bt_index_check(index regclass,
heapallindexed boolean)
RETURNS VOID
AS 'MODULE_PATHNAME', 'bt_index_check'
LANGUAGE C STRICT PARALLEL RESTRICTED;
--
-- bt_index_parent_check()
--
CREATE FUNCTION bt_index_parent_check(index regclass,
heapallindexed boolean)
RETURNS VOID
AS 'MODULE_PATHNAME', 'bt_index_parent_check'
LANGUAGE C STRICT PARALLEL RESTRICTED;
-- Don't want these to be available to public
REVOKE ALL ON FUNCTION bt_index_check(regclass, boolean) FROM PUBLIC;
REVOKE ALL ON FUNCTION bt_index_parent_check(regclass, boolean) FROM PUBLIC;

24
dist/win-x64/postgres-standalone/share/extension/amcheck--1.0.sql vendored Normal file
View File

@@ -0,0 +1,24 @@
/* contrib/amcheck/amcheck--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION amcheck" to load this file. \quit
--
-- bt_index_check()
--
CREATE FUNCTION bt_index_check(index regclass)
RETURNS VOID
AS 'MODULE_PATHNAME', 'bt_index_check'
LANGUAGE C STRICT PARALLEL RESTRICTED;
--
-- bt_index_parent_check()
--
CREATE FUNCTION bt_index_parent_check(index regclass)
RETURNS VOID
AS 'MODULE_PATHNAME', 'bt_index_parent_check'
LANGUAGE C STRICT PARALLEL RESTRICTED;
-- Don't want these to be available to public
REVOKE ALL ON FUNCTION bt_index_check(regclass) FROM PUBLIC;
REVOKE ALL ON FUNCTION bt_index_parent_check(regclass) FROM PUBLIC;

19
dist/win-x64/postgres-standalone/share/extension/amcheck--1.1--1.2.sql vendored Normal file
View File

@@ -0,0 +1,19 @@
/* contrib/amcheck/amcheck--1.1--1.2.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "ALTER EXTENSION amcheck UPDATE TO '1.2'" to load this file. \quit
-- In order to avoid issues with dependencies when updating amcheck to 1.2,
-- create new, overloaded version of the 1.1 function signature
--
-- bt_index_parent_check()
--
CREATE FUNCTION bt_index_parent_check(index regclass,
heapallindexed boolean, rootdescend boolean)
RETURNS VOID
AS 'MODULE_PATHNAME', 'bt_index_parent_check'
LANGUAGE C STRICT PARALLEL RESTRICTED;
-- Don't want this to be available to public
REVOKE ALL ON FUNCTION bt_index_parent_check(regclass, boolean, boolean) FROM PUBLIC;

30
dist/win-x64/postgres-standalone/share/extension/amcheck--1.2--1.3.sql vendored Normal file
View File

@@ -0,0 +1,30 @@
/* contrib/amcheck/amcheck--1.2--1.3.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "ALTER EXTENSION amcheck UPDATE TO '1.3'" to load this file. \quit
--
-- verify_heapam()
--
CREATE FUNCTION verify_heapam(relation regclass,
on_error_stop boolean default false,
check_toast boolean default false,
skip text default 'none',
startblock bigint default null,
endblock bigint default null,
blkno OUT bigint,
offnum OUT integer,
attnum OUT integer,
msg OUT text)
RETURNS SETOF record
AS 'MODULE_PATHNAME', 'verify_heapam'
LANGUAGE C;
-- Don't want this to be available to public
REVOKE ALL ON FUNCTION verify_heapam(regclass,
boolean,
boolean,
text,
bigint,
bigint)
FROM PUBLIC;

5
dist/win-x64/postgres-standalone/share/extension/amcheck.control vendored Normal file
View File

@@ -0,0 +1,5 @@
# amcheck extension
comment = 'functions for verifying relation integrity'
default_version = '1.3'
module_pathname = '$libdir/amcheck'
relocatable = true

9
dist/win-x64/postgres-standalone/share/extension/autoinc--1.0.sql vendored Normal file
View File

@@ -0,0 +1,9 @@
/* contrib/spi/autoinc--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION autoinc" to load this file. \quit
CREATE FUNCTION autoinc()
RETURNS trigger
AS 'MODULE_PATHNAME'
LANGUAGE C;

5
dist/win-x64/postgres-standalone/share/extension/autoinc.control vendored Normal file
View File

@@ -0,0 +1,5 @@
# autoinc extension
comment = 'functions for autoincrementing fields'
default_version = '1.0'
module_pathname = '$libdir/autoinc'
relocatable = true

25
dist/win-x64/postgres-standalone/share/extension/bloom--1.0.sql vendored Normal file
View File

@@ -0,0 +1,25 @@
/* contrib/bloom/bloom--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION bloom" to load this file. \quit
CREATE FUNCTION blhandler(internal)
RETURNS index_am_handler
AS 'MODULE_PATHNAME'
LANGUAGE C;
-- Access method
CREATE ACCESS METHOD bloom TYPE INDEX HANDLER blhandler;
COMMENT ON ACCESS METHOD bloom IS 'bloom index access method';
-- Opclasses
CREATE OPERATOR CLASS int4_ops
DEFAULT FOR TYPE int4 USING bloom AS
OPERATOR 1 =(int4, int4),
FUNCTION 1 hashint4(int4);
CREATE OPERATOR CLASS text_ops
DEFAULT FOR TYPE text USING bloom AS
OPERATOR 1 =(text, text),
FUNCTION 1 hashtext(text);

5
dist/win-x64/postgres-standalone/share/extension/bloom.control vendored Normal file
View File

@@ -0,0 +1,5 @@
# bloom extension
comment = 'bloom access method - signature file based index'
default_version = '1.0'
module_pathname = '$libdir/bloom'
relocatable = true

19
dist/win-x64/postgres-standalone/share/extension/bool_plperl--1.0.sql vendored Normal file
View File

@@ -0,0 +1,19 @@
/* contrib/bool_plperl/bool_plperl--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION bool_plperl" to load this file. \quit
CREATE FUNCTION bool_to_plperl(val internal) RETURNS internal
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME';
CREATE FUNCTION plperl_to_bool(val internal) RETURNS bool
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME';
CREATE TRANSFORM FOR bool LANGUAGE plperl (
FROM SQL WITH FUNCTION bool_to_plperl(internal),
TO SQL WITH FUNCTION plperl_to_bool(internal)
);
COMMENT ON TRANSFORM FOR bool LANGUAGE plperl IS 'transform between bool and Perl';

7
dist/win-x64/postgres-standalone/share/extension/bool_plperl.control vendored Normal file
View File

@@ -0,0 +1,7 @@
# bool_plperl extension
comment = 'transform between bool and plperl'
default_version = '1.0'
module_pathname = '$libdir/bool_plperl'
relocatable = true
trusted = true
requires = 'plperl'

19
dist/win-x64/postgres-standalone/share/extension/bool_plperlu--1.0.sql vendored Normal file
View File

@@ -0,0 +1,19 @@
/* contrib/bool_plperl/bool_plperlu--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION bool_plperlu" to load this file. \quit
CREATE FUNCTION bool_to_plperlu(val internal) RETURNS internal
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME', 'bool_to_plperl';
CREATE FUNCTION plperlu_to_bool(val internal) RETURNS bool
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME', 'plperl_to_bool';
CREATE TRANSFORM FOR bool LANGUAGE plperlu (
FROM SQL WITH FUNCTION bool_to_plperlu(internal),
TO SQL WITH FUNCTION plperlu_to_bool(internal)
);
COMMENT ON TRANSFORM FOR bool LANGUAGE plperlu IS 'transform between bool and Perl';

6
dist/win-x64/postgres-standalone/share/extension/bool_plperlu.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# bool_plperlu extension
comment = 'transform between bool and plperlu'
default_version = '1.0'
module_pathname = '$libdir/bool_plperl'
relocatable = true
requires = 'plperlu'

35
dist/win-x64/postgres-standalone/share/extension/btree_gin--1.0--1.1.sql vendored Normal file
View File

@@ -0,0 +1,35 @@
/* contrib/btree_gin/btree_gin--1.0--1.1.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "ALTER EXTENSION btree_gin UPDATE TO '1.1'" to load this file. \quit
-- macaddr8 datatype support new in 10.0.
CREATE FUNCTION gin_extract_value_macaddr8(macaddr8, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_macaddr8(macaddr8, macaddr8, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_macaddr8(macaddr8, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS macaddr8_ops
DEFAULT FOR TYPE macaddr8 USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 macaddr8_cmp(macaddr8, macaddr8),
FUNCTION 2 gin_extract_value_macaddr8(macaddr8, internal),
FUNCTION 3 gin_extract_query_macaddr8(macaddr8, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_macaddr8(macaddr8, macaddr8, int2, internal),
STORAGE macaddr8;

689
dist/win-x64/postgres-standalone/share/extension/btree_gin--1.0.sql vendored Normal file
View File

@@ -0,0 +1,689 @@
/* contrib/btree_gin/btree_gin--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION btree_gin" to load this file. \quit
CREATE FUNCTION gin_btree_consistent(internal, int2, anyelement, int4, internal, internal)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_value_int2(int2, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_int2(int2, int2, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_int2(int2, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS int2_ops
DEFAULT FOR TYPE int2 USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 btint2cmp(int2,int2),
FUNCTION 2 gin_extract_value_int2(int2, internal),
FUNCTION 3 gin_extract_query_int2(int2, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_int2(int2,int2,int2, internal),
STORAGE int2;
CREATE FUNCTION gin_extract_value_int4(int4, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_int4(int4, int4, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_int4(int4, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS int4_ops
DEFAULT FOR TYPE int4 USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 btint4cmp(int4,int4),
FUNCTION 2 gin_extract_value_int4(int4, internal),
FUNCTION 3 gin_extract_query_int4(int4, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_int4(int4,int4,int2, internal),
STORAGE int4;
CREATE FUNCTION gin_extract_value_int8(int8, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_int8(int8, int8, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_int8(int8, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS int8_ops
DEFAULT FOR TYPE int8 USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 btint8cmp(int8,int8),
FUNCTION 2 gin_extract_value_int8(int8, internal),
FUNCTION 3 gin_extract_query_int8(int8, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_int8(int8,int8,int2, internal),
STORAGE int8;
CREATE FUNCTION gin_extract_value_float4(float4, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_float4(float4, float4, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_float4(float4, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS float4_ops
DEFAULT FOR TYPE float4 USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 btfloat4cmp(float4,float4),
FUNCTION 2 gin_extract_value_float4(float4, internal),
FUNCTION 3 gin_extract_query_float4(float4, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_float4(float4,float4,int2, internal),
STORAGE float4;
CREATE FUNCTION gin_extract_value_float8(float8, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_float8(float8, float8, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_float8(float8, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS float8_ops
DEFAULT FOR TYPE float8 USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 btfloat8cmp(float8,float8),
FUNCTION 2 gin_extract_value_float8(float8, internal),
FUNCTION 3 gin_extract_query_float8(float8, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_float8(float8,float8,int2, internal),
STORAGE float8;
CREATE FUNCTION gin_extract_value_money(money, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_money(money, money, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_money(money, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS money_ops
DEFAULT FOR TYPE money USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 cash_cmp(money,money),
FUNCTION 2 gin_extract_value_money(money, internal),
FUNCTION 3 gin_extract_query_money(money, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_money(money,money,int2, internal),
STORAGE money;
CREATE FUNCTION gin_extract_value_oid(oid, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_oid(oid, oid, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_oid(oid, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS oid_ops
DEFAULT FOR TYPE oid USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 btoidcmp(oid,oid),
FUNCTION 2 gin_extract_value_oid(oid, internal),
FUNCTION 3 gin_extract_query_oid(oid, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_oid(oid,oid,int2, internal),
STORAGE oid;
CREATE FUNCTION gin_extract_value_timestamp(timestamp, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_timestamp(timestamp, timestamp, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_timestamp(timestamp, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS timestamp_ops
DEFAULT FOR TYPE timestamp USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 timestamp_cmp(timestamp,timestamp),
FUNCTION 2 gin_extract_value_timestamp(timestamp, internal),
FUNCTION 3 gin_extract_query_timestamp(timestamp, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_timestamp(timestamp,timestamp,int2, internal),
STORAGE timestamp;
CREATE FUNCTION gin_extract_value_timestamptz(timestamptz, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_timestamptz(timestamptz, timestamptz, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_timestamptz(timestamptz, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS timestamptz_ops
DEFAULT FOR TYPE timestamptz USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 timestamptz_cmp(timestamptz,timestamptz),
FUNCTION 2 gin_extract_value_timestamptz(timestamptz, internal),
FUNCTION 3 gin_extract_query_timestamptz(timestamptz, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_timestamptz(timestamptz,timestamptz,int2, internal),
STORAGE timestamptz;
CREATE FUNCTION gin_extract_value_time(time, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_time(time, time, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_time(time, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS time_ops
DEFAULT FOR TYPE time USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 time_cmp(time,time),
FUNCTION 2 gin_extract_value_time(time, internal),
FUNCTION 3 gin_extract_query_time(time, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_time(time,time,int2, internal),
STORAGE time;
CREATE FUNCTION gin_extract_value_timetz(timetz, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_timetz(timetz, timetz, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_timetz(timetz, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS timetz_ops
DEFAULT FOR TYPE timetz USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 timetz_cmp(timetz,timetz),
FUNCTION 2 gin_extract_value_timetz(timetz, internal),
FUNCTION 3 gin_extract_query_timetz(timetz, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_timetz(timetz,timetz,int2, internal),
STORAGE timetz;
CREATE FUNCTION gin_extract_value_date(date, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_date(date, date, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_date(date, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS date_ops
DEFAULT FOR TYPE date USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 date_cmp(date,date),
FUNCTION 2 gin_extract_value_date(date, internal),
FUNCTION 3 gin_extract_query_date(date, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_date(date,date,int2, internal),
STORAGE date;
CREATE FUNCTION gin_extract_value_interval(interval, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_interval(interval, interval, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_interval(interval, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS interval_ops
DEFAULT FOR TYPE interval USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 interval_cmp(interval,interval),
FUNCTION 2 gin_extract_value_interval(interval, internal),
FUNCTION 3 gin_extract_query_interval(interval, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_interval(interval,interval,int2, internal),
STORAGE interval;
CREATE FUNCTION gin_extract_value_macaddr(macaddr, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_macaddr(macaddr, macaddr, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_macaddr(macaddr, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS macaddr_ops
DEFAULT FOR TYPE macaddr USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 macaddr_cmp(macaddr,macaddr),
FUNCTION 2 gin_extract_value_macaddr(macaddr, internal),
FUNCTION 3 gin_extract_query_macaddr(macaddr, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_macaddr(macaddr,macaddr,int2, internal),
STORAGE macaddr;
CREATE FUNCTION gin_extract_value_inet(inet, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_inet(inet, inet, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_inet(inet, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS inet_ops
DEFAULT FOR TYPE inet USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 network_cmp(inet,inet),
FUNCTION 2 gin_extract_value_inet(inet, internal),
FUNCTION 3 gin_extract_query_inet(inet, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_inet(inet,inet,int2, internal),
STORAGE inet;
CREATE FUNCTION gin_extract_value_cidr(cidr, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_cidr(cidr, cidr, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_cidr(cidr, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS cidr_ops
DEFAULT FOR TYPE cidr USING gin
AS
OPERATOR 1 <(inet,inet),
OPERATOR 2 <=(inet,inet),
OPERATOR 3 =(inet,inet),
OPERATOR 4 >=(inet,inet),
OPERATOR 5 >(inet,inet),
FUNCTION 1 network_cmp(inet,inet),
FUNCTION 2 gin_extract_value_cidr(cidr, internal),
FUNCTION 3 gin_extract_query_cidr(cidr, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_cidr(cidr,cidr,int2, internal),
STORAGE cidr;
CREATE FUNCTION gin_extract_value_text(text, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_text(text, text, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_text(text, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS text_ops
DEFAULT FOR TYPE text USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 bttextcmp(text,text),
FUNCTION 2 gin_extract_value_text(text, internal),
FUNCTION 3 gin_extract_query_text(text, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_text(text,text,int2, internal),
STORAGE text;
CREATE OPERATOR CLASS varchar_ops
DEFAULT FOR TYPE varchar USING gin
AS
OPERATOR 1 <(text,text),
OPERATOR 2 <=(text,text),
OPERATOR 3 =(text,text),
OPERATOR 4 >=(text,text),
OPERATOR 5 >(text,text),
FUNCTION 1 bttextcmp(text,text),
FUNCTION 2 gin_extract_value_text(text, internal),
FUNCTION 3 gin_extract_query_text(text, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_text(text,text,int2, internal),
STORAGE varchar;
CREATE FUNCTION gin_extract_value_char("char", internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_char("char", "char", int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_char("char", internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS char_ops
DEFAULT FOR TYPE "char" USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 btcharcmp("char","char"),
FUNCTION 2 gin_extract_value_char("char", internal),
FUNCTION 3 gin_extract_query_char("char", internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_char("char","char",int2, internal),
STORAGE "char";
CREATE FUNCTION gin_extract_value_bytea(bytea, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_bytea(bytea, bytea, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_bytea(bytea, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS bytea_ops
DEFAULT FOR TYPE bytea USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 byteacmp(bytea,bytea),
FUNCTION 2 gin_extract_value_bytea(bytea, internal),
FUNCTION 3 gin_extract_query_bytea(bytea, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_bytea(bytea,bytea,int2, internal),
STORAGE bytea;
CREATE FUNCTION gin_extract_value_bit(bit, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_bit(bit, bit, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_bit(bit, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS bit_ops
DEFAULT FOR TYPE bit USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 bitcmp(bit,bit),
FUNCTION 2 gin_extract_value_bit(bit, internal),
FUNCTION 3 gin_extract_query_bit(bit, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_bit(bit,bit,int2, internal),
STORAGE bit;
CREATE FUNCTION gin_extract_value_varbit(varbit, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_varbit(varbit, varbit, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_varbit(varbit, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS varbit_ops
DEFAULT FOR TYPE varbit USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 varbitcmp(varbit,varbit),
FUNCTION 2 gin_extract_value_varbit(varbit, internal),
FUNCTION 3 gin_extract_query_varbit(varbit, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_varbit(varbit,varbit,int2, internal),
STORAGE varbit;
CREATE FUNCTION gin_extract_value_numeric(numeric, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_numeric(numeric, numeric, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_numeric(numeric, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_numeric_cmp(numeric, numeric)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS numeric_ops
DEFAULT FOR TYPE numeric USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 gin_numeric_cmp(numeric,numeric),
FUNCTION 2 gin_extract_value_numeric(numeric, internal),
FUNCTION 3 gin_extract_query_numeric(numeric, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_numeric(numeric,numeric,int2, internal),
STORAGE numeric;

47
dist/win-x64/postgres-standalone/share/extension/btree_gin--1.1--1.2.sql vendored Normal file
View File

@@ -0,0 +1,47 @@
/* contrib/btree_gin/btree_gin--1.1--1.2.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "ALTER EXTENSION btree_gin UPDATE TO '1.1'" to load this file. \quit
--
--
--
-- enum ops
--
--
CREATE FUNCTION gin_extract_value_anyenum(anyenum, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_anyenum(anyenum, anyenum, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_anyenum(anyenum, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_enum_cmp(anyenum, anyenum)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS enum_ops
DEFAULT FOR TYPE anyenum USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 gin_enum_cmp(anyenum,anyenum),
FUNCTION 2 gin_extract_value_anyenum(anyenum, internal),
FUNCTION 3 gin_extract_query_anyenum(anyenum, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_anyenum(anyenum,anyenum,int2, internal),
STORAGE anyenum;

128
dist/win-x64/postgres-standalone/share/extension/btree_gin--1.2--1.3.sql vendored Normal file
View File

@@ -0,0 +1,128 @@
/* contrib/btree_gin/btree_gin--1.2--1.3.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "ALTER EXTENSION btree_gin UPDATE TO '1.3'" to load this file. \quit
-- uuid datatype support new in 1.3.
CREATE FUNCTION gin_extract_value_uuid(uuid, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_uuid(uuid, uuid, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_uuid(uuid, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS uuid_ops
DEFAULT FOR TYPE uuid USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 uuid_cmp(uuid,uuid),
FUNCTION 2 gin_extract_value_uuid(uuid, internal),
FUNCTION 3 gin_extract_query_uuid(uuid, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_uuid(uuid,uuid,int2, internal),
STORAGE uuid;
-- name datatype support new in 1.3.
CREATE FUNCTION gin_extract_value_name(name, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_name(name, name, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_name(name, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS name_ops
DEFAULT FOR TYPE name USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 btnamecmp(name,name),
FUNCTION 2 gin_extract_value_name(name, internal),
FUNCTION 3 gin_extract_query_name(name, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_name(name,name,int2, internal),
STORAGE name;
-- bool datatype support new in 1.3.
CREATE FUNCTION gin_extract_value_bool(bool, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_bool(bool, bool, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_bool(bool, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS bool_ops
DEFAULT FOR TYPE bool USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 btboolcmp(bool,bool),
FUNCTION 2 gin_extract_value_bool(bool, internal),
FUNCTION 3 gin_extract_query_bool(bool, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_bool(bool,bool,int2, internal),
STORAGE bool;
-- bpchar datatype support new in 1.3.
CREATE FUNCTION gin_extract_value_bpchar(bpchar, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_compare_prefix_bpchar(bpchar, bpchar, int2, internal)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE FUNCTION gin_extract_query_bpchar(bpchar, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE;
CREATE OPERATOR CLASS bpchar_ops
DEFAULT FOR TYPE bpchar USING gin
AS
OPERATOR 1 <,
OPERATOR 2 <=,
OPERATOR 3 =,
OPERATOR 4 >=,
OPERATOR 5 >,
FUNCTION 1 bpcharcmp(bpchar, bpchar),
FUNCTION 2 gin_extract_value_bpchar(bpchar, internal),
FUNCTION 3 gin_extract_query_bpchar(bpchar, internal, int2, internal, internal),
FUNCTION 4 gin_btree_consistent(internal, int2, anyelement, int4, internal, internal),
FUNCTION 5 gin_compare_prefix_bpchar(bpchar,bpchar,int2, internal),
STORAGE bpchar;

6
dist/win-x64/postgres-standalone/share/extension/btree_gin.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# btree_gin extension
comment = 'support for indexing common datatypes in GIN'
default_version = '1.3'
module_pathname = '$libdir/btree_gin'
relocatable = true
trusted = true

127
dist/win-x64/postgres-standalone/share/extension/btree_gist--1.0--1.1.sql vendored Normal file
View File

@@ -0,0 +1,127 @@
/* contrib/btree_gist/btree_gist--1.0--1.1.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.1'" to load this file. \quit
-- Index-only scan support new in 9.5.
CREATE FUNCTION gbt_oid_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_int2_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_int4_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_int8_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_float4_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_float8_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_ts_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_time_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_date_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_intv_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_cash_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_macad_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_var_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
ALTER OPERATOR FAMILY gist_oid_ops USING gist ADD
FUNCTION 9 (oid, oid) gbt_oid_fetch (internal) ;
ALTER OPERATOR FAMILY gist_int2_ops USING gist ADD
FUNCTION 9 (int2, int2) gbt_int2_fetch (internal) ;
ALTER OPERATOR FAMILY gist_int4_ops USING gist ADD
FUNCTION 9 (int4, int4) gbt_int4_fetch (internal) ;
ALTER OPERATOR FAMILY gist_int8_ops USING gist ADD
FUNCTION 9 (int8, int8) gbt_int8_fetch (internal) ;
ALTER OPERATOR FAMILY gist_float4_ops USING gist ADD
FUNCTION 9 (float4, float4) gbt_float4_fetch (internal) ;
ALTER OPERATOR FAMILY gist_float8_ops USING gist ADD
FUNCTION 9 (float8, float8) gbt_float8_fetch (internal) ;
ALTER OPERATOR FAMILY gist_timestamp_ops USING gist ADD
FUNCTION 9 (timestamp, timestamp) gbt_ts_fetch (internal) ;
ALTER OPERATOR FAMILY gist_timestamptz_ops USING gist ADD
FUNCTION 9 (timestamptz, timestamptz) gbt_ts_fetch (internal) ;
ALTER OPERATOR FAMILY gist_time_ops USING gist ADD
FUNCTION 9 (time, time) gbt_time_fetch (internal) ;
ALTER OPERATOR FAMILY gist_date_ops USING gist ADD
FUNCTION 9 (date, date) gbt_date_fetch (internal) ;
ALTER OPERATOR FAMILY gist_interval_ops USING gist ADD
FUNCTION 9 (interval, interval) gbt_intv_fetch (internal) ;
ALTER OPERATOR FAMILY gist_cash_ops USING gist ADD
FUNCTION 9 (money, money) gbt_cash_fetch (internal) ;
ALTER OPERATOR FAMILY gist_macaddr_ops USING gist ADD
FUNCTION 9 (macaddr, macaddr) gbt_macad_fetch (internal) ;
ALTER OPERATOR FAMILY gist_text_ops USING gist ADD
FUNCTION 9 (text, text) gbt_var_fetch (internal) ;
ALTER OPERATOR FAMILY gist_bpchar_ops USING gist ADD
FUNCTION 9 (bpchar, bpchar) gbt_var_fetch (internal) ;
ALTER OPERATOR FAMILY gist_bytea_ops USING gist ADD
FUNCTION 9 (bytea, bytea) gbt_var_fetch (internal) ;
ALTER OPERATOR FAMILY gist_numeric_ops USING gist ADD
FUNCTION 9 (numeric, numeric) gbt_var_fetch (internal) ;
ALTER OPERATOR FAMILY gist_bit_ops USING gist ADD
FUNCTION 9 (bit, bit) gbt_var_fetch (internal) ;
ALTER OPERATOR FAMILY gist_vbit_ops USING gist ADD
FUNCTION 9 (varbit, varbit) gbt_var_fetch (internal) ;

79
dist/win-x64/postgres-standalone/share/extension/btree_gist--1.1--1.2.sql vendored Normal file
View File

@@ -0,0 +1,79 @@
/* contrib/btree_gist/btree_gist--1.1--1.2.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.2'" to load this file. \quit
-- Update procedure signatures the hard way.
-- We use to_regprocedure() so that query doesn't fail if run against 9.6beta1 definitions,
-- wherein the signatures have been updated already. In that case to_regprocedure() will
-- return NULL and no updates will happen.
DO LANGUAGE plpgsql
$$
DECLARE
my_schema pg_catalog.text := pg_catalog.quote_ident(pg_catalog.current_schema());
old_path pg_catalog.text := pg_catalog.current_setting('search_path');
BEGIN
-- for safety, transiently set search_path to just pg_catalog+pg_temp
PERFORM pg_catalog.set_config('search_path', 'pg_catalog, pg_temp', true);
UPDATE pg_catalog.pg_proc SET
proargtypes = pg_catalog.array_to_string(newtypes::pg_catalog.oid[], ' ')::pg_catalog.oidvector,
pronargs = pg_catalog.array_length(newtypes, 1)
FROM (VALUES
(NULL::pg_catalog.text, NULL::pg_catalog.text[]), -- establish column types
('gbt_oid_distance(internal,oid,int2,oid)', '{internal,oid,int2,oid,internal}'),
('gbt_oid_union(bytea,internal)', '{internal,internal}'),
('gbt_oid_same(internal,internal,internal)', '{SCH.gbtreekey8,SCH.gbtreekey8,internal}'),
('gbt_int2_distance(internal,int2,int2,oid)', '{internal,int2,int2,oid,internal}'),
('gbt_int2_union(bytea,internal)', '{internal,internal}'),
('gbt_int2_same(internal,internal,internal)', '{SCH.gbtreekey4,SCH.gbtreekey4,internal}'),
('gbt_int4_distance(internal,int4,int2,oid)', '{internal,int4,int2,oid,internal}'),
('gbt_int4_union(bytea,internal)', '{internal,internal}'),
('gbt_int4_same(internal,internal,internal)', '{SCH.gbtreekey8,SCH.gbtreekey8,internal}'),
('gbt_int8_distance(internal,int8,int2,oid)', '{internal,int8,int2,oid,internal}'),
('gbt_int8_union(bytea,internal)', '{internal,internal}'),
('gbt_int8_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}'),
('gbt_float4_distance(internal,float4,int2,oid)', '{internal,float4,int2,oid,internal}'),
('gbt_float4_union(bytea,internal)', '{internal,internal}'),
('gbt_float4_same(internal,internal,internal)', '{SCH.gbtreekey8,SCH.gbtreekey8,internal}'),
('gbt_float8_distance(internal,float8,int2,oid)', '{internal,float8,int2,oid,internal}'),
('gbt_float8_union(bytea,internal)', '{internal,internal}'),
('gbt_float8_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}'),
('gbt_ts_distance(internal,timestamp,int2,oid)', '{internal,timestamp,int2,oid,internal}'),
('gbt_tstz_distance(internal,timestamptz,int2,oid)', '{internal,timestamptz,int2,oid,internal}'),
('gbt_ts_union(bytea,internal)', '{internal,internal}'),
('gbt_ts_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}'),
('gbt_time_distance(internal,time,int2,oid)', '{internal,time,int2,oid,internal}'),
('gbt_time_union(bytea,internal)', '{internal,internal}'),
('gbt_time_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}'),
('gbt_date_distance(internal,date,int2,oid)', '{internal,date,int2,oid,internal}'),
('gbt_date_union(bytea,internal)', '{internal,internal}'),
('gbt_date_same(internal,internal,internal)', '{SCH.gbtreekey8,SCH.gbtreekey8,internal}'),
('gbt_intv_distance(internal,interval,int2,oid)', '{internal,interval,int2,oid,internal}'),
('gbt_intv_union(bytea,internal)', '{internal,internal}'),
('gbt_intv_same(internal,internal,internal)', '{SCH.gbtreekey32,SCH.gbtreekey32,internal}'),
('gbt_cash_distance(internal,money,int2,oid)', '{internal,money,int2,oid,internal}'),
('gbt_cash_union(bytea,internal)', '{internal,internal}'),
('gbt_cash_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}'),
('gbt_macad_union(bytea,internal)', '{internal,internal}'),
('gbt_macad_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}'),
('gbt_text_union(bytea,internal)', '{internal,internal}'),
('gbt_text_same(internal,internal,internal)', '{SCH.gbtreekey_var,SCH.gbtreekey_var,internal}'),
('gbt_bytea_union(bytea,internal)', '{internal,internal}'),
('gbt_bytea_same(internal,internal,internal)', '{SCH.gbtreekey_var,SCH.gbtreekey_var,internal}'),
('gbt_numeric_union(bytea,internal)', '{internal,internal}'),
('gbt_numeric_same(internal,internal,internal)', '{SCH.gbtreekey_var,SCH.gbtreekey_var,internal}'),
('gbt_bit_union(bytea,internal)', '{internal,internal}'),
('gbt_bit_same(internal,internal,internal)', '{SCH.gbtreekey_var,SCH.gbtreekey_var,internal}'),
('gbt_inet_union(bytea,internal)', '{internal,internal}'),
('gbt_inet_same(internal,internal,internal)', '{SCH.gbtreekey16,SCH.gbtreekey16,internal}')
) AS update_data (oldproc, newtypestext),
LATERAL (
SELECT array_agg(replace(typ, 'SCH', my_schema)::regtype) as newtypes FROM unnest(newtypestext) typ
) ls
WHERE oid = to_regprocedure(my_schema || '.' || replace(oldproc, 'SCH', my_schema));
PERFORM pg_catalog.set_config('search_path', old_path, true);
END
$$;

65
dist/win-x64/postgres-standalone/share/extension/btree_gist--1.2--1.3.sql vendored Normal file
View File

@@ -0,0 +1,65 @@
/* contrib/btree_gist/btree_gist--1.2--1.3.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.3'" to load this file. \quit
-- Add support for indexing UUID columns
-- define the GiST support methods
CREATE FUNCTION gbt_uuid_consistent(internal,uuid,int2,oid,internal)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_uuid_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_uuid_compress(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_uuid_penalty(internal,internal,internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_uuid_picksplit(internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_uuid_union(internal, internal)
RETURNS gbtreekey32
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_uuid_same(gbtreekey32, gbtreekey32, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
-- Create the operator class
CREATE OPERATOR CLASS gist_uuid_ops
DEFAULT FOR TYPE uuid USING gist
AS
OPERATOR 1 < ,
OPERATOR 2 <= ,
OPERATOR 3 = ,
OPERATOR 4 >= ,
OPERATOR 5 > ,
FUNCTION 1 gbt_uuid_consistent (internal, uuid, int2, oid, internal),
FUNCTION 2 gbt_uuid_union (internal, internal),
FUNCTION 3 gbt_uuid_compress (internal),
FUNCTION 4 gbt_decompress (internal),
FUNCTION 5 gbt_uuid_penalty (internal, internal, internal),
FUNCTION 6 gbt_uuid_picksplit (internal, internal),
FUNCTION 7 gbt_uuid_same (gbtreekey32, gbtreekey32, internal),
STORAGE gbtreekey32;
-- These are "loose" in the opfamily for consistency with the rest of btree_gist
ALTER OPERATOR FAMILY gist_uuid_ops USING gist ADD
OPERATOR 6 <> (uuid, uuid) ,
FUNCTION 9 (uuid, uuid) gbt_uuid_fetch (internal) ;

1570
dist/win-x64/postgres-standalone/share/extension/btree_gist--1.2.sql vendored Normal file
View File

File diff suppressed because it is too large Load Diff

64
dist/win-x64/postgres-standalone/share/extension/btree_gist--1.3--1.4.sql vendored Normal file
View File

@@ -0,0 +1,64 @@
/* contrib/btree_gist/btree_gist--1.3--1.4.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.4'" to load this file. \quit
-- Add support for indexing macaddr8 columns
-- define the GiST support methods
CREATE FUNCTION gbt_macad8_consistent(internal,macaddr8,int2,oid,internal)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_macad8_compress(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_macad8_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_macad8_penalty(internal,internal,internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_macad8_picksplit(internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_macad8_union(internal, internal)
RETURNS gbtreekey16
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_macad8_same(gbtreekey16, gbtreekey16, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
-- Create the operator class
CREATE OPERATOR CLASS gist_macaddr8_ops
DEFAULT FOR TYPE macaddr8 USING gist
AS
OPERATOR 1 < ,
OPERATOR 2 <= ,
OPERATOR 3 = ,
OPERATOR 4 >= ,
OPERATOR 5 > ,
FUNCTION 1 gbt_macad8_consistent (internal, macaddr8, int2, oid, internal),
FUNCTION 2 gbt_macad8_union (internal, internal),
FUNCTION 3 gbt_macad8_compress (internal),
FUNCTION 4 gbt_decompress (internal),
FUNCTION 5 gbt_macad8_penalty (internal, internal, internal),
FUNCTION 6 gbt_macad8_picksplit (internal, internal),
FUNCTION 7 gbt_macad8_same (gbtreekey16, gbtreekey16, internal),
STORAGE gbtreekey16;
ALTER OPERATOR FAMILY gist_macaddr8_ops USING gist ADD
OPERATOR 6 <> (macaddr8, macaddr8) ,
FUNCTION 9 (macaddr8, macaddr8) gbt_macad8_fetch (internal);

69
dist/win-x64/postgres-standalone/share/extension/btree_gist--1.4--1.5.sql vendored Normal file
View File

@@ -0,0 +1,69 @@
/* contrib/btree_gist/btree_gist--1.4--1.5.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.5'" to load this file. \quit
--
--
--
-- enum ops
--
--
--
-- define the GiST support methods
CREATE FUNCTION gbt_enum_consistent(internal,anyenum,int2,oid,internal)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_enum_compress(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_enum_fetch(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_enum_penalty(internal,internal,internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_enum_picksplit(internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_enum_union(internal, internal)
RETURNS gbtreekey8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION gbt_enum_same(gbtreekey8, gbtreekey8, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
-- Create the operator class
CREATE OPERATOR CLASS gist_enum_ops
DEFAULT FOR TYPE anyenum USING gist
AS
OPERATOR 1 < ,
OPERATOR 2 <= ,
OPERATOR 3 = ,
OPERATOR 4 >= ,
OPERATOR 5 > ,
FUNCTION 1 gbt_enum_consistent (internal, anyenum, int2, oid, internal),
FUNCTION 2 gbt_enum_union (internal, internal),
FUNCTION 3 gbt_enum_compress (internal),
FUNCTION 4 gbt_decompress (internal),
FUNCTION 5 gbt_enum_penalty (internal, internal, internal),
FUNCTION 6 gbt_enum_picksplit (internal, internal),
FUNCTION 7 gbt_enum_same (gbtreekey8, gbtreekey8, internal),
STORAGE gbtreekey8;
ALTER OPERATOR FAMILY gist_enum_ops USING gist ADD
OPERATOR 6 <> (anyenum, anyenum) ,
FUNCTION 9 (anyenum, anyenum) gbt_enum_fetch (internal) ;

191
dist/win-x64/postgres-standalone/share/extension/btree_gist--1.5--1.6.sql vendored Normal file
View File

@@ -0,0 +1,191 @@
/* contrib/btree_gist/btree_gist--1.5--1.6.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "ALTER EXTENSION btree_gist UPDATE TO '1.6'" to load this file. \quit
-- This upgrade script marks all btree_gist functions as parallel safe.
-- Input/output functions for GiST key types (gbtreekey*)
ALTER FUNCTION gbtreekey4_in(cstring) PARALLEL SAFE;
ALTER FUNCTION gbtreekey4_out(gbtreekey4) PARALLEL SAFE;
ALTER FUNCTION gbtreekey8_in(cstring) PARALLEL SAFE;
ALTER FUNCTION gbtreekey8_out(gbtreekey8) PARALLEL SAFE;
ALTER FUNCTION gbtreekey16_in(cstring) PARALLEL SAFE;
ALTER FUNCTION gbtreekey16_out(gbtreekey16) PARALLEL SAFE;
ALTER FUNCTION gbtreekey32_in(cstring) PARALLEL SAFE;
ALTER FUNCTION gbtreekey32_out(gbtreekey32) PARALLEL SAFE;
ALTER FUNCTION gbtreekey_var_in(cstring) PARALLEL SAFE;
ALTER FUNCTION gbtreekey_var_out(gbtreekey_var) PARALLEL SAFE;
-- Functions, which implement distance operators (<->)
ALTER FUNCTION cash_dist(money, money) PARALLEL SAFE;
ALTER FUNCTION date_dist(date, date) PARALLEL SAFE;
ALTER FUNCTION float4_dist(real, real) PARALLEL SAFE;
ALTER FUNCTION float8_dist(double precision, double precision) PARALLEL SAFE;
ALTER FUNCTION int2_dist(smallint, smallint) PARALLEL SAFE;
ALTER FUNCTION int4_dist(integer, integer) PARALLEL SAFE;
ALTER FUNCTION int8_dist(bigint, bigint) PARALLEL SAFE;
ALTER FUNCTION interval_dist(interval, interval) PARALLEL SAFE;
ALTER FUNCTION oid_dist(oid, oid) PARALLEL SAFE;
ALTER FUNCTION time_dist(time without time zone, time without time zone) PARALLEL SAFE;
ALTER FUNCTION ts_dist(timestamp without time zone, timestamp without time zone) PARALLEL SAFE;
ALTER FUNCTION tstz_dist(timestamp with time zone, timestamp with time zone) PARALLEL SAFE;
-- GiST support methods
ALTER FUNCTION gbt_oid_consistent(internal, oid, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_oid_distance(internal, oid, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_oid_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_oid_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_decompress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_var_decompress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_var_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_oid_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_oid_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_oid_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_oid_same(gbtreekey8, gbtreekey8, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int2_consistent(internal, smallint, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int2_distance(internal, smallint, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int2_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int2_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int2_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int2_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int2_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int2_same(gbtreekey4, gbtreekey4, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int4_consistent(internal, integer, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int4_distance(internal, integer, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int4_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int4_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int4_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int4_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int4_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int4_same(gbtreekey8, gbtreekey8, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int8_consistent(internal, bigint, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int8_distance(internal, bigint, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int8_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int8_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int8_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int8_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int8_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_int8_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float4_consistent(internal, real, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float4_distance(internal, real, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float4_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float4_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float4_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float4_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float4_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float4_same(gbtreekey8, gbtreekey8, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float8_consistent(internal, double precision, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float8_distance(internal, double precision, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float8_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float8_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float8_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float8_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float8_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_float8_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_ts_consistent(internal, timestamp without time zone, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_ts_distance(internal, timestamp without time zone, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_tstz_consistent(internal, timestamp with time zone, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_tstz_distance(internal, timestamp with time zone, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_ts_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_tstz_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_ts_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_ts_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_ts_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_ts_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_ts_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_time_consistent(internal, time without time zone, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_time_distance(internal, time without time zone, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_timetz_consistent(internal, time with time zone, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_time_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_timetz_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_time_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_time_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_time_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_time_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_time_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_date_consistent(internal, date, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_date_distance(internal, date, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_date_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_date_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_date_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_date_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_date_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_date_same(gbtreekey8, gbtreekey8, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_intv_consistent(internal, interval, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_intv_distance(internal, interval, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_intv_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_intv_decompress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_intv_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_intv_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_intv_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_intv_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_intv_same(gbtreekey32, gbtreekey32, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_cash_consistent(internal, money, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_cash_distance(internal, money, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_cash_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_cash_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_cash_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_cash_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_cash_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_cash_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad_consistent(internal, macaddr, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_text_consistent(internal, text, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bpchar_consistent(internal, character, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_text_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bpchar_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_text_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_text_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_text_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_text_same(gbtreekey_var, gbtreekey_var, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bytea_consistent(internal, bytea, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bytea_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bytea_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bytea_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bytea_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bytea_same(gbtreekey_var, gbtreekey_var, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_numeric_consistent(internal, numeric, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_numeric_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_numeric_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_numeric_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_numeric_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_numeric_same(gbtreekey_var, gbtreekey_var, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bit_consistent(internal, bit, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bit_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bit_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bit_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bit_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_bit_same(gbtreekey_var, gbtreekey_var, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_inet_consistent(internal, inet, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_inet_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_inet_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_inet_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_inet_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_inet_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_uuid_consistent(internal, uuid, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_uuid_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_uuid_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_uuid_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_uuid_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_uuid_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_uuid_same(gbtreekey32, gbtreekey32, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad8_consistent(internal, macaddr8, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad8_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad8_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad8_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad8_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad8_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_macad8_same(gbtreekey16, gbtreekey16, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_enum_consistent(internal, anyenum, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_enum_compress(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_enum_fetch(internal) PARALLEL SAFE;
ALTER FUNCTION gbt_enum_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_enum_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_enum_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION gbt_enum_same(gbtreekey8, gbtreekey8, internal) PARALLEL SAFE;

6
dist/win-x64/postgres-standalone/share/extension/btree_gist.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# btree_gist extension
comment = 'support for indexing common datatypes in GiST'
default_version = '1.6'
module_pathname = '$libdir/btree_gist'
relocatable = true
trusted = true

21
dist/win-x64/postgres-standalone/share/extension/citext--1.0--1.1.sql vendored Normal file
View File

@@ -0,0 +1,21 @@
/* contrib/citext/citext--1.0--1.1.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION citext UPDATE TO '1.1'" to load this file. \quit
/* First we have to remove them from the extension */
ALTER EXTENSION citext DROP FUNCTION regexp_matches( citext, citext );
ALTER EXTENSION citext DROP FUNCTION regexp_matches( citext, citext, text );
/* Then we can drop them */
DROP FUNCTION regexp_matches( citext, citext );
DROP FUNCTION regexp_matches( citext, citext, text );
/* Now redefine */
CREATE FUNCTION regexp_matches( citext, citext ) RETURNS SETOF TEXT[] AS $$
SELECT pg_catalog.regexp_matches( $1::pg_catalog.text, $2::pg_catalog.text, 'i' );
$$ LANGUAGE SQL IMMUTABLE STRICT ROWS 1;
CREATE FUNCTION regexp_matches( citext, citext, text ) RETURNS SETOF TEXT[] AS $$
SELECT pg_catalog.regexp_matches( $1::pg_catalog.text, $2::pg_catalog.text, CASE WHEN pg_catalog.strpos($3, 'c') = 0 THEN $3 || 'i' ELSE $3 END );
$$ LANGUAGE SQL IMMUTABLE STRICT ROWS 10;

68
dist/win-x64/postgres-standalone/share/extension/citext--1.1--1.2.sql vendored Normal file
View File

@@ -0,0 +1,68 @@
/* contrib/citext/citext--1.1--1.2.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION citext UPDATE TO '1.2'" to load this file. \quit
ALTER FUNCTION citextin(cstring) PARALLEL SAFE;
ALTER FUNCTION citextout(citext) PARALLEL SAFE;
ALTER FUNCTION citextrecv(internal) PARALLEL SAFE;
ALTER FUNCTION citextsend(citext) PARALLEL SAFE;
ALTER FUNCTION citext(bpchar) PARALLEL SAFE;
ALTER FUNCTION citext(boolean) PARALLEL SAFE;
ALTER FUNCTION citext(inet) PARALLEL SAFE;
ALTER FUNCTION citext_eq(citext, citext) PARALLEL SAFE;
ALTER FUNCTION citext_ne(citext, citext) PARALLEL SAFE;
ALTER FUNCTION citext_lt(citext, citext) PARALLEL SAFE;
ALTER FUNCTION citext_le(citext, citext) PARALLEL SAFE;
ALTER FUNCTION citext_gt(citext, citext) PARALLEL SAFE;
ALTER FUNCTION citext_ge(citext, citext) PARALLEL SAFE;
ALTER FUNCTION citext_cmp(citext, citext) PARALLEL SAFE;
ALTER FUNCTION citext_hash(citext) PARALLEL SAFE;
ALTER FUNCTION citext_smaller(citext, citext) PARALLEL SAFE;
ALTER FUNCTION citext_larger(citext, citext) PARALLEL SAFE;
ALTER FUNCTION texticlike(citext, citext) PARALLEL SAFE;
ALTER FUNCTION texticnlike(citext, citext) PARALLEL SAFE;
ALTER FUNCTION texticregexeq(citext, citext) PARALLEL SAFE;
ALTER FUNCTION texticregexne(citext, citext) PARALLEL SAFE;
ALTER FUNCTION texticlike(citext, text) PARALLEL SAFE;
ALTER FUNCTION texticnlike(citext, text) PARALLEL SAFE;
ALTER FUNCTION texticregexeq(citext, text) PARALLEL SAFE;
ALTER FUNCTION texticregexne(citext, text) PARALLEL SAFE;
ALTER FUNCTION regexp_matches(citext, citext) PARALLEL SAFE;
ALTER FUNCTION regexp_matches(citext, citext, text) PARALLEL SAFE;
ALTER FUNCTION regexp_replace(citext, citext, text) PARALLEL SAFE;
ALTER FUNCTION regexp_replace(citext, citext, text, text) PARALLEL SAFE;
ALTER FUNCTION regexp_split_to_array(citext, citext) PARALLEL SAFE;
ALTER FUNCTION regexp_split_to_array(citext, citext, text) PARALLEL SAFE;
ALTER FUNCTION regexp_split_to_table(citext, citext) PARALLEL SAFE;
ALTER FUNCTION regexp_split_to_table(citext, citext, text) PARALLEL SAFE;
ALTER FUNCTION strpos(citext, citext) PARALLEL SAFE;
ALTER FUNCTION replace(citext, citext, citext) PARALLEL SAFE;
ALTER FUNCTION split_part(citext, citext, int) PARALLEL SAFE;
ALTER FUNCTION translate(citext, citext, text) PARALLEL SAFE;
-- We have to update aggregates the hard way for lack of ALTER support
DO LANGUAGE plpgsql
$$
DECLARE
my_schema pg_catalog.text := pg_catalog.quote_ident(pg_catalog.current_schema());
old_path pg_catalog.text := pg_catalog.current_setting('search_path');
BEGIN
-- for safety, transiently set search_path to just pg_catalog+pg_temp
PERFORM pg_catalog.set_config('search_path', 'pg_catalog, pg_temp', true);
UPDATE pg_proc SET proparallel = 's'
WHERE oid = (my_schema || '.min(' || my_schema || '.citext)')::pg_catalog.regprocedure;
UPDATE pg_proc SET proparallel = 's'
WHERE oid = (my_schema || '.max(' || my_schema || '.citext)')::pg_catalog.regprocedure;
UPDATE pg_aggregate SET aggcombinefn = (my_schema || '.citext_smaller')::regproc
WHERE aggfnoid = (my_schema || '.max(' || my_schema || '.citext)')::pg_catalog.regprocedure;
UPDATE pg_aggregate SET aggcombinefn = (my_schema || '.citext_larger')::regproc
WHERE aggfnoid = (my_schema || '.max(' || my_schema || '.citext)')::pg_catalog.regprocedure;
PERFORM pg_catalog.set_config('search_path', old_path, true);
END
$$;

21
dist/win-x64/postgres-standalone/share/extension/citext--1.2--1.3.sql vendored Normal file
View File

@@ -0,0 +1,21 @@
/* contrib/citext/citext--1.2--1.3.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION citext UPDATE TO '1.3'" to load this file. \quit
-- We have to update aggregates the hard way for lack of ALTER support
DO LANGUAGE plpgsql
$$
DECLARE
my_schema pg_catalog.text := pg_catalog.quote_ident(pg_catalog.current_schema());
old_path pg_catalog.text := pg_catalog.current_setting('search_path');
BEGIN
-- for safety, transiently set search_path to just pg_catalog+pg_temp
PERFORM pg_catalog.set_config('search_path', 'pg_catalog, pg_temp', true);
UPDATE pg_aggregate SET aggcombinefn = (my_schema || '.citext_smaller')::regproc
WHERE aggfnoid = (my_schema || '.min(' || my_schema || '.citext)')::pg_catalog.regprocedure;
PERFORM pg_catalog.set_config('search_path', old_path, true);
END
$$;

12
dist/win-x64/postgres-standalone/share/extension/citext--1.3--1.4.sql vendored Normal file
View File

@@ -0,0 +1,12 @@
/* contrib/citext/citext--1.3--1.4.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION citext UPDATE TO '1.4'" to load this file. \quit
CREATE FUNCTION regexp_match( citext, citext ) RETURNS TEXT[] AS $$
SELECT pg_catalog.regexp_match( $1::pg_catalog.text, $2::pg_catalog.text, 'i' );
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION regexp_match( citext, citext, text ) RETURNS TEXT[] AS $$
SELECT pg_catalog.regexp_match( $1::pg_catalog.text, $2::pg_catalog.text, CASE WHEN pg_catalog.strpos($3, 'c') = 0 THEN $3 || 'i' ELSE $3 END );
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;

88
dist/win-x64/postgres-standalone/share/extension/citext--1.4--1.5.sql vendored Normal file
View File

@@ -0,0 +1,88 @@
/* contrib/citext/citext--1.4--1.5.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION citext UPDATE TO '1.5'" to load this file. \quit
ALTER OPERATOR <= (citext, citext) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel
);
ALTER OPERATOR >= (citext, citext) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel
);
CREATE FUNCTION citext_pattern_lt( citext, citext )
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citext_pattern_le( citext, citext )
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citext_pattern_gt( citext, citext )
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citext_pattern_ge( citext, citext )
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OPERATOR ~<~ (
LEFTARG = CITEXT,
RIGHTARG = CITEXT,
NEGATOR = ~>=~,
COMMUTATOR = ~>~,
PROCEDURE = citext_pattern_lt,
RESTRICT = scalarltsel,
JOIN = scalarltjoinsel
);
CREATE OPERATOR ~<=~ (
LEFTARG = CITEXT,
RIGHTARG = CITEXT,
NEGATOR = ~>~,
COMMUTATOR = ~>=~,
PROCEDURE = citext_pattern_le,
RESTRICT = scalarltsel,
JOIN = scalarltjoinsel
);
CREATE OPERATOR ~>=~ (
LEFTARG = CITEXT,
RIGHTARG = CITEXT,
NEGATOR = ~<~,
COMMUTATOR = ~<=~,
PROCEDURE = citext_pattern_ge,
RESTRICT = scalargtsel,
JOIN = scalargtjoinsel
);
CREATE OPERATOR ~>~ (
LEFTARG = CITEXT,
RIGHTARG = CITEXT,
NEGATOR = ~<=~,
COMMUTATOR = ~<~,
PROCEDURE = citext_pattern_gt,
RESTRICT = scalargtsel,
JOIN = scalargtjoinsel
);
CREATE FUNCTION citext_pattern_cmp(citext, citext)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR CLASS citext_pattern_ops
FOR TYPE CITEXT USING btree AS
OPERATOR 1 ~<~ (citext, citext),
OPERATOR 2 ~<=~ (citext, citext),
OPERATOR 3 = (citext, citext),
OPERATOR 4 ~>=~ (citext, citext),
OPERATOR 5 ~>~ (citext, citext),
FUNCTION 1 citext_pattern_cmp(citext, citext);

501
dist/win-x64/postgres-standalone/share/extension/citext--1.4.sql vendored Normal file
View File

@@ -0,0 +1,501 @@
/* contrib/citext/citext--1.4.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION citext" to load this file. \quit
--
-- PostgreSQL code for CITEXT.
--
-- Most I/O functions, and a few others, piggyback on the "text" type
-- functions via the implicit cast to text.
--
--
-- Shell type to keep things a bit quieter.
--
CREATE TYPE citext;
--
-- Input and output functions.
--
CREATE FUNCTION citextin(cstring)
RETURNS citext
AS 'textin'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citextout(citext)
RETURNS cstring
AS 'textout'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citextrecv(internal)
RETURNS citext
AS 'textrecv'
LANGUAGE internal STABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citextsend(citext)
RETURNS bytea
AS 'textsend'
LANGUAGE internal STABLE STRICT PARALLEL SAFE;
--
-- The type itself.
--
CREATE TYPE citext (
INPUT = citextin,
OUTPUT = citextout,
RECEIVE = citextrecv,
SEND = citextsend,
INTERNALLENGTH = VARIABLE,
STORAGE = extended,
-- make it a non-preferred member of string type category
CATEGORY = 'S',
PREFERRED = false,
COLLATABLE = true
);
--
-- Type casting functions for those situations where the I/O casts don't
-- automatically kick in.
--
CREATE FUNCTION citext(bpchar)
RETURNS citext
AS 'rtrim1'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citext(boolean)
RETURNS citext
AS 'booltext'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citext(inet)
RETURNS citext
AS 'network_show'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
--
-- Implicit and assignment type casts.
--
CREATE CAST (citext AS text) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (citext AS varchar) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (citext AS bpchar) WITHOUT FUNCTION AS ASSIGNMENT;
CREATE CAST (text AS citext) WITHOUT FUNCTION AS ASSIGNMENT;
CREATE CAST (varchar AS citext) WITHOUT FUNCTION AS ASSIGNMENT;
CREATE CAST (bpchar AS citext) WITH FUNCTION citext(bpchar) AS ASSIGNMENT;
CREATE CAST (boolean AS citext) WITH FUNCTION citext(boolean) AS ASSIGNMENT;
CREATE CAST (inet AS citext) WITH FUNCTION citext(inet) AS ASSIGNMENT;
--
-- Operator Functions.
--
CREATE FUNCTION citext_eq( citext, citext )
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citext_ne( citext, citext )
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citext_lt( citext, citext )
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citext_le( citext, citext )
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citext_gt( citext, citext )
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citext_ge( citext, citext )
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
--
-- Operators.
--
CREATE OPERATOR = (
LEFTARG = CITEXT,
RIGHTARG = CITEXT,
COMMUTATOR = =,
NEGATOR = <>,
PROCEDURE = citext_eq,
RESTRICT = eqsel,
JOIN = eqjoinsel,
HASHES,
MERGES
);
CREATE OPERATOR <> (
LEFTARG = CITEXT,
RIGHTARG = CITEXT,
NEGATOR = =,
COMMUTATOR = <>,
PROCEDURE = citext_ne,
RESTRICT = neqsel,
JOIN = neqjoinsel
);
CREATE OPERATOR < (
LEFTARG = CITEXT,
RIGHTARG = CITEXT,
NEGATOR = >=,
COMMUTATOR = >,
PROCEDURE = citext_lt,
RESTRICT = scalarltsel,
JOIN = scalarltjoinsel
);
CREATE OPERATOR <= (
LEFTARG = CITEXT,
RIGHTARG = CITEXT,
NEGATOR = >,
COMMUTATOR = >=,
PROCEDURE = citext_le,
RESTRICT = scalarltsel,
JOIN = scalarltjoinsel
);
CREATE OPERATOR >= (
LEFTARG = CITEXT,
RIGHTARG = CITEXT,
NEGATOR = <,
COMMUTATOR = <=,
PROCEDURE = citext_ge,
RESTRICT = scalargtsel,
JOIN = scalargtjoinsel
);
CREATE OPERATOR > (
LEFTARG = CITEXT,
RIGHTARG = CITEXT,
NEGATOR = <=,
COMMUTATOR = <,
PROCEDURE = citext_gt,
RESTRICT = scalargtsel,
JOIN = scalargtjoinsel
);
--
-- Support functions for indexing.
--
CREATE FUNCTION citext_cmp(citext, citext)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION citext_hash(citext)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
--
-- The btree indexing operator class.
--
CREATE OPERATOR CLASS citext_ops
DEFAULT FOR TYPE CITEXT USING btree AS
OPERATOR 1 < (citext, citext),
OPERATOR 2 <= (citext, citext),
OPERATOR 3 = (citext, citext),
OPERATOR 4 >= (citext, citext),
OPERATOR 5 > (citext, citext),
FUNCTION 1 citext_cmp(citext, citext);
--
-- The hash indexing operator class.
--
CREATE OPERATOR CLASS citext_ops
DEFAULT FOR TYPE citext USING hash AS
OPERATOR 1 = (citext, citext),
FUNCTION 1 citext_hash(citext);
--
-- Aggregates.
--
CREATE FUNCTION citext_smaller(citext, citext)
RETURNS citext
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION citext_larger(citext, citext)
RETURNS citext
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE AGGREGATE min(citext) (
SFUNC = citext_smaller,
STYPE = citext,
SORTOP = <,
PARALLEL = SAFE,
COMBINEFUNC = citext_smaller
);
CREATE AGGREGATE max(citext) (
SFUNC = citext_larger,
STYPE = citext,
SORTOP = >,
PARALLEL = SAFE,
COMBINEFUNC = citext_larger
);
--
-- CITEXT pattern matching.
--
CREATE FUNCTION texticlike(citext, citext)
RETURNS bool AS 'texticlike'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION texticnlike(citext, citext)
RETURNS bool AS 'texticnlike'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION texticregexeq(citext, citext)
RETURNS bool AS 'texticregexeq'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION texticregexne(citext, citext)
RETURNS bool AS 'texticregexne'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
CREATE OPERATOR ~ (
PROCEDURE = texticregexeq,
LEFTARG = citext,
RIGHTARG = citext,
NEGATOR = !~,
RESTRICT = icregexeqsel,
JOIN = icregexeqjoinsel
);
CREATE OPERATOR ~* (
PROCEDURE = texticregexeq,
LEFTARG = citext,
RIGHTARG = citext,
NEGATOR = !~*,
RESTRICT = icregexeqsel,
JOIN = icregexeqjoinsel
);
CREATE OPERATOR !~ (
PROCEDURE = texticregexne,
LEFTARG = citext,
RIGHTARG = citext,
NEGATOR = ~,
RESTRICT = icregexnesel,
JOIN = icregexnejoinsel
);
CREATE OPERATOR !~* (
PROCEDURE = texticregexne,
LEFTARG = citext,
RIGHTARG = citext,
NEGATOR = ~*,
RESTRICT = icregexnesel,
JOIN = icregexnejoinsel
);
CREATE OPERATOR ~~ (
PROCEDURE = texticlike,
LEFTARG = citext,
RIGHTARG = citext,
NEGATOR = !~~,
RESTRICT = iclikesel,
JOIN = iclikejoinsel
);
CREATE OPERATOR ~~* (
PROCEDURE = texticlike,
LEFTARG = citext,
RIGHTARG = citext,
NEGATOR = !~~*,
RESTRICT = iclikesel,
JOIN = iclikejoinsel
);
CREATE OPERATOR !~~ (
PROCEDURE = texticnlike,
LEFTARG = citext,
RIGHTARG = citext,
NEGATOR = ~~,
RESTRICT = icnlikesel,
JOIN = icnlikejoinsel
);
CREATE OPERATOR !~~* (
PROCEDURE = texticnlike,
LEFTARG = citext,
RIGHTARG = citext,
NEGATOR = ~~*,
RESTRICT = icnlikesel,
JOIN = icnlikejoinsel
);
--
-- Matching citext to text.
--
CREATE FUNCTION texticlike(citext, text)
RETURNS bool AS 'texticlike'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION texticnlike(citext, text)
RETURNS bool AS 'texticnlike'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION texticregexeq(citext, text)
RETURNS bool AS 'texticregexeq'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION texticregexne(citext, text)
RETURNS bool AS 'texticregexne'
LANGUAGE internal IMMUTABLE STRICT PARALLEL SAFE;
CREATE OPERATOR ~ (
PROCEDURE = texticregexeq,
LEFTARG = citext,
RIGHTARG = text,
NEGATOR = !~,
RESTRICT = icregexeqsel,
JOIN = icregexeqjoinsel
);
CREATE OPERATOR ~* (
PROCEDURE = texticregexeq,
LEFTARG = citext,
RIGHTARG = text,
NEGATOR = !~*,
RESTRICT = icregexeqsel,
JOIN = icregexeqjoinsel
);
CREATE OPERATOR !~ (
PROCEDURE = texticregexne,
LEFTARG = citext,
RIGHTARG = text,
NEGATOR = ~,
RESTRICT = icregexnesel,
JOIN = icregexnejoinsel
);
CREATE OPERATOR !~* (
PROCEDURE = texticregexne,
LEFTARG = citext,
RIGHTARG = text,
NEGATOR = ~*,
RESTRICT = icregexnesel,
JOIN = icregexnejoinsel
);
CREATE OPERATOR ~~ (
PROCEDURE = texticlike,
LEFTARG = citext,
RIGHTARG = text,
NEGATOR = !~~,
RESTRICT = iclikesel,
JOIN = iclikejoinsel
);
CREATE OPERATOR ~~* (
PROCEDURE = texticlike,
LEFTARG = citext,
RIGHTARG = text,
NEGATOR = !~~*,
RESTRICT = iclikesel,
JOIN = iclikejoinsel
);
CREATE OPERATOR !~~ (
PROCEDURE = texticnlike,
LEFTARG = citext,
RIGHTARG = text,
NEGATOR = ~~,
RESTRICT = icnlikesel,
JOIN = icnlikejoinsel
);
CREATE OPERATOR !~~* (
PROCEDURE = texticnlike,
LEFTARG = citext,
RIGHTARG = text,
NEGATOR = ~~*,
RESTRICT = icnlikesel,
JOIN = icnlikejoinsel
);
--
-- Matching citext in string comparison functions.
-- XXX TODO Ideally these would be implemented in C.
--
CREATE FUNCTION regexp_match( citext, citext ) RETURNS TEXT[] AS $$
SELECT pg_catalog.regexp_match( $1::pg_catalog.text, $2::pg_catalog.text, 'i' );
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION regexp_match( citext, citext, text ) RETURNS TEXT[] AS $$
SELECT pg_catalog.regexp_match( $1::pg_catalog.text, $2::pg_catalog.text, CASE WHEN pg_catalog.strpos($3, 'c') = 0 THEN $3 || 'i' ELSE $3 END );
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION regexp_matches( citext, citext ) RETURNS SETOF TEXT[] AS $$
SELECT pg_catalog.regexp_matches( $1::pg_catalog.text, $2::pg_catalog.text, 'i' );
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE ROWS 1;
CREATE FUNCTION regexp_matches( citext, citext, text ) RETURNS SETOF TEXT[] AS $$
SELECT pg_catalog.regexp_matches( $1::pg_catalog.text, $2::pg_catalog.text, CASE WHEN pg_catalog.strpos($3, 'c') = 0 THEN $3 || 'i' ELSE $3 END );
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE ROWS 10;
CREATE FUNCTION regexp_replace( citext, citext, text ) returns TEXT AS $$
SELECT pg_catalog.regexp_replace( $1::pg_catalog.text, $2::pg_catalog.text, $3, 'i');
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION regexp_replace( citext, citext, text, text ) returns TEXT AS $$
SELECT pg_catalog.regexp_replace( $1::pg_catalog.text, $2::pg_catalog.text, $3, CASE WHEN pg_catalog.strpos($4, 'c') = 0 THEN $4 || 'i' ELSE $4 END);
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION regexp_split_to_array( citext, citext ) RETURNS TEXT[] AS $$
SELECT pg_catalog.regexp_split_to_array( $1::pg_catalog.text, $2::pg_catalog.text, 'i' );
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION regexp_split_to_array( citext, citext, text ) RETURNS TEXT[] AS $$
SELECT pg_catalog.regexp_split_to_array( $1::pg_catalog.text, $2::pg_catalog.text, CASE WHEN pg_catalog.strpos($3, 'c') = 0 THEN $3 || 'i' ELSE $3 END );
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION regexp_split_to_table( citext, citext ) RETURNS SETOF TEXT AS $$
SELECT pg_catalog.regexp_split_to_table( $1::pg_catalog.text, $2::pg_catalog.text, 'i' );
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION regexp_split_to_table( citext, citext, text ) RETURNS SETOF TEXT AS $$
SELECT pg_catalog.regexp_split_to_table( $1::pg_catalog.text, $2::pg_catalog.text, CASE WHEN pg_catalog.strpos($3, 'c') = 0 THEN $3 || 'i' ELSE $3 END );
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION strpos( citext, citext ) RETURNS INT AS $$
SELECT pg_catalog.strpos( pg_catalog.lower( $1::pg_catalog.text ), pg_catalog.lower( $2::pg_catalog.text ) );
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION replace( citext, citext, citext ) RETURNS TEXT AS $$
SELECT pg_catalog.regexp_replace( $1::pg_catalog.text, pg_catalog.regexp_replace($2::pg_catalog.text, '([^a-zA-Z_0-9])', E'\\\\\\1', 'g'), $3::pg_catalog.text, 'gi' );
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION split_part( citext, citext, int ) RETURNS TEXT AS $$
SELECT (pg_catalog.regexp_split_to_array( $1::pg_catalog.text, pg_catalog.regexp_replace($2::pg_catalog.text, '([^a-zA-Z_0-9])', E'\\\\\\1', 'g'), 'i'))[$3];
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION translate( citext, citext, text ) RETURNS TEXT AS $$
SELECT pg_catalog.translate( pg_catalog.translate( $1::pg_catalog.text, pg_catalog.lower($2::pg_catalog.text), $3), pg_catalog.upper($2::pg_catalog.text), $3);
$$ LANGUAGE SQL IMMUTABLE STRICT PARALLEL SAFE;

12
dist/win-x64/postgres-standalone/share/extension/citext--1.5--1.6.sql vendored Normal file
View File

@@ -0,0 +1,12 @@
/* contrib/citext/citext--1.5--1.6.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION citext UPDATE TO '1.6'" to load this file. \quit
CREATE FUNCTION citext_hash_extended(citext, int8)
RETURNS int8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
ALTER OPERATOR FAMILY citext_ops USING hash ADD
FUNCTION 2 citext_hash_extended(citext, int8);

6
dist/win-x64/postgres-standalone/share/extension/citext.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# citext extension
comment = 'data type for case-insensitive character strings'
default_version = '1.6'
module_pathname = '$libdir/citext'
relocatable = true
trusted = true

59
dist/win-x64/postgres-standalone/share/extension/cube--1.0--1.1.sql vendored Normal file
View File

@@ -0,0 +1,59 @@
/* contrib/cube/cube--1.0--1.1.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION cube UPDATE TO '1.1'" to load this file. \quit
CREATE FUNCTION distance_chebyshev(cube, cube)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION distance_taxicab(cube, cube)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION cube_coord(cube, int4)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION cube_coord_llur(cube, int4)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
CREATE OPERATOR -> (
LEFTARG = cube, RIGHTARG = int, PROCEDURE = cube_coord
);
CREATE OPERATOR ~> (
LEFTARG = cube, RIGHTARG = int, PROCEDURE = cube_coord_llur
);
CREATE OPERATOR <#> (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = distance_taxicab,
COMMUTATOR = '<#>'
);
CREATE OPERATOR <-> (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_distance,
COMMUTATOR = '<->'
);
CREATE OPERATOR <=> (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = distance_chebyshev,
COMMUTATOR = '<=>'
);
CREATE FUNCTION g_cube_distance (internal, cube, smallint, oid)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT;
ALTER OPERATOR FAMILY gist_cube_ops USING gist ADD
OPERATOR 15 ~> (cube, int) FOR ORDER BY float_ops,
OPERATOR 16 <#> (cube, cube) FOR ORDER BY float_ops,
OPERATOR 17 <-> (cube, cube) FOR ORDER BY float_ops,
OPERATOR 18 <=> (cube, cube) FOR ORDER BY float_ops,
FUNCTION 8 (cube, cube) g_cube_distance (internal, cube, smallint, oid);

75
dist/win-x64/postgres-standalone/share/extension/cube--1.1--1.2.sql vendored Normal file
View File

@@ -0,0 +1,75 @@
/* contrib/cube/cube--1.1--1.2.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION cube UPDATE TO '1.2'" to load this file. \quit
-- Update procedure signatures the hard way.
-- We use to_regprocedure() so that query doesn't fail if run against 9.6beta1 definitions,
-- wherein the signatures have been updated already. In that case to_regprocedure() will
-- return NULL and no updates will happen.
DO LANGUAGE plpgsql
$$
DECLARE
my_schema pg_catalog.text := pg_catalog.quote_ident(pg_catalog.current_schema());
old_path pg_catalog.text := pg_catalog.current_setting('search_path');
BEGIN
-- for safety, transiently set search_path to just pg_catalog+pg_temp
PERFORM pg_catalog.set_config('search_path', 'pg_catalog, pg_temp', true);
UPDATE pg_catalog.pg_proc SET
proargtypes = pg_catalog.array_to_string(newtypes::pg_catalog.oid[], ' ')::pg_catalog.oidvector,
pronargs = pg_catalog.array_length(newtypes, 1)
FROM (VALUES
(NULL::pg_catalog.text, NULL::pg_catalog.text[]), -- establish column types
('g_cube_consistent(internal,SCH.cube,int4,oid,internal)', '{internal,SCH.cube,int2,oid,internal}'),
('g_cube_distance(internal,SCH.cube,smallint,oid)', '{internal,SCH.cube,smallint,oid,internal}')
) AS update_data (oldproc, newtypestext),
LATERAL (
SELECT array_agg(replace(typ, 'SCH', my_schema)::regtype) as newtypes FROM unnest(newtypestext) typ
) ls
WHERE oid = to_regprocedure(my_schema || '.' || replace(oldproc, 'SCH', my_schema));
PERFORM pg_catalog.set_config('search_path', old_path, true);
END
$$;
ALTER FUNCTION cube_in(cstring) PARALLEL SAFE;
ALTER FUNCTION cube(float8[], float8[]) PARALLEL SAFE;
ALTER FUNCTION cube(float8[]) PARALLEL SAFE;
ALTER FUNCTION cube_out(cube) PARALLEL SAFE;
ALTER FUNCTION cube_eq(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_ne(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_lt(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_gt(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_le(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_ge(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_cmp(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_contains(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_contained(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_overlap(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_union(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_inter(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_size(cube) PARALLEL SAFE;
ALTER FUNCTION cube_subset(cube, int4[]) PARALLEL SAFE;
ALTER FUNCTION cube_distance(cube, cube) PARALLEL SAFE;
ALTER FUNCTION distance_chebyshev(cube, cube) PARALLEL SAFE;
ALTER FUNCTION distance_taxicab(cube, cube) PARALLEL SAFE;
ALTER FUNCTION cube_dim(cube) PARALLEL SAFE;
ALTER FUNCTION cube_ll_coord(cube, int4) PARALLEL SAFE;
ALTER FUNCTION cube_ur_coord(cube, int4) PARALLEL SAFE;
ALTER FUNCTION cube_coord(cube, int4) PARALLEL SAFE;
ALTER FUNCTION cube_coord_llur(cube, int4) PARALLEL SAFE;
ALTER FUNCTION cube(float8) PARALLEL SAFE;
ALTER FUNCTION cube(float8, float8) PARALLEL SAFE;
ALTER FUNCTION cube(cube, float8) PARALLEL SAFE;
ALTER FUNCTION cube(cube, float8, float8) PARALLEL SAFE;
ALTER FUNCTION cube_is_point(cube) PARALLEL SAFE;
ALTER FUNCTION cube_enlarge(cube, float8, int4) PARALLEL SAFE;
ALTER FUNCTION g_cube_consistent(internal, cube, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION g_cube_compress(internal) PARALLEL SAFE;
ALTER FUNCTION g_cube_decompress(internal) PARALLEL SAFE;
ALTER FUNCTION g_cube_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION g_cube_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION g_cube_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION g_cube_same(cube, cube, internal) PARALLEL SAFE;
ALTER FUNCTION g_cube_distance(internal, cube, smallint, oid, internal) PARALLEL SAFE;

12
dist/win-x64/postgres-standalone/share/extension/cube--1.2--1.3.sql vendored Normal file
View File

@@ -0,0 +1,12 @@
/* contrib/cube/cube--1.2--1.3.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION cube UPDATE TO '1.3'" to load this file. \quit
ALTER OPERATOR <= (cube, cube) SET (
RESTRICT = scalarlesel, JOIN = scalarlejoinsel
);
ALTER OPERATOR >= (cube, cube) SET (
RESTRICT = scalargesel, JOIN = scalargejoinsel
);

378
dist/win-x64/postgres-standalone/share/extension/cube--1.2.sql vendored Normal file
View File

@@ -0,0 +1,378 @@
/* contrib/cube/cube--1.2.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION cube" to load this file. \quit
-- Create the user-defined type for N-dimensional boxes
CREATE FUNCTION cube_in(cstring)
RETURNS cube
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube(float8[], float8[]) RETURNS cube
AS 'MODULE_PATHNAME', 'cube_a_f8_f8'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube(float8[]) RETURNS cube
AS 'MODULE_PATHNAME', 'cube_a_f8'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube_out(cube)
RETURNS cstring
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE TYPE cube (
INTERNALLENGTH = variable,
INPUT = cube_in,
OUTPUT = cube_out,
ALIGNMENT = double
);
COMMENT ON TYPE cube IS 'multi-dimensional cube ''(FLOAT-1, FLOAT-2, ..., FLOAT-N), (FLOAT-1, FLOAT-2, ..., FLOAT-N)''';
--
-- External C-functions for R-tree methods
--
-- Comparison methods
CREATE FUNCTION cube_eq(cube, cube)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
COMMENT ON FUNCTION cube_eq(cube, cube) IS 'same as';
CREATE FUNCTION cube_ne(cube, cube)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
COMMENT ON FUNCTION cube_ne(cube, cube) IS 'different';
CREATE FUNCTION cube_lt(cube, cube)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
COMMENT ON FUNCTION cube_lt(cube, cube) IS 'lower than';
CREATE FUNCTION cube_gt(cube, cube)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
COMMENT ON FUNCTION cube_gt(cube, cube) IS 'greater than';
CREATE FUNCTION cube_le(cube, cube)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
COMMENT ON FUNCTION cube_le(cube, cube) IS 'lower than or equal to';
CREATE FUNCTION cube_ge(cube, cube)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
COMMENT ON FUNCTION cube_ge(cube, cube) IS 'greater than or equal to';
CREATE FUNCTION cube_cmp(cube, cube)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
COMMENT ON FUNCTION cube_cmp(cube, cube) IS 'btree comparison function';
CREATE FUNCTION cube_contains(cube, cube)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
COMMENT ON FUNCTION cube_contains(cube, cube) IS 'contains';
CREATE FUNCTION cube_contained(cube, cube)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
COMMENT ON FUNCTION cube_contained(cube, cube) IS 'contained in';
CREATE FUNCTION cube_overlap(cube, cube)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
COMMENT ON FUNCTION cube_overlap(cube, cube) IS 'overlaps';
-- support routines for indexing
CREATE FUNCTION cube_union(cube, cube)
RETURNS cube
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube_inter(cube, cube)
RETURNS cube
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube_size(cube)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Misc N-dimensional functions
CREATE FUNCTION cube_subset(cube, int4[])
RETURNS cube
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- proximity routines
CREATE FUNCTION cube_distance(cube, cube)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION distance_chebyshev(cube, cube)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION distance_taxicab(cube, cube)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Extracting elements functions
CREATE FUNCTION cube_dim(cube)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube_ll_coord(cube, int4)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube_ur_coord(cube, int4)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube_coord(cube, int4)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube_coord_llur(cube, int4)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube(float8) RETURNS cube
AS 'MODULE_PATHNAME', 'cube_f8'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube(float8, float8) RETURNS cube
AS 'MODULE_PATHNAME', 'cube_f8_f8'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube(cube, float8) RETURNS cube
AS 'MODULE_PATHNAME', 'cube_c_f8'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube(cube, float8, float8) RETURNS cube
AS 'MODULE_PATHNAME', 'cube_c_f8_f8'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Test if cube is also a point
CREATE FUNCTION cube_is_point(cube)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Increasing the size of a cube by a radius in at least n dimensions
CREATE FUNCTION cube_enlarge(cube, float8, int4)
RETURNS cube
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
--
-- OPERATORS
--
CREATE OPERATOR < (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_lt,
COMMUTATOR = '>', NEGATOR = '>=',
RESTRICT = scalarltsel, JOIN = scalarltjoinsel
);
CREATE OPERATOR > (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_gt,
COMMUTATOR = '<', NEGATOR = '<=',
RESTRICT = scalargtsel, JOIN = scalargtjoinsel
);
CREATE OPERATOR <= (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_le,
COMMUTATOR = '>=', NEGATOR = '>',
RESTRICT = scalarltsel, JOIN = scalarltjoinsel
);
CREATE OPERATOR >= (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_ge,
COMMUTATOR = '<=', NEGATOR = '<',
RESTRICT = scalargtsel, JOIN = scalargtjoinsel
);
CREATE OPERATOR && (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_overlap,
COMMUTATOR = '&&',
RESTRICT = areasel, JOIN = areajoinsel
);
CREATE OPERATOR = (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_eq,
COMMUTATOR = '=', NEGATOR = '<>',
RESTRICT = eqsel, JOIN = eqjoinsel,
MERGES
);
CREATE OPERATOR <> (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_ne,
COMMUTATOR = '<>', NEGATOR = '=',
RESTRICT = neqsel, JOIN = neqjoinsel
);
CREATE OPERATOR @> (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_contains,
COMMUTATOR = '<@',
RESTRICT = contsel, JOIN = contjoinsel
);
CREATE OPERATOR <@ (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_contained,
COMMUTATOR = '@>',
RESTRICT = contsel, JOIN = contjoinsel
);
CREATE OPERATOR -> (
LEFTARG = cube, RIGHTARG = int, PROCEDURE = cube_coord
);
CREATE OPERATOR ~> (
LEFTARG = cube, RIGHTARG = int, PROCEDURE = cube_coord_llur
);
CREATE OPERATOR <#> (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = distance_taxicab,
COMMUTATOR = '<#>'
);
CREATE OPERATOR <-> (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_distance,
COMMUTATOR = '<->'
);
CREATE OPERATOR <=> (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = distance_chebyshev,
COMMUTATOR = '<=>'
);
-- these are obsolete/deprecated:
CREATE OPERATOR @ (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_contains,
COMMUTATOR = '~',
RESTRICT = contsel, JOIN = contjoinsel
);
CREATE OPERATOR ~ (
LEFTARG = cube, RIGHTARG = cube, PROCEDURE = cube_contained,
COMMUTATOR = '@',
RESTRICT = contsel, JOIN = contjoinsel
);
-- define the GiST support methods
CREATE FUNCTION g_cube_consistent(internal,cube,smallint,oid,internal)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_cube_compress(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_cube_decompress(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_cube_penalty(internal,internal,internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_cube_picksplit(internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_cube_union(internal, internal)
RETURNS cube
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_cube_same(cube, cube, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_cube_distance (internal, cube, smallint, oid, internal)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Create the operator classes for indexing
CREATE OPERATOR CLASS cube_ops
DEFAULT FOR TYPE cube USING btree AS
OPERATOR 1 < ,
OPERATOR 2 <= ,
OPERATOR 3 = ,
OPERATOR 4 >= ,
OPERATOR 5 > ,
FUNCTION 1 cube_cmp(cube, cube);
CREATE OPERATOR CLASS gist_cube_ops
DEFAULT FOR TYPE cube USING gist AS
OPERATOR 3 && ,
OPERATOR 6 = ,
OPERATOR 7 @> ,
OPERATOR 8 <@ ,
OPERATOR 13 @ ,
OPERATOR 14 ~ ,
OPERATOR 15 ~> (cube, int) FOR ORDER BY float_ops,
OPERATOR 16 <#> (cube, cube) FOR ORDER BY float_ops,
OPERATOR 17 <-> (cube, cube) FOR ORDER BY float_ops,
OPERATOR 18 <=> (cube, cube) FOR ORDER BY float_ops,
FUNCTION 1 g_cube_consistent (internal, cube, smallint, oid, internal),
FUNCTION 2 g_cube_union (internal, internal),
FUNCTION 3 g_cube_compress (internal),
FUNCTION 4 g_cube_decompress (internal),
FUNCTION 5 g_cube_penalty (internal, internal, internal),
FUNCTION 6 g_cube_picksplit (internal, internal),
FUNCTION 7 g_cube_same (cube, cube, internal),
FUNCTION 8 g_cube_distance (internal, cube, smallint, oid, internal);

58
dist/win-x64/postgres-standalone/share/extension/cube--1.3--1.4.sql vendored Normal file
View File

@@ -0,0 +1,58 @@
/* contrib/cube/cube--1.3--1.4.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION cube UPDATE TO '1.4'" to load this file. \quit
--
-- Get rid of unnecessary compress and decompress support functions.
--
-- To be allowed to drop the opclass entry for a support function,
-- we must change the entry's dependency type from 'internal' to 'auto',
-- as though it were a loose member of the opfamily rather than being
-- bound into a particular opclass. There's no SQL command for that,
-- so fake it with a manual update on pg_depend.
--
DO LANGUAGE plpgsql
$$
DECLARE
my_schema pg_catalog.text := pg_catalog.quote_ident(pg_catalog.current_schema());
old_path pg_catalog.text := pg_catalog.current_setting('search_path');
BEGIN
-- for safety, transiently set search_path to just pg_catalog+pg_temp
PERFORM pg_catalog.set_config('search_path', 'pg_catalog, pg_temp', true);
UPDATE pg_catalog.pg_depend
SET deptype = 'a'
WHERE classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass
AND objid =
(SELECT objid
FROM pg_catalog.pg_depend
WHERE classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass
AND refclassid = 'pg_catalog.pg_proc'::pg_catalog.regclass
AND (refobjid = (my_schema || '.g_cube_compress(pg_catalog.internal)')::pg_catalog.regprocedure))
AND refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass
AND deptype = 'i';
UPDATE pg_catalog.pg_depend
SET deptype = 'a'
WHERE classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass
AND objid =
(SELECT objid
FROM pg_catalog.pg_depend
WHERE classid = 'pg_catalog.pg_amproc'::pg_catalog.regclass
AND refclassid = 'pg_catalog.pg_proc'::pg_catalog.regclass
AND (refobjid = (my_schema || '.g_cube_decompress(pg_catalog.internal)')::pg_catalog.regprocedure))
AND refclassid = 'pg_catalog.pg_opclass'::pg_catalog.regclass
AND deptype = 'i';
PERFORM pg_catalog.set_config('search_path', old_path, true);
END
$$;
ALTER OPERATOR FAMILY gist_cube_ops USING gist drop function 3 (cube);
ALTER EXTENSION cube DROP function g_cube_compress(pg_catalog.internal);
DROP FUNCTION g_cube_compress(pg_catalog.internal);
ALTER OPERATOR FAMILY gist_cube_ops USING gist drop function 4 (cube);
ALTER EXTENSION cube DROP function g_cube_decompress(pg_catalog.internal);
DROP FUNCTION g_cube_decompress(pg_catalog.internal);

21
dist/win-x64/postgres-standalone/share/extension/cube--1.4--1.5.sql vendored Normal file
View File

@@ -0,0 +1,21 @@
/* contrib/cube/cube--1.4--1.5.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION cube UPDATE TO '1.5'" to load this file. \quit
-- Remove @ and ~
DROP OPERATOR @ (cube, cube);
DROP OPERATOR ~ (cube, cube);
-- Add binary input/output handlers
CREATE FUNCTION cube_recv(internal)
RETURNS cube
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION cube_send(cube)
RETURNS bytea
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
ALTER TYPE cube SET ( RECEIVE = cube_recv, SEND = cube_send );

6
dist/win-x64/postgres-standalone/share/extension/cube.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# cube extension
comment = 'data type for multidimensional cubes'
default_version = '1.5'
module_pathname = '$libdir/cube'
relocatable = true
trusted = true

14
dist/win-x64/postgres-standalone/share/extension/dblink--1.0--1.1.sql vendored Normal file
View File

@@ -0,0 +1,14 @@
/* contrib/dblink/dblink--1.0--1.1.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION dblink UPDATE TO '1.1'" to load this file. \quit
CREATE FUNCTION dblink_fdw_validator(
options text[],
catalog oid
)
RETURNS void
AS 'MODULE_PATHNAME', 'dblink_fdw_validator'
LANGUAGE C STRICT;
CREATE FOREIGN DATA WRAPPER dblink_fdw VALIDATOR dblink_fdw_validator;

46
dist/win-x64/postgres-standalone/share/extension/dblink--1.1--1.2.sql vendored Normal file
View File

@@ -0,0 +1,46 @@
/* contrib/dblink/dblink--1.1--1.2.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION dblink UPDATE TO '1.2'" to load this file. \quit
ALTER FUNCTION dblink_connect(text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_connect(text, text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_connect_u(text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_connect_u(text, text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_disconnect() PARALLEL RESTRICTED;
ALTER FUNCTION dblink_disconnect(text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_open(text, text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_open(text, text, boolean) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_open(text, text, text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_open(text, text, text, boolean) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_fetch(text, int) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_fetch(text, int, boolean) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_fetch(text, text, int) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_fetch(text, text, int, boolean) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_close(text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_close(text, boolean) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_close(text, text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_close(text, text, boolean) PARALLEL RESTRICTED;
ALTER FUNCTION dblink(text, text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink(text, text, boolean) PARALLEL RESTRICTED;
ALTER FUNCTION dblink(text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink(text, boolean) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_exec(text, text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_exec(text, text, boolean) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_exec(text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_exec(text, boolean) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_get_pkey(text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_build_sql_insert(text, int2vector, int, _text, _text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_build_sql_delete(text, int2vector, int, _text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_build_sql_update(text, int2vector, int, _text, _text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_current_query() PARALLEL RESTRICTED;
ALTER FUNCTION dblink_send_query(text, text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_is_busy(text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_get_result(text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_get_result(text, bool) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_get_connections() PARALLEL RESTRICTED;
ALTER FUNCTION dblink_cancel_query(text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_error_message(text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_get_notify() PARALLEL RESTRICTED;
ALTER FUNCTION dblink_get_notify(text) PARALLEL RESTRICTED;
ALTER FUNCTION dblink_fdw_validator(text[], oid) PARALLEL SAFE;

235
dist/win-x64/postgres-standalone/share/extension/dblink--1.2.sql vendored Normal file
View File

@@ -0,0 +1,235 @@
/* contrib/dblink/dblink--1.2.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION dblink" to load this file. \quit
-- dblink_connect now restricts non-superusers to password
-- authenticated connections
CREATE FUNCTION dblink_connect (text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_connect'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_connect (text, text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_connect'
LANGUAGE C STRICT PARALLEL RESTRICTED;
-- dblink_connect_u allows non-superusers to use
-- non-password authenticated connections, but initially
-- privileges are revoked from public
CREATE FUNCTION dblink_connect_u (text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_connect'
LANGUAGE C STRICT PARALLEL RESTRICTED SECURITY DEFINER;
CREATE FUNCTION dblink_connect_u (text, text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_connect'
LANGUAGE C STRICT PARALLEL RESTRICTED SECURITY DEFINER;
REVOKE ALL ON FUNCTION dblink_connect_u (text) FROM public;
REVOKE ALL ON FUNCTION dblink_connect_u (text, text) FROM public;
CREATE FUNCTION dblink_disconnect ()
RETURNS text
AS 'MODULE_PATHNAME','dblink_disconnect'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_disconnect (text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_disconnect'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_open (text, text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_open'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_open (text, text, boolean)
RETURNS text
AS 'MODULE_PATHNAME','dblink_open'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_open (text, text, text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_open'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_open (text, text, text, boolean)
RETURNS text
AS 'MODULE_PATHNAME','dblink_open'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_fetch (text, int)
RETURNS setof record
AS 'MODULE_PATHNAME','dblink_fetch'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_fetch (text, int, boolean)
RETURNS setof record
AS 'MODULE_PATHNAME','dblink_fetch'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_fetch (text, text, int)
RETURNS setof record
AS 'MODULE_PATHNAME','dblink_fetch'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_fetch (text, text, int, boolean)
RETURNS setof record
AS 'MODULE_PATHNAME','dblink_fetch'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_close (text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_close'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_close (text, boolean)
RETURNS text
AS 'MODULE_PATHNAME','dblink_close'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_close (text, text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_close'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_close (text, text, boolean)
RETURNS text
AS 'MODULE_PATHNAME','dblink_close'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink (text, text)
RETURNS setof record
AS 'MODULE_PATHNAME','dblink_record'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink (text, text, boolean)
RETURNS setof record
AS 'MODULE_PATHNAME','dblink_record'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink (text)
RETURNS setof record
AS 'MODULE_PATHNAME','dblink_record'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink (text, boolean)
RETURNS setof record
AS 'MODULE_PATHNAME','dblink_record'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_exec (text, text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_exec'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_exec (text, text, boolean)
RETURNS text
AS 'MODULE_PATHNAME','dblink_exec'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_exec (text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_exec'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_exec (text,boolean)
RETURNS text
AS 'MODULE_PATHNAME','dblink_exec'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE TYPE dblink_pkey_results AS (position int, colname text);
CREATE FUNCTION dblink_get_pkey (text)
RETURNS setof dblink_pkey_results
AS 'MODULE_PATHNAME','dblink_get_pkey'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_build_sql_insert (text, int2vector, int, _text, _text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_build_sql_insert'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_build_sql_delete (text, int2vector, int, _text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_build_sql_delete'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_build_sql_update (text, int2vector, int, _text, _text)
RETURNS text
AS 'MODULE_PATHNAME','dblink_build_sql_update'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_current_query ()
RETURNS text
AS 'MODULE_PATHNAME','dblink_current_query'
LANGUAGE C PARALLEL RESTRICTED;
CREATE FUNCTION dblink_send_query(text, text)
RETURNS int4
AS 'MODULE_PATHNAME', 'dblink_send_query'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_is_busy(text)
RETURNS int4
AS 'MODULE_PATHNAME', 'dblink_is_busy'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_get_result(text)
RETURNS SETOF record
AS 'MODULE_PATHNAME', 'dblink_get_result'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_get_result(text, bool)
RETURNS SETOF record
AS 'MODULE_PATHNAME', 'dblink_get_result'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_get_connections()
RETURNS text[]
AS 'MODULE_PATHNAME', 'dblink_get_connections'
LANGUAGE C PARALLEL RESTRICTED;
CREATE FUNCTION dblink_cancel_query(text)
RETURNS text
AS 'MODULE_PATHNAME', 'dblink_cancel_query'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_error_message(text)
RETURNS text
AS 'MODULE_PATHNAME', 'dblink_error_message'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_get_notify(
OUT notify_name TEXT,
OUT be_pid INT4,
OUT extra TEXT
)
RETURNS setof record
AS 'MODULE_PATHNAME', 'dblink_get_notify'
LANGUAGE C STRICT PARALLEL RESTRICTED;
CREATE FUNCTION dblink_get_notify(
conname TEXT,
OUT notify_name TEXT,
OUT be_pid INT4,
OUT extra TEXT
)
RETURNS setof record
AS 'MODULE_PATHNAME', 'dblink_get_notify'
LANGUAGE C STRICT PARALLEL RESTRICTED;
/* New stuff in 1.1 begins here */
CREATE FUNCTION dblink_fdw_validator(
options text[],
catalog oid
)
RETURNS void
AS 'MODULE_PATHNAME', 'dblink_fdw_validator'
LANGUAGE C STRICT PARALLEL SAFE;
CREATE FOREIGN DATA WRAPPER dblink_fdw VALIDATOR dblink_fdw_validator;

5
dist/win-x64/postgres-standalone/share/extension/dblink.control vendored Normal file
View File

@@ -0,0 +1,5 @@
# dblink extension
comment = 'connect to other PostgreSQL databases from within a database'
default_version = '1.2'
module_pathname = '$libdir/dblink'
relocatable = true

25
dist/win-x64/postgres-standalone/share/extension/dict_int--1.0.sql vendored Normal file
View File

@@ -0,0 +1,25 @@
/* contrib/dict_int/dict_int--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION dict_int" to load this file. \quit
CREATE FUNCTION dintdict_init(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT;
CREATE FUNCTION dintdict_lexize(internal, internal, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT;
CREATE TEXT SEARCH TEMPLATE intdict_template (
LEXIZE = dintdict_lexize,
INIT = dintdict_init
);
CREATE TEXT SEARCH DICTIONARY intdict (
TEMPLATE = intdict_template
);
COMMENT ON TEXT SEARCH DICTIONARY intdict IS 'dictionary for integers';

6
dist/win-x64/postgres-standalone/share/extension/dict_int.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# dict_int extension
comment = 'text search dictionary template for integers'
default_version = '1.0'
module_pathname = '$libdir/dict_int'
relocatable = true
trusted = true

25
dist/win-x64/postgres-standalone/share/extension/dict_xsyn--1.0.sql vendored Normal file
View File

@@ -0,0 +1,25 @@
/* contrib/dict_xsyn/dict_xsyn--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION dict_xsyn" to load this file. \quit
CREATE FUNCTION dxsyn_init(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT;
CREATE FUNCTION dxsyn_lexize(internal, internal, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT;
CREATE TEXT SEARCH TEMPLATE xsyn_template (
LEXIZE = dxsyn_lexize,
INIT = dxsyn_init
);
CREATE TEXT SEARCH DICTIONARY xsyn (
TEMPLATE = xsyn_template
);
COMMENT ON TEXT SEARCH DICTIONARY xsyn IS 'eXtended synonym dictionary';

5
dist/win-x64/postgres-standalone/share/extension/dict_xsyn.control vendored Normal file
View File

@@ -0,0 +1,5 @@
# dict_xsyn extension
comment = 'text search dictionary template for extended synonym processing'
default_version = '1.0'
module_pathname = '$libdir/dict_xsyn'
relocatable = true

19
dist/win-x64/postgres-standalone/share/extension/dummy_index_am--1.0.sql vendored Normal file
View File

@@ -0,0 +1,19 @@
/* src/test/modules/dummy_index_am/dummy_index_am--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION dummy_index_am" to load this file. \quit
CREATE FUNCTION dihandler(internal)
RETURNS index_am_handler
AS 'MODULE_PATHNAME'
LANGUAGE C;
-- Access method
CREATE ACCESS METHOD dummy_index_am TYPE INDEX HANDLER dihandler;
COMMENT ON ACCESS METHOD dummy_index_am IS 'dummy index access method';
-- Operator classes
CREATE OPERATOR CLASS int4_ops
DEFAULT FOR TYPE int4 USING dummy_index_am AS
OPERATOR 1 = (int4, int4),
FUNCTION 1 hashint4(int4);

5
dist/win-x64/postgres-standalone/share/extension/dummy_index_am.control vendored Normal file
View File

@@ -0,0 +1,5 @@
# dummy_index_am extension
comment = 'dummy_index_am - index access method template'
default_version = '1.0'
module_pathname = '$libdir/dummy_index_am'
relocatable = true

14
dist/win-x64/postgres-standalone/share/extension/earthdistance--1.0--1.1.sql vendored Normal file
View File

@@ -0,0 +1,14 @@
/* contrib/earthdistance/earthdistance--1.0--1.1.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION earthdistance UPDATE TO '1.1'" to load this file. \quit
ALTER FUNCTION earth() PARALLEL SAFE;
ALTER FUNCTION sec_to_gc(float8) PARALLEL SAFE;
ALTER FUNCTION gc_to_sec(float8) PARALLEL SAFE;
ALTER FUNCTION ll_to_earth(float8, float8) PARALLEL SAFE;
ALTER FUNCTION latitude(earth) PARALLEL SAFE;
ALTER FUNCTION longitude(earth) PARALLEL SAFE;
ALTER FUNCTION earth_distance(earth, earth) PARALLEL SAFE;
ALTER FUNCTION earth_box(earth, float8) PARALLEL SAFE;
ALTER FUNCTION geo_distance(point, point) PARALLEL SAFE;

98
dist/win-x64/postgres-standalone/share/extension/earthdistance--1.1.sql vendored Normal file
View File

@@ -0,0 +1,98 @@
/* contrib/earthdistance/earthdistance--1.1.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION earthdistance" to load this file. \quit
-- earth() returns the radius of the earth in meters. This is the only
-- place you need to change things for the cube base distance functions
-- in order to use different units (or a better value for the Earth's radius).
CREATE FUNCTION earth() RETURNS float8
LANGUAGE SQL IMMUTABLE PARALLEL SAFE
AS 'SELECT ''6378168''::float8';
-- Astronomers may want to change the earth function so that distances will be
-- returned in degrees. To do this comment out the above definition and
-- uncomment the one below. Note that doing this will break the regression
-- tests.
--
-- CREATE FUNCTION earth() RETURNS float8
-- LANGUAGE SQL IMMUTABLE
-- AS 'SELECT 180/pi()';
-- Define domain for locations on the surface of the earth using a cube
-- datatype with constraints. cube provides 3D indexing.
-- The cube is restricted to be a point, no more than 3 dimensions
-- (for less than 3 dimensions 0 is assumed for the missing coordinates)
-- and that the point must be very near the surface of the sphere
-- centered about the origin with the radius of the earth.
CREATE DOMAIN earth AS cube
CONSTRAINT not_point check(cube_is_point(value))
CONSTRAINT not_3d check(cube_dim(value) <= 3)
CONSTRAINT on_surface check(abs(cube_distance(value, '(0)'::cube) /
earth() - '1'::float8) < '10e-7'::float8);
CREATE FUNCTION sec_to_gc(float8)
RETURNS float8
LANGUAGE SQL
IMMUTABLE STRICT
PARALLEL SAFE
AS 'SELECT CASE WHEN $1 < 0 THEN 0::float8 WHEN $1/(2*earth()) > 1 THEN pi()*earth() ELSE 2*earth()*asin($1/(2*earth())) END';
CREATE FUNCTION gc_to_sec(float8)
RETURNS float8
LANGUAGE SQL
IMMUTABLE STRICT
PARALLEL SAFE
AS 'SELECT CASE WHEN $1 < 0 THEN 0::float8 WHEN $1/earth() > pi() THEN 2*earth() ELSE 2*earth()*sin($1/(2*earth())) END';
CREATE FUNCTION ll_to_earth(float8, float8)
RETURNS earth
LANGUAGE SQL
IMMUTABLE STRICT
PARALLEL SAFE
AS 'SELECT cube(cube(cube(earth()*cos(radians($1))*cos(radians($2))),earth()*cos(radians($1))*sin(radians($2))),earth()*sin(radians($1)))::earth';
CREATE FUNCTION latitude(earth)
RETURNS float8
LANGUAGE SQL
IMMUTABLE STRICT
PARALLEL SAFE
AS 'SELECT CASE WHEN cube_ll_coord($1, 3)/earth() < -1 THEN -90::float8 WHEN cube_ll_coord($1, 3)/earth() > 1 THEN 90::float8 ELSE degrees(asin(cube_ll_coord($1, 3)/earth())) END';
CREATE FUNCTION longitude(earth)
RETURNS float8
LANGUAGE SQL
IMMUTABLE STRICT
PARALLEL SAFE
AS 'SELECT degrees(atan2(cube_ll_coord($1, 2), cube_ll_coord($1, 1)))';
CREATE FUNCTION earth_distance(earth, earth)
RETURNS float8
LANGUAGE SQL
IMMUTABLE STRICT
PARALLEL SAFE
AS 'SELECT sec_to_gc(cube_distance($1, $2))';
CREATE FUNCTION earth_box(earth, float8)
RETURNS cube
LANGUAGE SQL
IMMUTABLE STRICT
PARALLEL SAFE
AS 'SELECT cube_enlarge($1, gc_to_sec($2), 3)';
--------------- geo_distance
CREATE FUNCTION geo_distance (point, point)
RETURNS float8
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE AS 'MODULE_PATHNAME';
--------------- geo_distance as operator <@>
CREATE OPERATOR <@> (
LEFTARG = point,
RIGHTARG = point,
PROCEDURE = geo_distance,
COMMUTATOR = <@>
);

6
dist/win-x64/postgres-standalone/share/extension/earthdistance.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# earthdistance extension
comment = 'calculate great-circle distances on the surface of the Earth'
default_version = '1.1'
module_pathname = '$libdir/earthdistance'
relocatable = true
requires = 'cube'

18
dist/win-x64/postgres-standalone/share/extension/file_fdw--1.0.sql vendored Normal file
View File

@@ -0,0 +1,18 @@
/* contrib/file_fdw/file_fdw--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION file_fdw" to load this file. \quit
CREATE FUNCTION file_fdw_handler()
RETURNS fdw_handler
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT;
CREATE FUNCTION file_fdw_validator(text[], oid)
RETURNS void
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT;
CREATE FOREIGN DATA WRAPPER file_fdw
HANDLER file_fdw_handler
VALIDATOR file_fdw_validator;

5
dist/win-x64/postgres-standalone/share/extension/file_fdw.control vendored Normal file
View File

@@ -0,0 +1,5 @@
# file_fdw extension
comment = 'foreign-data wrapper for flat file access'
default_version = '1.0'
module_pathname = '$libdir/file_fdw'
relocatable = true

15
dist/win-x64/postgres-standalone/share/extension/fuzzystrmatch--1.0--1.1.sql vendored Normal file
View File

@@ -0,0 +1,15 @@
/* contrib/fuzzystrmatch/fuzzystrmatch--1.0--1.1.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION fuzzystrmatch UPDATE TO '1.1'" to load this file. \quit
ALTER FUNCTION levenshtein(text, text) PARALLEL SAFE;
ALTER FUNCTION levenshtein(text, text, int, int, int) PARALLEL SAFE;
ALTER FUNCTION levenshtein_less_equal(text, text, int) PARALLEL SAFE;
ALTER FUNCTION levenshtein_less_equal(text, text, int, int, int, int) PARALLEL SAFE;
ALTER FUNCTION metaphone(text, int) PARALLEL SAFE;
ALTER FUNCTION soundex(text) PARALLEL SAFE;
ALTER FUNCTION text_soundex(text) PARALLEL SAFE;
ALTER FUNCTION difference(text, text) PARALLEL SAFE;
ALTER FUNCTION dmetaphone(text) PARALLEL SAFE;
ALTER FUNCTION dmetaphone_alt(text) PARALLEL SAFE;

44
dist/win-x64/postgres-standalone/share/extension/fuzzystrmatch--1.1.sql vendored Normal file
View File

@@ -0,0 +1,44 @@
/* contrib/fuzzystrmatch/fuzzystrmatch--1.1.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION fuzzystrmatch" to load this file. \quit
CREATE FUNCTION levenshtein (text,text) RETURNS int
AS 'MODULE_PATHNAME','levenshtein'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION levenshtein (text,text,int,int,int) RETURNS int
AS 'MODULE_PATHNAME','levenshtein_with_costs'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION levenshtein_less_equal (text,text,int) RETURNS int
AS 'MODULE_PATHNAME','levenshtein_less_equal'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION levenshtein_less_equal (text,text,int,int,int,int) RETURNS int
AS 'MODULE_PATHNAME','levenshtein_less_equal_with_costs'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION metaphone (text,int) RETURNS text
AS 'MODULE_PATHNAME','metaphone'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION soundex(text) RETURNS text
AS 'MODULE_PATHNAME', 'soundex'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION text_soundex(text) RETURNS text
AS 'MODULE_PATHNAME', 'soundex'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION difference(text,text) RETURNS int
AS 'MODULE_PATHNAME', 'difference'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION dmetaphone (text) RETURNS text
AS 'MODULE_PATHNAME', 'dmetaphone'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION dmetaphone_alt (text) RETURNS text
AS 'MODULE_PATHNAME', 'dmetaphone_alt'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;

6
dist/win-x64/postgres-standalone/share/extension/fuzzystrmatch.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# fuzzystrmatch extension
comment = 'determine similarities and distance between strings'
default_version = '1.1'
module_pathname = '$libdir/fuzzystrmatch'
relocatable = true
trusted = true

53
dist/win-x64/postgres-standalone/share/extension/hstore--1.1--1.2.sql vendored Normal file
View File

@@ -0,0 +1,53 @@
/* contrib/hstore/hstore--1.1--1.2.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION hstore UPDATE TO '1.2'" to load this file. \quit
-- A version of 1.1 was shipped with these objects mistakenly in 9.3.0.
-- Therefore we only add them if we detect that they aren't already there and
-- dependent on the extension.
DO LANGUAGE plpgsql
$$
DECLARE
my_schema pg_catalog.text := pg_catalog.quote_ident(pg_catalog.current_schema());
old_path pg_catalog.text := pg_catalog.current_setting('search_path');
BEGIN
-- for safety, transiently set search_path to just pg_catalog+pg_temp
PERFORM pg_catalog.set_config('search_path', 'pg_catalog, pg_temp', true);
PERFORM 1
FROM pg_proc p
JOIN pg_depend d
ON p.proname = 'hstore_to_json_loose'
AND d.classid = 'pg_proc'::regclass
AND d.objid = p.oid
AND d.refclassid = 'pg_extension'::regclass
JOIN pg_extension x
ON d.refobjid = x.oid
AND x.extname = 'hstore';
IF NOT FOUND
THEN
PERFORM pg_catalog.set_config('search_path', old_path, true);
CREATE FUNCTION hstore_to_json(hstore)
RETURNS json
AS 'MODULE_PATHNAME', 'hstore_to_json'
LANGUAGE C IMMUTABLE STRICT;
CREATE CAST (hstore AS json)
WITH FUNCTION hstore_to_json(hstore);
CREATE FUNCTION hstore_to_json_loose(hstore)
RETURNS json
AS 'MODULE_PATHNAME', 'hstore_to_json_loose'
LANGUAGE C IMMUTABLE STRICT;
END IF;
PERFORM pg_catalog.set_config('search_path', old_path, true);
END;
$$;

17
dist/win-x64/postgres-standalone/share/extension/hstore--1.2--1.3.sql vendored Normal file
View File

@@ -0,0 +1,17 @@
/* contrib/hstore/hstore--1.2--1.3.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION hstore UPDATE TO '1.3'" to load this file. \quit
CREATE FUNCTION hstore_to_jsonb(hstore)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'hstore_to_jsonb'
LANGUAGE C IMMUTABLE STRICT;
CREATE CAST (hstore AS jsonb)
WITH FUNCTION hstore_to_jsonb(hstore);
CREATE FUNCTION hstore_to_jsonb_loose(hstore)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'hstore_to_jsonb_loose'
LANGUAGE C IMMUTABLE STRICT;

99
dist/win-x64/postgres-standalone/share/extension/hstore--1.3--1.4.sql vendored Normal file
View File

@@ -0,0 +1,99 @@
/* contrib/hstore/hstore--1.3--1.4.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION hstore UPDATE TO '1.4'" to load this file. \quit
-- Update procedure signatures the hard way.
-- We use to_regprocedure() so that query doesn't fail if run against 9.6beta1 definitions,
-- wherein the signatures have been updated already. In that case to_regprocedure() will
-- return NULL and no updates will happen.
DO LANGUAGE plpgsql
$$
DECLARE
my_schema pg_catalog.text := pg_catalog.quote_ident(pg_catalog.current_schema());
old_path pg_catalog.text := pg_catalog.current_setting('search_path');
BEGIN
-- for safety, transiently set search_path to just pg_catalog+pg_temp
PERFORM pg_catalog.set_config('search_path', 'pg_catalog, pg_temp', true);
UPDATE pg_catalog.pg_proc SET
proargtypes = pg_catalog.array_to_string(newtypes::pg_catalog.oid[], ' ')::pg_catalog.oidvector,
pronargs = pg_catalog.array_length(newtypes, 1)
FROM (VALUES
(NULL::pg_catalog.text, NULL::pg_catalog.text[]), -- establish column types
('ghstore_same(internal,internal,internal)', '{SCH.ghstore,SCH.ghstore,internal}'),
('ghstore_consistent(internal,internal,int4,oid,internal)', '{internal,SCH.hstore,int2,oid,internal}'),
('gin_extract_hstore(internal,internal)', '{SCH.hstore,internal}'),
('gin_extract_hstore_query(internal,internal,int2,internal,internal)', '{SCH.hstore,internal,int2,internal,internal}'),
('gin_consistent_hstore(internal,int2,internal,int4,internal,internal)', '{internal,int2,SCH.hstore,int4,internal,internal}')
) AS update_data (oldproc, newtypestext),
LATERAL (
SELECT array_agg(replace(typ, 'SCH', my_schema)::regtype) as newtypes FROM unnest(newtypestext) typ
) ls
WHERE oid = to_regprocedure(my_schema || '.' || replace(oldproc, 'SCH', my_schema));
UPDATE pg_catalog.pg_proc SET
prorettype = (my_schema || '.ghstore')::pg_catalog.regtype
WHERE oid = pg_catalog.to_regprocedure((my_schema || '.ghstore_union(internal,internal)'));
PERFORM pg_catalog.set_config('search_path', old_path, true);
END
$$;
ALTER FUNCTION hstore_in(cstring) PARALLEL SAFE;
ALTER FUNCTION hstore_out(hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_recv(internal) PARALLEL SAFE;
ALTER FUNCTION hstore_send(hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_version_diag(hstore) PARALLEL SAFE;
ALTER FUNCTION fetchval(hstore, text) PARALLEL SAFE;
ALTER FUNCTION slice_array(hstore, text[]) PARALLEL SAFE;
ALTER FUNCTION slice(hstore, text[]) PARALLEL SAFE;
ALTER FUNCTION isexists(hstore, text) PARALLEL SAFE;
ALTER FUNCTION exist(hstore, text) PARALLEL SAFE;
ALTER FUNCTION exists_any(hstore, text[]) PARALLEL SAFE;
ALTER FUNCTION exists_all(hstore, text[]) PARALLEL SAFE;
ALTER FUNCTION isdefined(hstore, text) PARALLEL SAFE;
ALTER FUNCTION defined(hstore, text) PARALLEL SAFE;
ALTER FUNCTION delete(hstore, text) PARALLEL SAFE;
ALTER FUNCTION delete(hstore, text[]) PARALLEL SAFE;
ALTER FUNCTION delete(hstore, hstore) PARALLEL SAFE;
ALTER FUNCTION hs_concat(hstore, hstore) PARALLEL SAFE;
ALTER FUNCTION hs_contains(hstore, hstore) PARALLEL SAFE;
ALTER FUNCTION hs_contained(hstore, hstore) PARALLEL SAFE;
ALTER FUNCTION tconvert(text, text) PARALLEL SAFE;
ALTER FUNCTION hstore(text, text) PARALLEL SAFE;
ALTER FUNCTION hstore(text[], text[]) PARALLEL SAFE;
ALTER FUNCTION hstore(text[]) PARALLEL SAFE;
ALTER FUNCTION hstore_to_json(hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_to_json_loose(hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_to_jsonb(hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_to_jsonb_loose(hstore) PARALLEL SAFE;
ALTER FUNCTION hstore(record) PARALLEL SAFE;
ALTER FUNCTION hstore_to_array(hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_to_matrix(hstore) PARALLEL SAFE;
ALTER FUNCTION akeys(hstore) PARALLEL SAFE;
ALTER FUNCTION avals(hstore) PARALLEL SAFE;
ALTER FUNCTION skeys(hstore) PARALLEL SAFE;
ALTER FUNCTION svals(hstore) PARALLEL SAFE;
ALTER FUNCTION each(hstore) PARALLEL SAFE;
ALTER FUNCTION populate_record(anyelement, hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_eq(hstore, hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_ne(hstore, hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_gt(hstore, hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_ge(hstore, hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_lt(hstore, hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_le(hstore, hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_cmp(hstore, hstore) PARALLEL SAFE;
ALTER FUNCTION hstore_hash(hstore) PARALLEL SAFE;
ALTER FUNCTION ghstore_in(cstring) PARALLEL SAFE;
ALTER FUNCTION ghstore_out(ghstore) PARALLEL SAFE;
ALTER FUNCTION ghstore_compress(internal) PARALLEL SAFE;
ALTER FUNCTION ghstore_decompress(internal) PARALLEL SAFE;
ALTER FUNCTION ghstore_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION ghstore_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION ghstore_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION ghstore_same(ghstore, ghstore, internal) PARALLEL SAFE;
ALTER FUNCTION ghstore_consistent(internal, hstore, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION gin_extract_hstore(hstore, internal) PARALLEL SAFE;
ALTER FUNCTION gin_extract_hstore_query(hstore, internal, int2, internal, internal) PARALLEL SAFE;
ALTER FUNCTION gin_consistent_hstore(internal, int2, hstore, int4, internal, internal) PARALLEL SAFE;

14
dist/win-x64/postgres-standalone/share/extension/hstore--1.4--1.5.sql vendored Normal file
View File

@@ -0,0 +1,14 @@
/* contrib/hstore/hstore--1.4--1.5.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION hstore UPDATE TO '1.5'" to load this file. \quit
ALTER OPERATOR #<=# (hstore, hstore) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel
);
ALTER OPERATOR #>=# (hstore, hstore) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel
);

550
dist/win-x64/postgres-standalone/share/extension/hstore--1.4.sql vendored Normal file
View File

@@ -0,0 +1,550 @@
/* contrib/hstore/hstore--1.4.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION hstore" to load this file. \quit
CREATE TYPE hstore;
CREATE FUNCTION hstore_in(cstring)
RETURNS hstore
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION hstore_out(hstore)
RETURNS cstring
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION hstore_recv(internal)
RETURNS hstore
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION hstore_send(hstore)
RETURNS bytea
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE TYPE hstore (
INTERNALLENGTH = -1,
INPUT = hstore_in,
OUTPUT = hstore_out,
RECEIVE = hstore_recv,
SEND = hstore_send,
STORAGE = extended
);
CREATE FUNCTION hstore_version_diag(hstore)
RETURNS integer
AS 'MODULE_PATHNAME','hstore_version_diag'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION fetchval(hstore,text)
RETURNS text
AS 'MODULE_PATHNAME','hstore_fetchval'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR -> (
LEFTARG = hstore,
RIGHTARG = text,
PROCEDURE = fetchval
);
CREATE FUNCTION slice_array(hstore,text[])
RETURNS text[]
AS 'MODULE_PATHNAME','hstore_slice_to_array'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR -> (
LEFTARG = hstore,
RIGHTARG = text[],
PROCEDURE = slice_array
);
CREATE FUNCTION slice(hstore,text[])
RETURNS hstore
AS 'MODULE_PATHNAME','hstore_slice_to_hstore'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION isexists(hstore,text)
RETURNS bool
AS 'MODULE_PATHNAME','hstore_exists'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION exist(hstore,text)
RETURNS bool
AS 'MODULE_PATHNAME','hstore_exists'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR ? (
LEFTARG = hstore,
RIGHTARG = text,
PROCEDURE = exist,
RESTRICT = contsel,
JOIN = contjoinsel
);
CREATE FUNCTION exists_any(hstore,text[])
RETURNS bool
AS 'MODULE_PATHNAME','hstore_exists_any'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR ?| (
LEFTARG = hstore,
RIGHTARG = text[],
PROCEDURE = exists_any,
RESTRICT = contsel,
JOIN = contjoinsel
);
CREATE FUNCTION exists_all(hstore,text[])
RETURNS bool
AS 'MODULE_PATHNAME','hstore_exists_all'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR ?& (
LEFTARG = hstore,
RIGHTARG = text[],
PROCEDURE = exists_all,
RESTRICT = contsel,
JOIN = contjoinsel
);
CREATE FUNCTION isdefined(hstore,text)
RETURNS bool
AS 'MODULE_PATHNAME','hstore_defined'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION defined(hstore,text)
RETURNS bool
AS 'MODULE_PATHNAME','hstore_defined'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION delete(hstore,text)
RETURNS hstore
AS 'MODULE_PATHNAME','hstore_delete'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION delete(hstore,text[])
RETURNS hstore
AS 'MODULE_PATHNAME','hstore_delete_array'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION delete(hstore,hstore)
RETURNS hstore
AS 'MODULE_PATHNAME','hstore_delete_hstore'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR - (
LEFTARG = hstore,
RIGHTARG = text,
PROCEDURE = delete
);
CREATE OPERATOR - (
LEFTARG = hstore,
RIGHTARG = text[],
PROCEDURE = delete
);
CREATE OPERATOR - (
LEFTARG = hstore,
RIGHTARG = hstore,
PROCEDURE = delete
);
CREATE FUNCTION hs_concat(hstore,hstore)
RETURNS hstore
AS 'MODULE_PATHNAME','hstore_concat'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR || (
LEFTARG = hstore,
RIGHTARG = hstore,
PROCEDURE = hs_concat
);
CREATE FUNCTION hs_contains(hstore,hstore)
RETURNS bool
AS 'MODULE_PATHNAME','hstore_contains'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION hs_contained(hstore,hstore)
RETURNS bool
AS 'MODULE_PATHNAME','hstore_contained'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR @> (
LEFTARG = hstore,
RIGHTARG = hstore,
PROCEDURE = hs_contains,
COMMUTATOR = '<@',
RESTRICT = contsel,
JOIN = contjoinsel
);
CREATE OPERATOR <@ (
LEFTARG = hstore,
RIGHTARG = hstore,
PROCEDURE = hs_contained,
COMMUTATOR = '@>',
RESTRICT = contsel,
JOIN = contjoinsel
);
-- obsolete:
CREATE OPERATOR @ (
LEFTARG = hstore,
RIGHTARG = hstore,
PROCEDURE = hs_contains,
COMMUTATOR = '~',
RESTRICT = contsel,
JOIN = contjoinsel
);
CREATE OPERATOR ~ (
LEFTARG = hstore,
RIGHTARG = hstore,
PROCEDURE = hs_contained,
COMMUTATOR = '@',
RESTRICT = contsel,
JOIN = contjoinsel
);
CREATE FUNCTION tconvert(text,text)
RETURNS hstore
AS 'MODULE_PATHNAME','hstore_from_text'
LANGUAGE C IMMUTABLE PARALLEL SAFE; -- not STRICT; needs to allow (key,NULL)
CREATE FUNCTION hstore(text,text)
RETURNS hstore
AS 'MODULE_PATHNAME','hstore_from_text'
LANGUAGE C IMMUTABLE PARALLEL SAFE; -- not STRICT; needs to allow (key,NULL)
CREATE FUNCTION hstore(text[],text[])
RETURNS hstore
AS 'MODULE_PATHNAME', 'hstore_from_arrays'
LANGUAGE C IMMUTABLE PARALLEL SAFE; -- not STRICT; allows (keys,null)
CREATE FUNCTION hstore(text[])
RETURNS hstore
AS 'MODULE_PATHNAME', 'hstore_from_array'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE CAST (text[] AS hstore)
WITH FUNCTION hstore(text[]);
CREATE FUNCTION hstore_to_json(hstore)
RETURNS json
AS 'MODULE_PATHNAME', 'hstore_to_json'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE CAST (hstore AS json)
WITH FUNCTION hstore_to_json(hstore);
CREATE FUNCTION hstore_to_json_loose(hstore)
RETURNS json
AS 'MODULE_PATHNAME', 'hstore_to_json_loose'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION hstore_to_jsonb(hstore)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'hstore_to_jsonb'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE CAST (hstore AS jsonb)
WITH FUNCTION hstore_to_jsonb(hstore);
CREATE FUNCTION hstore_to_jsonb_loose(hstore)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'hstore_to_jsonb_loose'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION hstore(record)
RETURNS hstore
AS 'MODULE_PATHNAME', 'hstore_from_record'
LANGUAGE C IMMUTABLE PARALLEL SAFE; -- not STRICT; allows (null::recordtype)
CREATE FUNCTION hstore_to_array(hstore)
RETURNS text[]
AS 'MODULE_PATHNAME','hstore_to_array'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR %% (
RIGHTARG = hstore,
PROCEDURE = hstore_to_array
);
CREATE FUNCTION hstore_to_matrix(hstore)
RETURNS text[]
AS 'MODULE_PATHNAME','hstore_to_matrix'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR %# (
RIGHTARG = hstore,
PROCEDURE = hstore_to_matrix
);
CREATE FUNCTION akeys(hstore)
RETURNS text[]
AS 'MODULE_PATHNAME','hstore_akeys'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION avals(hstore)
RETURNS text[]
AS 'MODULE_PATHNAME','hstore_avals'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION skeys(hstore)
RETURNS setof text
AS 'MODULE_PATHNAME','hstore_skeys'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION svals(hstore)
RETURNS setof text
AS 'MODULE_PATHNAME','hstore_svals'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION each(IN hs hstore,
OUT key text,
OUT value text)
RETURNS SETOF record
AS 'MODULE_PATHNAME','hstore_each'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION populate_record(anyelement,hstore)
RETURNS anyelement
AS 'MODULE_PATHNAME', 'hstore_populate_record'
LANGUAGE C IMMUTABLE PARALLEL SAFE; -- not STRICT; allows (null::rectype,hstore)
CREATE OPERATOR #= (
LEFTARG = anyelement,
RIGHTARG = hstore,
PROCEDURE = populate_record
);
-- btree support
CREATE FUNCTION hstore_eq(hstore,hstore)
RETURNS boolean
AS 'MODULE_PATHNAME','hstore_eq'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION hstore_ne(hstore,hstore)
RETURNS boolean
AS 'MODULE_PATHNAME','hstore_ne'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION hstore_gt(hstore,hstore)
RETURNS boolean
AS 'MODULE_PATHNAME','hstore_gt'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION hstore_ge(hstore,hstore)
RETURNS boolean
AS 'MODULE_PATHNAME','hstore_ge'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION hstore_lt(hstore,hstore)
RETURNS boolean
AS 'MODULE_PATHNAME','hstore_lt'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION hstore_le(hstore,hstore)
RETURNS boolean
AS 'MODULE_PATHNAME','hstore_le'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION hstore_cmp(hstore,hstore)
RETURNS integer
AS 'MODULE_PATHNAME','hstore_cmp'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR = (
LEFTARG = hstore,
RIGHTARG = hstore,
PROCEDURE = hstore_eq,
COMMUTATOR = =,
NEGATOR = <>,
RESTRICT = eqsel,
JOIN = eqjoinsel,
MERGES,
HASHES
);
CREATE OPERATOR <> (
LEFTARG = hstore,
RIGHTARG = hstore,
PROCEDURE = hstore_ne,
COMMUTATOR = <>,
NEGATOR = =,
RESTRICT = neqsel,
JOIN = neqjoinsel
);
-- the comparison operators have funky names (and are undocumented)
-- in an attempt to discourage anyone from actually using them. they
-- only exist to support the btree opclass
CREATE OPERATOR #<# (
LEFTARG = hstore,
RIGHTARG = hstore,
PROCEDURE = hstore_lt,
COMMUTATOR = #>#,
NEGATOR = #>=#,
RESTRICT = scalarltsel,
JOIN = scalarltjoinsel
);
CREATE OPERATOR #<=# (
LEFTARG = hstore,
RIGHTARG = hstore,
PROCEDURE = hstore_le,
COMMUTATOR = #>=#,
NEGATOR = #>#,
RESTRICT = scalarltsel,
JOIN = scalarltjoinsel
);
CREATE OPERATOR #># (
LEFTARG = hstore,
RIGHTARG = hstore,
PROCEDURE = hstore_gt,
COMMUTATOR = #<#,
NEGATOR = #<=#,
RESTRICT = scalargtsel,
JOIN = scalargtjoinsel
);
CREATE OPERATOR #>=# (
LEFTARG = hstore,
RIGHTARG = hstore,
PROCEDURE = hstore_ge,
COMMUTATOR = #<=#,
NEGATOR = #<#,
RESTRICT = scalargtsel,
JOIN = scalargtjoinsel
);
CREATE OPERATOR CLASS btree_hstore_ops
DEFAULT FOR TYPE hstore USING btree
AS
OPERATOR 1 #<# ,
OPERATOR 2 #<=# ,
OPERATOR 3 = ,
OPERATOR 4 #>=# ,
OPERATOR 5 #># ,
FUNCTION 1 hstore_cmp(hstore,hstore);
-- hash support
CREATE FUNCTION hstore_hash(hstore)
RETURNS integer
AS 'MODULE_PATHNAME','hstore_hash'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR CLASS hash_hstore_ops
DEFAULT FOR TYPE hstore USING hash
AS
OPERATOR 1 = ,
FUNCTION 1 hstore_hash(hstore);
-- GiST support
CREATE TYPE ghstore;
CREATE FUNCTION ghstore_in(cstring)
RETURNS ghstore
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION ghstore_out(ghstore)
RETURNS cstring
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE TYPE ghstore (
INTERNALLENGTH = -1,
INPUT = ghstore_in,
OUTPUT = ghstore_out
);
CREATE FUNCTION ghstore_compress(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION ghstore_decompress(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION ghstore_penalty(internal,internal,internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION ghstore_picksplit(internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION ghstore_union(internal, internal)
RETURNS ghstore
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION ghstore_same(ghstore, ghstore, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION ghstore_consistent(internal,hstore,smallint,oid,internal)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OPERATOR CLASS gist_hstore_ops
DEFAULT FOR TYPE hstore USING gist
AS
OPERATOR 7 @> ,
OPERATOR 9 ?(hstore,text) ,
OPERATOR 10 ?|(hstore,text[]) ,
OPERATOR 11 ?&(hstore,text[]) ,
--OPERATOR 8 <@ ,
OPERATOR 13 @ ,
--OPERATOR 14 ~ ,
FUNCTION 1 ghstore_consistent (internal, hstore, smallint, oid, internal),
FUNCTION 2 ghstore_union (internal, internal),
FUNCTION 3 ghstore_compress (internal),
FUNCTION 4 ghstore_decompress (internal),
FUNCTION 5 ghstore_penalty (internal, internal, internal),
FUNCTION 6 ghstore_picksplit (internal, internal),
FUNCTION 7 ghstore_same (ghstore, ghstore, internal),
STORAGE ghstore;
-- GIN support
CREATE FUNCTION gin_extract_hstore(hstore, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION gin_extract_hstore_query(hstore, internal, int2, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION gin_consistent_hstore(internal, int2, hstore, int4, internal, internal)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OPERATOR CLASS gin_hstore_ops
DEFAULT FOR TYPE hstore USING gin
AS
OPERATOR 7 @>,
OPERATOR 9 ?(hstore,text),
OPERATOR 10 ?|(hstore,text[]),
OPERATOR 11 ?&(hstore,text[]),
FUNCTION 1 bttextcmp(text,text),
FUNCTION 2 gin_extract_hstore(hstore, internal),
FUNCTION 3 gin_extract_hstore_query(hstore, internal, int2, internal, internal),
FUNCTION 4 gin_consistent_hstore(internal, int2, hstore, int4, internal, internal),
STORAGE text;

12
dist/win-x64/postgres-standalone/share/extension/hstore--1.5--1.6.sql vendored Normal file
View File

@@ -0,0 +1,12 @@
/* contrib/hstore/hstore--1.5--1.6.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION hstore UPDATE TO '1.6'" to load this file. \quit
CREATE FUNCTION hstore_hash_extended(hstore, int8)
RETURNS int8
AS 'MODULE_PATHNAME','hstore_hash_extended'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
ALTER OPERATOR FAMILY hash_hstore_ops USING hash ADD
FUNCTION 2 hstore_hash_extended(hstore, int8);

27
dist/win-x64/postgres-standalone/share/extension/hstore--1.6--1.7.sql vendored Normal file
View File

@@ -0,0 +1,27 @@
/* contrib/hstore/hstore--1.6--1.7.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION hstore UPDATE TO '1.7'" to load this file. \quit
CREATE FUNCTION ghstore_options(internal)
RETURNS void
AS 'MODULE_PATHNAME', 'ghstore_options'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
ALTER OPERATOR FAMILY gist_hstore_ops USING gist
ADD FUNCTION 10 (hstore) ghstore_options (internal);
ALTER OPERATOR ? (hstore, text)
SET (RESTRICT = matchingsel, JOIN = matchingjoinsel);
ALTER OPERATOR ?| (hstore, text[])
SET (RESTRICT = matchingsel, JOIN = matchingjoinsel);
ALTER OPERATOR ?& (hstore, text[])
SET (RESTRICT = matchingsel, JOIN = matchingjoinsel);
ALTER OPERATOR @> (hstore, hstore)
SET (RESTRICT = matchingsel, JOIN = matchingjoinsel);
ALTER OPERATOR <@ (hstore, hstore)
SET (RESTRICT = matchingsel, JOIN = matchingjoinsel);
ALTER OPERATOR @ (hstore, hstore)
SET (RESTRICT = matchingsel, JOIN = matchingjoinsel);
ALTER OPERATOR ~ (hstore, hstore)
SET (RESTRICT = matchingsel, JOIN = matchingjoinsel);

17
dist/win-x64/postgres-standalone/share/extension/hstore--1.7--1.8.sql vendored Normal file
View File

@@ -0,0 +1,17 @@
/* contrib/hstore/hstore--1.7--1.8.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION hstore UPDATE TO '1.8'" to load this file. \quit
CREATE FUNCTION hstore_subscript_handler(internal)
RETURNS internal
AS 'MODULE_PATHNAME', 'hstore_subscript_handler'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
ALTER TYPE hstore SET (
SUBSCRIPT = hstore_subscript_handler
);
-- Remove @ and ~
DROP OPERATOR @ (hstore, hstore);
DROP OPERATOR ~ (hstore, hstore);

6
dist/win-x64/postgres-standalone/share/extension/hstore.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# hstore extension
comment = 'data type for storing sets of (key, value) pairs'
default_version = '1.8'
module_pathname = '$libdir/hstore'
relocatable = true
trusted = true

17
dist/win-x64/postgres-standalone/share/extension/hstore_plperl--1.0.sql vendored Normal file
View File

@@ -0,0 +1,17 @@
/* contrib/hstore_plperl/hstore_plperl--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION hstore_plperl" to load this file. \quit
CREATE FUNCTION hstore_to_plperl(val internal) RETURNS internal
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME';
CREATE FUNCTION plperl_to_hstore(val internal) RETURNS hstore
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME';
CREATE TRANSFORM FOR hstore LANGUAGE plperl (
FROM SQL WITH FUNCTION hstore_to_plperl(internal),
TO SQL WITH FUNCTION plperl_to_hstore(internal)
);

6
dist/win-x64/postgres-standalone/share/extension/hstore_plperl.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# hstore_plperl extension
comment = 'transform between hstore and plperl'
default_version = '1.0'
module_pathname = '$libdir/hstore_plperl'
relocatable = true
requires = 'hstore,plperl'

17
dist/win-x64/postgres-standalone/share/extension/hstore_plperlu--1.0.sql vendored Normal file
View File

@@ -0,0 +1,17 @@
/* contrib/hstore_plperl/hstore_plperlu--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION hstore_plperlu" to load this file. \quit
CREATE FUNCTION hstore_to_plperlu(val internal) RETURNS internal
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME', 'hstore_to_plperl';
CREATE FUNCTION plperlu_to_hstore(val internal) RETURNS hstore
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME', 'plperl_to_hstore';
CREATE TRANSFORM FOR hstore LANGUAGE plperlu (
FROM SQL WITH FUNCTION hstore_to_plperlu(internal),
TO SQL WITH FUNCTION plperlu_to_hstore(internal)
);

6
dist/win-x64/postgres-standalone/share/extension/hstore_plperlu.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# hstore_plperlu extension
comment = 'transform between hstore and plperlu'
default_version = '1.0'
module_pathname = '$libdir/hstore_plperl'
relocatable = true
requires = 'hstore,plperlu'

19
dist/win-x64/postgres-standalone/share/extension/hstore_plpython2u--1.0.sql vendored Normal file
View File

@@ -0,0 +1,19 @@
/* contrib/hstore_plpython/hstore_plpython2u--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION hstore_plpython2u" to load this file. \quit
CREATE FUNCTION hstore_to_plpython2(val internal) RETURNS internal
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME', 'hstore_to_plpython';
CREATE FUNCTION plpython2_to_hstore(val internal) RETURNS hstore
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME', 'plpython_to_hstore';
CREATE TRANSFORM FOR hstore LANGUAGE plpython2u (
FROM SQL WITH FUNCTION hstore_to_plpython2(internal),
TO SQL WITH FUNCTION plpython2_to_hstore(internal)
);
COMMENT ON TRANSFORM FOR hstore LANGUAGE plpython2u IS 'transform between hstore and Python dict';

6
dist/win-x64/postgres-standalone/share/extension/hstore_plpython2u.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# hstore_plpython2u extension
comment = 'transform between hstore and plpython2u'
default_version = '1.0'
module_pathname = '$libdir/hstore_plpython2'
relocatable = true
requires = 'hstore,plpython2u'

19
dist/win-x64/postgres-standalone/share/extension/hstore_plpython3u--1.0.sql vendored Normal file
View File

@@ -0,0 +1,19 @@
/* contrib/hstore_plpython/hstore_plpython3u--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION hstore_plpython3u" to load this file. \quit
CREATE FUNCTION hstore_to_plpython3(val internal) RETURNS internal
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME', 'hstore_to_plpython';
CREATE FUNCTION plpython3_to_hstore(val internal) RETURNS hstore
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME', 'plpython_to_hstore';
CREATE TRANSFORM FOR hstore LANGUAGE plpython3u (
FROM SQL WITH FUNCTION hstore_to_plpython3(internal),
TO SQL WITH FUNCTION plpython3_to_hstore(internal)
);
COMMENT ON TRANSFORM FOR hstore LANGUAGE plpython3u IS 'transform between hstore and Python dict';

6
dist/win-x64/postgres-standalone/share/extension/hstore_plpython3u.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# hstore_plpython3u extension
comment = 'transform between hstore and plpython3u'
default_version = '1.0'
module_pathname = '$libdir/hstore_plpython3'
relocatable = true
requires = 'hstore,plpython3u'

19
dist/win-x64/postgres-standalone/share/extension/hstore_plpythonu--1.0.sql vendored Normal file
View File

@@ -0,0 +1,19 @@
/* contrib/hstore_plpython/hstore_plpythonu--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION hstore_plpythonu" to load this file. \quit
CREATE FUNCTION hstore_to_plpython(val internal) RETURNS internal
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME';
CREATE FUNCTION plpython_to_hstore(val internal) RETURNS hstore
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME';
CREATE TRANSFORM FOR hstore LANGUAGE plpythonu (
FROM SQL WITH FUNCTION hstore_to_plpython(internal),
TO SQL WITH FUNCTION plpython_to_hstore(internal)
);
COMMENT ON TRANSFORM FOR hstore LANGUAGE plpythonu IS 'transform between hstore and Python dict';

6
dist/win-x64/postgres-standalone/share/extension/hstore_plpythonu.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# hstore_plpythonu extension
comment = 'transform between hstore and plpythonu'
default_version = '1.0'
module_pathname = '$libdir/hstore_plpython2'
relocatable = true
requires = 'hstore,plpythonu'

9
dist/win-x64/postgres-standalone/share/extension/insert_username--1.0.sql vendored Normal file
View File

@@ -0,0 +1,9 @@
/* contrib/spi/insert_username--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION insert_username" to load this file. \quit
CREATE FUNCTION insert_username()
RETURNS trigger
AS 'MODULE_PATHNAME'
LANGUAGE C;

5
dist/win-x64/postgres-standalone/share/extension/insert_username.control vendored Normal file
View File

@@ -0,0 +1,5 @@
# insert_username extension
comment = 'functions for tracking who changed a table'
default_version = '1.0'
module_pathname = '$libdir/insert_username'
relocatable = true

23
dist/win-x64/postgres-standalone/share/extension/intagg--1.0--1.1.sql vendored Normal file
View File

@@ -0,0 +1,23 @@
/* contrib/intagg/intagg--1.0--1.1.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION intagg UPDATE TO '1.1'" to load this file. \quit
ALTER FUNCTION int_agg_state(internal, int4) PARALLEL SAFE;
ALTER FUNCTION int_agg_final_array(internal) PARALLEL SAFE;
ALTER FUNCTION int_array_enum(int4[]) PARALLEL SAFE;
DO LANGUAGE plpgsql
$$
DECLARE
my_schema pg_catalog.text := pg_catalog.quote_ident(pg_catalog.current_schema());
old_path pg_catalog.text := pg_catalog.current_setting('search_path');
BEGIN
-- for safety, transiently set search_path to just pg_catalog+pg_temp
PERFORM pg_catalog.set_config('search_path', 'pg_catalog, pg_temp', true);
UPDATE pg_proc SET proparallel = 's'
WHERE oid = (my_schema || '.int_array_aggregate(int4)')::pg_catalog.regprocedure;
PERFORM pg_catalog.set_config('search_path', old_path, true);
END
$$;

37
dist/win-x64/postgres-standalone/share/extension/intagg--1.1.sql vendored Normal file
View File

@@ -0,0 +1,37 @@
/* contrib/intagg/intagg--1.1.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION intagg" to load this file. \quit
-- Internal function for the aggregate
-- Is called for each item in an aggregation
CREATE FUNCTION int_agg_state (internal, int4)
RETURNS internal
AS 'array_agg_transfn'
PARALLEL SAFE
LANGUAGE INTERNAL;
-- Internal function for the aggregate
-- Is called at the end of the aggregation, and returns an array.
CREATE FUNCTION int_agg_final_array (internal)
RETURNS int4[]
AS 'array_agg_finalfn'
PARALLEL SAFE
LANGUAGE INTERNAL;
-- The aggregate function itself
-- uses the above functions to create an array of integers from an aggregation.
CREATE AGGREGATE int_array_aggregate(int4) (
SFUNC = int_agg_state,
STYPE = internal,
FINALFUNC = int_agg_final_array,
PARALLEL = SAFE
);
-- The enumeration function
-- returns each element in a one dimensional integer array
-- as a row.
CREATE FUNCTION int_array_enum(int4[])
RETURNS setof integer
AS 'array_unnest'
LANGUAGE INTERNAL IMMUTABLE STRICT PARALLEL SAFE;

4
dist/win-x64/postgres-standalone/share/extension/intagg.control vendored Normal file
View File

@@ -0,0 +1,4 @@
# intagg extension
comment = 'integer aggregator and enumerator (obsolete)'
default_version = '1.1'
relocatable = true

49
dist/win-x64/postgres-standalone/share/extension/intarray--1.0--1.1.sql vendored Normal file
View File

@@ -0,0 +1,49 @@
/* contrib/intarray/intarray--1.0--1.1.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "ALTER EXTENSION intarray UPDATE TO '1.1'" to load this file. \quit
CREATE FUNCTION _int_matchsel(internal, oid, internal, integer)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE;
ALTER OPERATOR @@ (_int4, query_int) SET (RESTRICT = _int_matchsel);
ALTER OPERATOR ~~ (query_int, _int4) SET (RESTRICT = _int_matchsel);
CREATE FUNCTION _int_overlap_sel(internal, oid, internal, integer)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE;
CREATE FUNCTION _int_contains_sel(internal, oid, internal, integer)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE;
CREATE FUNCTION _int_contained_sel(internal, oid, internal, integer)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE;
CREATE FUNCTION _int_overlap_joinsel(internal, oid, internal, smallint, internal)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE;
CREATE FUNCTION _int_contains_joinsel(internal, oid, internal, smallint, internal)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE;
CREATE FUNCTION _int_contained_joinsel(internal, oid, internal, smallint, internal)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE;
ALTER OPERATOR && (_int4, _int4) SET (RESTRICT = _int_overlap_sel, JOIN = _int_overlap_joinsel);
ALTER OPERATOR @> (_int4, _int4) SET (RESTRICT = _int_contains_sel, JOIN = _int_contains_joinsel);
ALTER OPERATOR <@ (_int4, _int4) SET (RESTRICT = _int_contained_sel, JOIN = _int_contained_joinsel);
ALTER OPERATOR @ (_int4, _int4) SET (RESTRICT = _int_contains_sel, JOIN = _int_contains_joinsel);
ALTER OPERATOR ~ (_int4, _int4) SET (RESTRICT = _int_contained_sel, JOIN = _int_contained_joinsel);

94
dist/win-x64/postgres-standalone/share/extension/intarray--1.1--1.2.sql vendored Normal file
View File

@@ -0,0 +1,94 @@
/* contrib/intarray/intarray--1.1--1.2.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION intarray UPDATE TO '1.2'" to load this file. \quit
-- Update procedure signatures the hard way.
-- We use to_regprocedure() so that query doesn't fail if run against 9.6beta1 definitions,
-- wherein the signatures have been updated already. In that case to_regprocedure() will
-- return NULL and no updates will happen.
DO LANGUAGE plpgsql
$$
DECLARE
my_schema pg_catalog.text := pg_catalog.quote_ident(pg_catalog.current_schema());
old_path pg_catalog.text := pg_catalog.current_setting('search_path');
BEGIN
-- for safety, transiently set search_path to just pg_catalog+pg_temp
PERFORM pg_catalog.set_config('search_path', 'pg_catalog, pg_temp', true);
UPDATE pg_catalog.pg_proc SET
proargtypes = pg_catalog.array_to_string(newtypes::pg_catalog.oid[], ' ')::pg_catalog.oidvector,
pronargs = pg_catalog.array_length(newtypes, 1)
FROM (VALUES
(NULL::pg_catalog.text, NULL::pg_catalog.text[]), -- establish column types
('g_int_consistent(internal,_int4,int4,oid,internal)', '{internal,_int4,int2,oid,internal}'),
('g_intbig_consistent(internal,internal,int4,oid,internal)', '{internal,_int4,int2,oid,internal}'),
('g_intbig_same(internal,internal,internal)', '{SCH.intbig_gkey,SCH.intbig_gkey,internal}'),
('ginint4_queryextract(internal,internal,int2,internal,internal,internal,internal)', '{_int4,internal,int2,internal,internal,internal,internal}'),
('ginint4_consistent(internal,int2,internal,int4,internal,internal,internal,internal)', '{internal,int2,_int4,int4,internal,internal,internal,internal}')
) AS update_data (oldproc, newtypestext),
LATERAL (
SELECT array_agg(replace(typ, 'SCH', my_schema)::regtype) as newtypes FROM unnest(newtypestext) typ
) ls
WHERE oid = to_regprocedure(my_schema || '.' || replace(oldproc, 'SCH', my_schema));
UPDATE pg_catalog.pg_proc SET
prorettype = (my_schema || '.intbig_gkey')::pg_catalog.regtype
WHERE oid = pg_catalog.to_regprocedure(my_schema || '.g_intbig_union(internal,internal)');
PERFORM pg_catalog.set_config('search_path', old_path, true);
END
$$;
ALTER FUNCTION bqarr_in(cstring) PARALLEL SAFE;
ALTER FUNCTION bqarr_out(query_int) PARALLEL SAFE;
ALTER FUNCTION querytree(query_int) PARALLEL SAFE;
ALTER FUNCTION boolop(_int4, query_int) PARALLEL SAFE;
ALTER FUNCTION rboolop(query_int, _int4) PARALLEL SAFE;
ALTER FUNCTION _int_matchsel(internal, oid, internal, integer) PARALLEL SAFE;
ALTER FUNCTION _int_contains(_int4, _int4) PARALLEL SAFE;
ALTER FUNCTION _int_contained(_int4, _int4) PARALLEL SAFE;
ALTER FUNCTION _int_overlap(_int4, _int4) PARALLEL SAFE;
ALTER FUNCTION _int_same(_int4, _int4) PARALLEL SAFE;
ALTER FUNCTION _int_different(_int4, _int4) PARALLEL SAFE;
ALTER FUNCTION _int_union(_int4, _int4) PARALLEL SAFE;
ALTER FUNCTION _int_inter(_int4, _int4) PARALLEL SAFE;
ALTER FUNCTION _int_overlap_sel(internal, oid, internal, integer) PARALLEL SAFE;
ALTER FUNCTION _int_contains_sel(internal, oid, internal, integer) PARALLEL SAFE;
ALTER FUNCTION _int_contained_sel(internal, oid, internal, integer) PARALLEL SAFE;
ALTER FUNCTION _int_overlap_joinsel(internal, oid, internal, smallint, internal) PARALLEL SAFE;
ALTER FUNCTION _int_contains_joinsel(internal, oid, internal, smallint, internal) PARALLEL SAFE;
ALTER FUNCTION _int_contained_joinsel(internal, oid, internal, smallint, internal) PARALLEL SAFE;
ALTER FUNCTION intset(int4) PARALLEL SAFE;
ALTER FUNCTION icount(_int4) PARALLEL SAFE;
ALTER FUNCTION sort(_int4, text) PARALLEL SAFE;
ALTER FUNCTION sort(_int4) PARALLEL SAFE;
ALTER FUNCTION sort_asc(_int4) PARALLEL SAFE;
ALTER FUNCTION sort_desc(_int4) PARALLEL SAFE;
ALTER FUNCTION uniq(_int4) PARALLEL SAFE;
ALTER FUNCTION idx(_int4, int4) PARALLEL SAFE;
ALTER FUNCTION subarray(_int4, int4, int4) PARALLEL SAFE;
ALTER FUNCTION subarray(_int4, int4) PARALLEL SAFE;
ALTER FUNCTION intarray_push_elem(_int4, int4) PARALLEL SAFE;
ALTER FUNCTION intarray_push_array(_int4, _int4) PARALLEL SAFE;
ALTER FUNCTION intarray_del_elem(_int4, int4) PARALLEL SAFE;
ALTER FUNCTION intset_union_elem(_int4, int4) PARALLEL SAFE;
ALTER FUNCTION intset_subtract(_int4, _int4) PARALLEL SAFE;
ALTER FUNCTION g_int_consistent(internal, _int4, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION g_int_compress(internal) PARALLEL SAFE;
ALTER FUNCTION g_int_decompress(internal) PARALLEL SAFE;
ALTER FUNCTION g_int_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION g_int_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION g_int_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION g_int_same(_int4, _int4, internal) PARALLEL SAFE;
ALTER FUNCTION _intbig_in(cstring) PARALLEL SAFE;
ALTER FUNCTION _intbig_out(intbig_gkey) PARALLEL SAFE;
ALTER FUNCTION g_intbig_consistent(internal, _int4, smallint, oid, internal) PARALLEL SAFE;
ALTER FUNCTION g_intbig_compress(internal) PARALLEL SAFE;
ALTER FUNCTION g_intbig_decompress(internal) PARALLEL SAFE;
ALTER FUNCTION g_intbig_penalty(internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION g_intbig_picksplit(internal, internal) PARALLEL SAFE;
ALTER FUNCTION g_intbig_union(internal, internal) PARALLEL SAFE;
ALTER FUNCTION g_intbig_same(intbig_gkey, intbig_gkey, internal) PARALLEL SAFE;
ALTER FUNCTION ginint4_queryextract(_int4, internal, int2, internal, internal, internal, internal) PARALLEL SAFE;
ALTER FUNCTION ginint4_consistent(internal, int2, _int4, int4, internal, internal, internal, internal) PARALLEL SAFE;

20
dist/win-x64/postgres-standalone/share/extension/intarray--1.2--1.3.sql vendored Normal file
View File

@@ -0,0 +1,20 @@
/* contrib/intarray/intarray--1.2--1.3.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION intarray UPDATE TO '1.3'" to load this file. \quit
CREATE FUNCTION g_int_options(internal)
RETURNS void
AS 'MODULE_PATHNAME', 'g_int_options'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION g_intbig_options(internal)
RETURNS void
AS 'MODULE_PATHNAME', 'g_intbig_options'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
ALTER OPERATOR FAMILY gist__int_ops USING gist
ADD FUNCTION 10 (_int4) g_int_options (internal);
ALTER OPERATOR FAMILY gist__intbig_ops USING gist
ADD FUNCTION 10 (_int4) g_intbig_options (internal);

520
dist/win-x64/postgres-standalone/share/extension/intarray--1.2.sql vendored Normal file
View File

@@ -0,0 +1,520 @@
/* contrib/intarray/intarray--1.2.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION intarray" to load this file. \quit
--
-- Create the user-defined type for the 1-D integer arrays (_int4)
--
-- Query type
CREATE FUNCTION bqarr_in(cstring)
RETURNS query_int
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION bqarr_out(query_int)
RETURNS cstring
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE TYPE query_int (
INTERNALLENGTH = -1,
INPUT = bqarr_in,
OUTPUT = bqarr_out
);
--only for debug
CREATE FUNCTION querytree(query_int)
RETURNS text
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION boolop(_int4, query_int)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
COMMENT ON FUNCTION boolop(_int4, query_int) IS 'boolean operation with array';
CREATE FUNCTION rboolop(query_int, _int4)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
COMMENT ON FUNCTION rboolop(query_int, _int4) IS 'boolean operation with array';
CREATE FUNCTION _int_matchsel(internal, oid, internal, integer)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE PARALLEL SAFE;
CREATE OPERATOR @@ (
LEFTARG = _int4,
RIGHTARG = query_int,
PROCEDURE = boolop,
COMMUTATOR = '~~',
RESTRICT = _int_matchsel,
JOIN = contjoinsel
);
CREATE OPERATOR ~~ (
LEFTARG = query_int,
RIGHTARG = _int4,
PROCEDURE = rboolop,
COMMUTATOR = '@@',
RESTRICT = _int_matchsel,
JOIN = contjoinsel
);
--
-- External C-functions for R-tree methods
--
-- Comparison methods
CREATE FUNCTION _int_contains(_int4, _int4)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
COMMENT ON FUNCTION _int_contains(_int4, _int4) IS 'contains';
CREATE FUNCTION _int_contained(_int4, _int4)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
COMMENT ON FUNCTION _int_contained(_int4, _int4) IS 'contained in';
CREATE FUNCTION _int_overlap(_int4, _int4)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
COMMENT ON FUNCTION _int_overlap(_int4, _int4) IS 'overlaps';
CREATE FUNCTION _int_same(_int4, _int4)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
COMMENT ON FUNCTION _int_same(_int4, _int4) IS 'same as';
CREATE FUNCTION _int_different(_int4, _int4)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
COMMENT ON FUNCTION _int_different(_int4, _int4) IS 'different';
-- support routines for indexing
CREATE FUNCTION _int_union(_int4, _int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION _int_inter(_int4, _int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION _int_overlap_sel(internal, oid, internal, integer)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE PARALLEL SAFE;
CREATE FUNCTION _int_contains_sel(internal, oid, internal, integer)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE PARALLEL SAFE;
CREATE FUNCTION _int_contained_sel(internal, oid, internal, integer)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE PARALLEL SAFE;
CREATE FUNCTION _int_overlap_joinsel(internal, oid, internal, smallint, internal)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE PARALLEL SAFE;
CREATE FUNCTION _int_contains_joinsel(internal, oid, internal, smallint, internal)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE PARALLEL SAFE;
CREATE FUNCTION _int_contained_joinsel(internal, oid, internal, smallint, internal)
RETURNS float8
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT STABLE PARALLEL SAFE;
--
-- OPERATORS
--
CREATE OPERATOR && (
LEFTARG = _int4,
RIGHTARG = _int4,
PROCEDURE = _int_overlap,
COMMUTATOR = '&&',
RESTRICT = _int_overlap_sel,
JOIN = _int_overlap_joinsel
);
--CREATE OPERATOR = (
-- LEFTARG = _int4,
-- RIGHTARG = _int4,
-- PROCEDURE = _int_same,
-- COMMUTATOR = '=',
-- NEGATOR = '<>',
-- RESTRICT = eqsel,
-- JOIN = eqjoinsel,
-- SORT1 = '<',
-- SORT2 = '<'
--);
--CREATE OPERATOR <> (
-- LEFTARG = _int4,
-- RIGHTARG = _int4,
-- PROCEDURE = _int_different,
-- COMMUTATOR = '<>',
-- NEGATOR = '=',
-- RESTRICT = neqsel,
-- JOIN = neqjoinsel
--);
CREATE OPERATOR @> (
LEFTARG = _int4,
RIGHTARG = _int4,
PROCEDURE = _int_contains,
COMMUTATOR = '<@',
RESTRICT = _int_contains_sel,
JOIN = _int_contains_joinsel
);
CREATE OPERATOR <@ (
LEFTARG = _int4,
RIGHTARG = _int4,
PROCEDURE = _int_contained,
COMMUTATOR = '@>',
RESTRICT = _int_contained_sel,
JOIN = _int_contained_joinsel
);
-- obsolete:
CREATE OPERATOR @ (
LEFTARG = _int4,
RIGHTARG = _int4,
PROCEDURE = _int_contains,
COMMUTATOR = '~',
RESTRICT = _int_contains_sel,
JOIN = _int_contains_joinsel
);
CREATE OPERATOR ~ (
LEFTARG = _int4,
RIGHTARG = _int4,
PROCEDURE = _int_contained,
COMMUTATOR = '@',
RESTRICT = _int_contained_sel,
JOIN = _int_contained_joinsel
);
--------------
CREATE FUNCTION intset(int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION icount(_int4)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR # (
RIGHTARG = _int4,
PROCEDURE = icount
);
CREATE FUNCTION sort(_int4, text)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION sort(_int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION sort_asc(_int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION sort_desc(_int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION uniq(_int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION idx(_int4, int4)
RETURNS int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR # (
LEFTARG = _int4,
RIGHTARG = int4,
PROCEDURE = idx
);
CREATE FUNCTION subarray(_int4, int4, int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION subarray(_int4, int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION intarray_push_elem(_int4, int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR + (
LEFTARG = _int4,
RIGHTARG = int4,
PROCEDURE = intarray_push_elem
);
CREATE FUNCTION intarray_push_array(_int4, _int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR + (
LEFTARG = _int4,
RIGHTARG = _int4,
COMMUTATOR = +,
PROCEDURE = intarray_push_array
);
CREATE FUNCTION intarray_del_elem(_int4, int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR - (
LEFTARG = _int4,
RIGHTARG = int4,
PROCEDURE = intarray_del_elem
);
CREATE FUNCTION intset_union_elem(_int4, int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR | (
LEFTARG = _int4,
RIGHTARG = int4,
PROCEDURE = intset_union_elem
);
CREATE OPERATOR | (
LEFTARG = _int4,
RIGHTARG = _int4,
COMMUTATOR = |,
PROCEDURE = _int_union
);
CREATE FUNCTION intset_subtract(_int4, _int4)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE OPERATOR - (
LEFTARG = _int4,
RIGHTARG = _int4,
PROCEDURE = intset_subtract
);
CREATE OPERATOR & (
LEFTARG = _int4,
RIGHTARG = _int4,
COMMUTATOR = &,
PROCEDURE = _int_inter
);
--------------
-- define the GiST support methods
CREATE FUNCTION g_int_consistent(internal,_int4,smallint,oid,internal)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_int_compress(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_int_decompress(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_int_penalty(internal,internal,internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_int_picksplit(internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_int_union(internal, internal)
RETURNS _int4
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_int_same(_int4, _int4, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Create the operator class for indexing
CREATE OPERATOR CLASS gist__int_ops
DEFAULT FOR TYPE _int4 USING gist AS
OPERATOR 3 &&,
OPERATOR 6 = (anyarray, anyarray),
OPERATOR 7 @>,
OPERATOR 8 <@,
OPERATOR 13 @,
OPERATOR 14 ~,
OPERATOR 20 @@ (_int4, query_int),
FUNCTION 1 g_int_consistent (internal, _int4, smallint, oid, internal),
FUNCTION 2 g_int_union (internal, internal),
FUNCTION 3 g_int_compress (internal),
FUNCTION 4 g_int_decompress (internal),
FUNCTION 5 g_int_penalty (internal, internal, internal),
FUNCTION 6 g_int_picksplit (internal, internal),
FUNCTION 7 g_int_same (_int4, _int4, internal);
---------------------------------------------
-- intbig
---------------------------------------------
-- define the GiST support methods
CREATE FUNCTION _intbig_in(cstring)
RETURNS intbig_gkey
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE FUNCTION _intbig_out(intbig_gkey)
RETURNS cstring
AS 'MODULE_PATHNAME'
LANGUAGE C STRICT IMMUTABLE PARALLEL SAFE;
CREATE TYPE intbig_gkey (
INTERNALLENGTH = -1,
INPUT = _intbig_in,
OUTPUT = _intbig_out
);
CREATE FUNCTION g_intbig_consistent(internal,_int4,smallint,oid,internal)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_intbig_compress(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_intbig_decompress(internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_intbig_penalty(internal,internal,internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_intbig_picksplit(internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_intbig_union(internal, internal)
RETURNS intbig_gkey
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION g_intbig_same(intbig_gkey, intbig_gkey, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- register the opclass for indexing (not as default)
CREATE OPERATOR CLASS gist__intbig_ops
FOR TYPE _int4 USING gist
AS
OPERATOR 3 &&,
OPERATOR 6 = (anyarray, anyarray),
OPERATOR 7 @>,
OPERATOR 8 <@,
OPERATOR 13 @,
OPERATOR 14 ~,
OPERATOR 20 @@ (_int4, query_int),
FUNCTION 1 g_intbig_consistent (internal, _int4, smallint, oid, internal),
FUNCTION 2 g_intbig_union (internal, internal),
FUNCTION 3 g_intbig_compress (internal),
FUNCTION 4 g_intbig_decompress (internal),
FUNCTION 5 g_intbig_penalty (internal, internal, internal),
FUNCTION 6 g_intbig_picksplit (internal, internal),
FUNCTION 7 g_intbig_same (intbig_gkey, intbig_gkey, internal),
STORAGE intbig_gkey;
--GIN
CREATE FUNCTION ginint4_queryextract(_int4, internal, int2, internal, internal, internal, internal)
RETURNS internal
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE FUNCTION ginint4_consistent(internal, int2, _int4, int4, internal, internal, internal, internal)
RETURNS bool
AS 'MODULE_PATHNAME'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OPERATOR CLASS gin__int_ops
FOR TYPE _int4 USING gin
AS
OPERATOR 3 &&,
OPERATOR 6 = (anyarray, anyarray),
OPERATOR 7 @>,
OPERATOR 8 <@,
OPERATOR 13 @,
OPERATOR 14 ~,
OPERATOR 20 @@ (_int4, query_int),
FUNCTION 1 btint4cmp (int4, int4),
FUNCTION 2 ginarrayextract (anyarray, internal, internal),
FUNCTION 3 ginint4_queryextract (_int4, internal, int2, internal, internal, internal, internal),
FUNCTION 4 ginint4_consistent (internal, int2, _int4, int4, internal, internal, internal, internal),
STORAGE int4;

21
dist/win-x64/postgres-standalone/share/extension/intarray--1.3--1.4.sql vendored Normal file
View File

@@ -0,0 +1,21 @@
/* contrib/intarray/intarray--1.3--1.4.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION intarray UPDATE TO '1.4'" to load this file. \quit
-- Remove <@ from the GiST opclasses, as it's not usefully indexable
-- due to mishandling of empty arrays. (It's OK in GIN.)
ALTER OPERATOR FAMILY gist__int_ops USING gist
DROP OPERATOR 8 (_int4, _int4);
ALTER OPERATOR FAMILY gist__intbig_ops USING gist
DROP OPERATOR 8 (_int4, _int4);
-- Likewise for the old spelling ~.
ALTER OPERATOR FAMILY gist__int_ops USING gist
DROP OPERATOR 14 (_int4, _int4);
ALTER OPERATOR FAMILY gist__intbig_ops USING gist
DROP OPERATOR 14 (_int4, _int4);

8
dist/win-x64/postgres-standalone/share/extension/intarray--1.4--1.5.sql vendored Normal file
View File

@@ -0,0 +1,8 @@
/* contrib/intarray/intarray--1.4--1.5.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION intarray UPDATE TO '1.5'" to load this file. \quit
-- Remove @ and ~
DROP OPERATOR @ (_int4, _int4);
DROP OPERATOR ~ (_int4, _int4);

6
dist/win-x64/postgres-standalone/share/extension/intarray.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# intarray extension
comment = 'functions, operators, and index support for 1-D arrays of integers'
default_version = '1.5'
module_pathname = '$libdir/_int'
relocatable = true
trusted = true

250
dist/win-x64/postgres-standalone/share/extension/isn--1.0--1.1.sql vendored Normal file
View File

@@ -0,0 +1,250 @@
/* contrib/isn/isn--1.0--1.1.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION isn UPDATE TO '1.1'" to load this file. \quit
ALTER FUNCTION ean13_in(cstring) PARALLEL SAFE;
ALTER FUNCTION ean13_out(ean13) PARALLEL SAFE;
ALTER FUNCTION isbn13_in(cstring) PARALLEL SAFE;
ALTER FUNCTION ean13_out(isbn13) PARALLEL SAFE;
ALTER FUNCTION ismn13_in(cstring) PARALLEL SAFE;
ALTER FUNCTION ean13_out(ismn13) PARALLEL SAFE;
ALTER FUNCTION issn13_in(cstring) PARALLEL SAFE;
ALTER FUNCTION ean13_out(issn13) PARALLEL SAFE;
ALTER FUNCTION isbn_in(cstring) PARALLEL SAFE;
ALTER FUNCTION isn_out(isbn) PARALLEL SAFE;
ALTER FUNCTION ismn_in(cstring) PARALLEL SAFE;
ALTER FUNCTION isn_out(ismn) PARALLEL SAFE;
ALTER FUNCTION issn_in(cstring) PARALLEL SAFE;
ALTER FUNCTION isn_out(issn) PARALLEL SAFE;
ALTER FUNCTION upc_in(cstring) PARALLEL SAFE;
ALTER FUNCTION isn_out(upc) PARALLEL SAFE;
ALTER FUNCTION isnlt(ean13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnle(ean13, ean13) PARALLEL SAFE;
ALTER FUNCTION isneq(ean13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnge(ean13, ean13) PARALLEL SAFE;
ALTER FUNCTION isngt(ean13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnne(ean13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnlt(ean13, isbn13) PARALLEL SAFE;
ALTER FUNCTION isnle(ean13, isbn13) PARALLEL SAFE;
ALTER FUNCTION isneq(ean13, isbn13) PARALLEL SAFE;
ALTER FUNCTION isnge(ean13, isbn13) PARALLEL SAFE;
ALTER FUNCTION isngt(ean13, isbn13) PARALLEL SAFE;
ALTER FUNCTION isnne(ean13, isbn13) PARALLEL SAFE;
ALTER FUNCTION isnlt(ean13, ismn13) PARALLEL SAFE;
ALTER FUNCTION isnle(ean13, ismn13) PARALLEL SAFE;
ALTER FUNCTION isneq(ean13, ismn13) PARALLEL SAFE;
ALTER FUNCTION isnge(ean13, ismn13) PARALLEL SAFE;
ALTER FUNCTION isngt(ean13, ismn13) PARALLEL SAFE;
ALTER FUNCTION isnne(ean13, ismn13) PARALLEL SAFE;
ALTER FUNCTION isnlt(ean13, issn13) PARALLEL SAFE;
ALTER FUNCTION isnle(ean13, issn13) PARALLEL SAFE;
ALTER FUNCTION isneq(ean13, issn13) PARALLEL SAFE;
ALTER FUNCTION isnge(ean13, issn13) PARALLEL SAFE;
ALTER FUNCTION isngt(ean13, issn13) PARALLEL SAFE;
ALTER FUNCTION isnne(ean13, issn13) PARALLEL SAFE;
ALTER FUNCTION isnlt(ean13, isbn) PARALLEL SAFE;
ALTER FUNCTION isnle(ean13, isbn) PARALLEL SAFE;
ALTER FUNCTION isneq(ean13, isbn) PARALLEL SAFE;
ALTER FUNCTION isnge(ean13, isbn) PARALLEL SAFE;
ALTER FUNCTION isngt(ean13, isbn) PARALLEL SAFE;
ALTER FUNCTION isnne(ean13, isbn) PARALLEL SAFE;
ALTER FUNCTION isnlt(ean13, ismn) PARALLEL SAFE;
ALTER FUNCTION isnle(ean13, ismn) PARALLEL SAFE;
ALTER FUNCTION isneq(ean13, ismn) PARALLEL SAFE;
ALTER FUNCTION isnge(ean13, ismn) PARALLEL SAFE;
ALTER FUNCTION isngt(ean13, ismn) PARALLEL SAFE;
ALTER FUNCTION isnne(ean13, ismn) PARALLEL SAFE;
ALTER FUNCTION isnlt(ean13, issn) PARALLEL SAFE;
ALTER FUNCTION isnle(ean13, issn) PARALLEL SAFE;
ALTER FUNCTION isneq(ean13, issn) PARALLEL SAFE;
ALTER FUNCTION isnge(ean13, issn) PARALLEL SAFE;
ALTER FUNCTION isngt(ean13, issn) PARALLEL SAFE;
ALTER FUNCTION isnne(ean13, issn) PARALLEL SAFE;
ALTER FUNCTION isnlt(ean13, upc) PARALLEL SAFE;
ALTER FUNCTION isnle(ean13, upc) PARALLEL SAFE;
ALTER FUNCTION isneq(ean13, upc) PARALLEL SAFE;
ALTER FUNCTION isnge(ean13, upc) PARALLEL SAFE;
ALTER FUNCTION isngt(ean13, upc) PARALLEL SAFE;
ALTER FUNCTION isnne(ean13, upc) PARALLEL SAFE;
ALTER FUNCTION isnlt(isbn13, isbn13) PARALLEL SAFE;
ALTER FUNCTION isnle(isbn13, isbn13) PARALLEL SAFE;
ALTER FUNCTION isneq(isbn13, isbn13) PARALLEL SAFE;
ALTER FUNCTION isnge(isbn13, isbn13) PARALLEL SAFE;
ALTER FUNCTION isngt(isbn13, isbn13) PARALLEL SAFE;
ALTER FUNCTION isnne(isbn13, isbn13) PARALLEL SAFE;
ALTER FUNCTION isnlt(isbn13, isbn) PARALLEL SAFE;
ALTER FUNCTION isnle(isbn13, isbn) PARALLEL SAFE;
ALTER FUNCTION isneq(isbn13, isbn) PARALLEL SAFE;
ALTER FUNCTION isnge(isbn13, isbn) PARALLEL SAFE;
ALTER FUNCTION isngt(isbn13, isbn) PARALLEL SAFE;
ALTER FUNCTION isnne(isbn13, isbn) PARALLEL SAFE;
ALTER FUNCTION isnlt(isbn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnle(isbn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isneq(isbn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnge(isbn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isngt(isbn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnne(isbn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnlt(isbn, isbn) PARALLEL SAFE;
ALTER FUNCTION isnle(isbn, isbn) PARALLEL SAFE;
ALTER FUNCTION isneq(isbn, isbn) PARALLEL SAFE;
ALTER FUNCTION isnge(isbn, isbn) PARALLEL SAFE;
ALTER FUNCTION isngt(isbn, isbn) PARALLEL SAFE;
ALTER FUNCTION isnne(isbn, isbn) PARALLEL SAFE;
ALTER FUNCTION isnlt(isbn, isbn13) PARALLEL SAFE;
ALTER FUNCTION isnle(isbn, isbn13) PARALLEL SAFE;
ALTER FUNCTION isneq(isbn, isbn13) PARALLEL SAFE;
ALTER FUNCTION isnge(isbn, isbn13) PARALLEL SAFE;
ALTER FUNCTION isngt(isbn, isbn13) PARALLEL SAFE;
ALTER FUNCTION isnne(isbn, isbn13) PARALLEL SAFE;
ALTER FUNCTION isnlt(isbn, ean13) PARALLEL SAFE;
ALTER FUNCTION isnle(isbn, ean13) PARALLEL SAFE;
ALTER FUNCTION isneq(isbn, ean13) PARALLEL SAFE;
ALTER FUNCTION isnge(isbn, ean13) PARALLEL SAFE;
ALTER FUNCTION isngt(isbn, ean13) PARALLEL SAFE;
ALTER FUNCTION isnne(isbn, ean13) PARALLEL SAFE;
ALTER FUNCTION isnlt(ismn13, ismn13) PARALLEL SAFE;
ALTER FUNCTION isnle(ismn13, ismn13) PARALLEL SAFE;
ALTER FUNCTION isneq(ismn13, ismn13) PARALLEL SAFE;
ALTER FUNCTION isnge(ismn13, ismn13) PARALLEL SAFE;
ALTER FUNCTION isngt(ismn13, ismn13) PARALLEL SAFE;
ALTER FUNCTION isnne(ismn13, ismn13) PARALLEL SAFE;
ALTER FUNCTION isnlt(ismn13, ismn) PARALLEL SAFE;
ALTER FUNCTION isnle(ismn13, ismn) PARALLEL SAFE;
ALTER FUNCTION isneq(ismn13, ismn) PARALLEL SAFE;
ALTER FUNCTION isnge(ismn13, ismn) PARALLEL SAFE;
ALTER FUNCTION isngt(ismn13, ismn) PARALLEL SAFE;
ALTER FUNCTION isnne(ismn13, ismn) PARALLEL SAFE;
ALTER FUNCTION isnlt(ismn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnle(ismn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isneq(ismn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnge(ismn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isngt(ismn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnne(ismn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnlt(ismn, ismn) PARALLEL SAFE;
ALTER FUNCTION isnle(ismn, ismn) PARALLEL SAFE;
ALTER FUNCTION isneq(ismn, ismn) PARALLEL SAFE;
ALTER FUNCTION isnge(ismn, ismn) PARALLEL SAFE;
ALTER FUNCTION isngt(ismn, ismn) PARALLEL SAFE;
ALTER FUNCTION isnne(ismn, ismn) PARALLEL SAFE;
ALTER FUNCTION isnlt(ismn, ismn13) PARALLEL SAFE;
ALTER FUNCTION isnle(ismn, ismn13) PARALLEL SAFE;
ALTER FUNCTION isneq(ismn, ismn13) PARALLEL SAFE;
ALTER FUNCTION isnge(ismn, ismn13) PARALLEL SAFE;
ALTER FUNCTION isngt(ismn, ismn13) PARALLEL SAFE;
ALTER FUNCTION isnne(ismn, ismn13) PARALLEL SAFE;
ALTER FUNCTION isnlt(ismn, ean13) PARALLEL SAFE;
ALTER FUNCTION isnle(ismn, ean13) PARALLEL SAFE;
ALTER FUNCTION isneq(ismn, ean13) PARALLEL SAFE;
ALTER FUNCTION isnge(ismn, ean13) PARALLEL SAFE;
ALTER FUNCTION isngt(ismn, ean13) PARALLEL SAFE;
ALTER FUNCTION isnne(ismn, ean13) PARALLEL SAFE;
ALTER FUNCTION isnlt(issn13, issn13) PARALLEL SAFE;
ALTER FUNCTION isnle(issn13, issn13) PARALLEL SAFE;
ALTER FUNCTION isneq(issn13, issn13) PARALLEL SAFE;
ALTER FUNCTION isnge(issn13, issn13) PARALLEL SAFE;
ALTER FUNCTION isngt(issn13, issn13) PARALLEL SAFE;
ALTER FUNCTION isnne(issn13, issn13) PARALLEL SAFE;
ALTER FUNCTION isnlt(issn13, issn) PARALLEL SAFE;
ALTER FUNCTION isnle(issn13, issn) PARALLEL SAFE;
ALTER FUNCTION isneq(issn13, issn) PARALLEL SAFE;
ALTER FUNCTION isnge(issn13, issn) PARALLEL SAFE;
ALTER FUNCTION isngt(issn13, issn) PARALLEL SAFE;
ALTER FUNCTION isnne(issn13, issn) PARALLEL SAFE;
ALTER FUNCTION isnlt(issn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnle(issn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isneq(issn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnge(issn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isngt(issn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnne(issn13, ean13) PARALLEL SAFE;
ALTER FUNCTION isnlt(issn, issn) PARALLEL SAFE;
ALTER FUNCTION isnle(issn, issn) PARALLEL SAFE;
ALTER FUNCTION isneq(issn, issn) PARALLEL SAFE;
ALTER FUNCTION isnge(issn, issn) PARALLEL SAFE;
ALTER FUNCTION isngt(issn, issn) PARALLEL SAFE;
ALTER FUNCTION isnne(issn, issn) PARALLEL SAFE;
ALTER FUNCTION isnlt(issn, issn13) PARALLEL SAFE;
ALTER FUNCTION isnle(issn, issn13) PARALLEL SAFE;
ALTER FUNCTION isneq(issn, issn13) PARALLEL SAFE;
ALTER FUNCTION isnge(issn, issn13) PARALLEL SAFE;
ALTER FUNCTION isngt(issn, issn13) PARALLEL SAFE;
ALTER FUNCTION isnne(issn, issn13) PARALLEL SAFE;
ALTER FUNCTION isnlt(issn, ean13) PARALLEL SAFE;
ALTER FUNCTION isnle(issn, ean13) PARALLEL SAFE;
ALTER FUNCTION isneq(issn, ean13) PARALLEL SAFE;
ALTER FUNCTION isnge(issn, ean13) PARALLEL SAFE;
ALTER FUNCTION isngt(issn, ean13) PARALLEL SAFE;
ALTER FUNCTION isnne(issn, ean13) PARALLEL SAFE;
ALTER FUNCTION isnlt(upc, upc) PARALLEL SAFE;
ALTER FUNCTION isnle(upc, upc) PARALLEL SAFE;
ALTER FUNCTION isneq(upc, upc) PARALLEL SAFE;
ALTER FUNCTION isnge(upc, upc) PARALLEL SAFE;
ALTER FUNCTION isngt(upc, upc) PARALLEL SAFE;
ALTER FUNCTION isnne(upc, upc) PARALLEL SAFE;
ALTER FUNCTION isnlt(upc, ean13) PARALLEL SAFE;
ALTER FUNCTION isnle(upc, ean13) PARALLEL SAFE;
ALTER FUNCTION isneq(upc, ean13) PARALLEL SAFE;
ALTER FUNCTION isnge(upc, ean13) PARALLEL SAFE;
ALTER FUNCTION isngt(upc, ean13) PARALLEL SAFE;
ALTER FUNCTION isnne(upc, ean13) PARALLEL SAFE;
ALTER FUNCTION btean13cmp(ean13, ean13) PARALLEL SAFE;
ALTER FUNCTION hashean13(ean13) PARALLEL SAFE;
ALTER FUNCTION btean13cmp(ean13, isbn13) PARALLEL SAFE;
ALTER FUNCTION btean13cmp(ean13, ismn13) PARALLEL SAFE;
ALTER FUNCTION btean13cmp(ean13, issn13) PARALLEL SAFE;
ALTER FUNCTION btean13cmp(ean13, isbn) PARALLEL SAFE;
ALTER FUNCTION btean13cmp(ean13, ismn) PARALLEL SAFE;
ALTER FUNCTION btean13cmp(ean13, issn) PARALLEL SAFE;
ALTER FUNCTION btean13cmp(ean13, upc) PARALLEL SAFE;
ALTER FUNCTION btisbn13cmp(isbn13, isbn13) PARALLEL SAFE;
ALTER FUNCTION hashisbn13(isbn13) PARALLEL SAFE;
ALTER FUNCTION btisbn13cmp(isbn13, ean13) PARALLEL SAFE;
ALTER FUNCTION btisbn13cmp(isbn13, isbn) PARALLEL SAFE;
ALTER FUNCTION btisbncmp(isbn, isbn) PARALLEL SAFE;
ALTER FUNCTION hashisbn(isbn) PARALLEL SAFE;
ALTER FUNCTION btisbncmp(isbn, ean13) PARALLEL SAFE;
ALTER FUNCTION btisbncmp(isbn, isbn13) PARALLEL SAFE;
ALTER FUNCTION btismn13cmp(ismn13, ismn13) PARALLEL SAFE;
ALTER FUNCTION hashismn13(ismn13) PARALLEL SAFE;
ALTER FUNCTION btismn13cmp(ismn13, ean13) PARALLEL SAFE;
ALTER FUNCTION btismn13cmp(ismn13, ismn) PARALLEL SAFE;
ALTER FUNCTION btismncmp(ismn, ismn) PARALLEL SAFE;
ALTER FUNCTION hashismn(ismn) PARALLEL SAFE;
ALTER FUNCTION btismncmp(ismn, ean13) PARALLEL SAFE;
ALTER FUNCTION btismncmp(ismn, ismn13) PARALLEL SAFE;
ALTER FUNCTION btissn13cmp(issn13, issn13) PARALLEL SAFE;
ALTER FUNCTION hashissn13(issn13) PARALLEL SAFE;
ALTER FUNCTION btissn13cmp(issn13, ean13) PARALLEL SAFE;
ALTER FUNCTION btissn13cmp(issn13, issn) PARALLEL SAFE;
ALTER FUNCTION btissncmp(issn, issn) PARALLEL SAFE;
ALTER FUNCTION hashissn(issn) PARALLEL SAFE;
ALTER FUNCTION btissncmp(issn, ean13) PARALLEL SAFE;
ALTER FUNCTION btissncmp(issn, issn13) PARALLEL SAFE;
ALTER FUNCTION btupccmp(upc, upc) PARALLEL SAFE;
ALTER FUNCTION hashupc(upc) PARALLEL SAFE;
ALTER FUNCTION btupccmp(upc, ean13) PARALLEL SAFE;
ALTER FUNCTION isbn13(ean13) PARALLEL SAFE;
ALTER FUNCTION ismn13(ean13) PARALLEL SAFE;
ALTER FUNCTION issn13(ean13) PARALLEL SAFE;
ALTER FUNCTION isbn(ean13) PARALLEL SAFE;
ALTER FUNCTION ismn(ean13) PARALLEL SAFE;
ALTER FUNCTION issn(ean13) PARALLEL SAFE;
ALTER FUNCTION upc(ean13) PARALLEL SAFE;
ALTER FUNCTION make_valid(ean13) PARALLEL SAFE;
ALTER FUNCTION make_valid(isbn13) PARALLEL SAFE;
ALTER FUNCTION make_valid(ismn13) PARALLEL SAFE;
ALTER FUNCTION make_valid(issn13) PARALLEL SAFE;
ALTER FUNCTION make_valid(isbn) PARALLEL SAFE;
ALTER FUNCTION make_valid(ismn) PARALLEL SAFE;
ALTER FUNCTION make_valid(issn) PARALLEL SAFE;
ALTER FUNCTION make_valid(upc) PARALLEL SAFE;
ALTER FUNCTION is_valid(ean13) PARALLEL SAFE;
ALTER FUNCTION is_valid(isbn13) PARALLEL SAFE;
ALTER FUNCTION is_valid(ismn13) PARALLEL SAFE;
ALTER FUNCTION is_valid(issn13) PARALLEL SAFE;
ALTER FUNCTION is_valid(isbn) PARALLEL SAFE;
ALTER FUNCTION is_valid(ismn) PARALLEL SAFE;
ALTER FUNCTION is_valid(issn) PARALLEL SAFE;
ALTER FUNCTION is_valid(upc) PARALLEL SAFE;
ALTER FUNCTION isn_weak(boolean) PARALLEL RESTRICTED;
ALTER FUNCTION isn_weak() PARALLEL RESTRICTED;

228
dist/win-x64/postgres-standalone/share/extension/isn--1.1--1.2.sql vendored Normal file
View File

@@ -0,0 +1,228 @@
/* contrib/isn/isn--1.1--1.2.sql */
-- complain if script is sourced in psql, rather than via ALTER EXTENSION
\echo Use "ALTER EXTENSION isn UPDATE TO '1.2'" to load this file. \quit
ALTER OPERATOR <= (ean13, ean13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ean13, ean13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ean13, isbn13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ean13, isbn13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (isbn13, ean13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (isbn13, ean13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ean13, ismn13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ean13, ismn13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ismn13, ean13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ismn13, ean13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ean13, issn13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ean13, issn13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ean13, isbn) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ean13, isbn) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ean13, ismn) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ean13, ismn) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ean13, issn) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ean13, issn) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ean13, upc) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ean13, upc) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (isbn13, isbn13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (isbn13, isbn13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (isbn13, isbn) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (isbn13, isbn) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (isbn, isbn) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (isbn, isbn) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (isbn, isbn13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (isbn, isbn13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (isbn, ean13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (isbn, ean13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ismn13, ismn13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ismn13, ismn13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ismn13, ismn) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ismn13, ismn) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ismn, ismn) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ismn, ismn) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ismn, ismn13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ismn, ismn13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (ismn, ean13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (ismn, ean13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (issn13, issn13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (issn13, issn13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (issn13, issn) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (issn13, issn) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (issn13, ean13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (issn13, ean13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (issn, issn) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (issn, issn) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (issn, issn13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (issn, issn13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (issn, ean13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (issn, ean13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (upc, upc) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (upc, upc) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);
ALTER OPERATOR <= (upc, ean13) SET (
RESTRICT = scalarlesel,
JOIN = scalarlejoinsel);
ALTER OPERATOR >= (upc, ean13) SET (
RESTRICT = scalargesel,
JOIN = scalargejoinsel);

3434
dist/win-x64/postgres-standalone/share/extension/isn--1.1.sql vendored Normal file
View File

File diff suppressed because it is too large Load Diff

6
dist/win-x64/postgres-standalone/share/extension/isn.control vendored Normal file
View File

@@ -0,0 +1,6 @@
# isn extension
comment = 'data types for international product numbering standards'
default_version = '1.2'
module_pathname = '$libdir/isn'
relocatable = true
trusted = true

19
dist/win-x64/postgres-standalone/share/extension/jsonb_plperl--1.0.sql vendored Normal file
View File

@@ -0,0 +1,19 @@
/* contrib/jsonb_plperl/jsonb_plperl--1.0.sql */
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION jsonb_plperl" to load this file. \quit
CREATE FUNCTION jsonb_to_plperl(val internal) RETURNS internal
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME';
CREATE FUNCTION plperl_to_jsonb(val internal) RETURNS jsonb
LANGUAGE C STRICT IMMUTABLE
AS 'MODULE_PATHNAME';
CREATE TRANSFORM FOR jsonb LANGUAGE plperl (
FROM SQL WITH FUNCTION jsonb_to_plperl(internal),
TO SQL WITH FUNCTION plperl_to_jsonb(internal)
);
COMMENT ON TRANSFORM FOR jsonb LANGUAGE plperl IS 'transform between jsonb and Perl';

Some files were not shown because too many files have changed in this diff Show More