From f0ef7e4b95f437fbc3c4a341201956ce2da4bc08 Mon Sep 17 00:00:00 2001 From: totaj Date: Wed, 11 Oct 2023 14:18:39 +0800 Subject: [PATCH] Upgrade version to 1.2 --- contrib/dolphin/Makefile | 5 +- contrib/dolphin/dolphin.control | 4 +- ...in--1.1--1.0.sql => dolphin--1.2--1.0.sql} | 0 .../rollback_script/dolphin--2.0--1.2.sql | 1922 ++++++++ ...in--1.0--1.1.sql => dolphin--1.0--1.2.sql} | 0 .../upgrade_script/dolphin--1.2--2.0.sql | 4196 +++++++++++++++++ 6 files changed, 6123 insertions(+), 4 deletions(-) rename contrib/dolphin/rollback_script/{dolphin--1.1--1.0.sql => dolphin--1.2--1.0.sql} (100%) create mode 100644 contrib/dolphin/rollback_script/dolphin--2.0--1.2.sql rename contrib/dolphin/upgrade_script/{dolphin--1.0--1.1.sql => dolphin--1.0--1.2.sql} (100%) create mode 100644 contrib/dolphin/upgrade_script/dolphin--1.2--2.0.sql diff --git a/contrib/dolphin/Makefile b/contrib/dolphin/Makefile index 35b0f1db0..80cce9605 100644 --- a/contrib/dolphin/Makefile +++ b/contrib/dolphin/Makefile @@ -131,9 +131,10 @@ clean: extra_clean dolphin--1.0.sql: sql_script/* sql_script_post/* cat $^ > $@ -dolphin--1.1.sql: dolphin--1.0.sql upgrade_script/dolphin--1.0--1.1.sql +dolphin--1.2.sql: dolphin--1.0.sql upgrade_script/dolphin--1.0--1.2.sql cat $^ > $@ -DATA_built = dolphin--1.0.sql dolphin--1.1.sql upgrade_script/dolphin--1.0--1.1.sql rollback_script/dolphin--1.1--1.0.sql openGauss_expr_dolphin.ir +DATA_built = dolphin--1.0.sql dolphin--1.2.sql upgrade_script/dolphin--1.0--1.2.sql rollback_script/dolphin--1.2--1.0.sql openGauss_expr_dolphin.ir +DATA = upgrade_script/dolphin--1.2--2.0.sql rollback_script/dolphin--2.0--1.2.sql OBJS += plugin_postgres.o plugin_postgres.o: plugin_postgres.cpp diff --git a/contrib/dolphin/dolphin.control b/contrib/dolphin/dolphin.control index 91471c504..dfb708e42 100644 --- a/contrib/dolphin/dolphin.control +++ b/contrib/dolphin/dolphin.control @@ -1,5 +1,5 @@ # dolphin extension comment = 'sql engine' -default_version = '1.1' +default_version = '1.2' module_pathname = '$libdir/dolphin' -relocatable = false \ No newline at end of file +relocatable = false diff --git a/contrib/dolphin/rollback_script/dolphin--1.1--1.0.sql b/contrib/dolphin/rollback_script/dolphin--1.2--1.0.sql similarity index 100% rename from contrib/dolphin/rollback_script/dolphin--1.1--1.0.sql rename to contrib/dolphin/rollback_script/dolphin--1.2--1.0.sql diff --git a/contrib/dolphin/rollback_script/dolphin--2.0--1.2.sql b/contrib/dolphin/rollback_script/dolphin--2.0--1.2.sql new file mode 100644 index 000000000..13edc76f5 --- /dev/null +++ b/contrib/dolphin/rollback_script/dolphin--2.0--1.2.sql @@ -0,0 +1,1922 @@ + +--rollback binary/varbinary -> text implicit +DROP OPERATOR IF EXISTS pg_catalog.>=(binary, time) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(binary, numeric) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(binary, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(binary, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(binary, uint4) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(binary, uint8) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.binary_time_ge(binary, time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_numeric_ge(binary, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint1_ge(binary, uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint2_ge(binary, uint2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint4_ge(binary, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint8_ge(binary, uint8) CASCADE; + +DROP OPERATOR IF EXISTS pg_catalog.>=(time, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(numeric, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(uint1, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(uint2, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(uint4, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(uint8, binary) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_binary_ge(time, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_binary_ge(numeric, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint1_binary_ge(uint1, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint2_binary_ge(uint2, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint4_binary_ge(uint4, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint8_binary_ge(uint8, binary) CASCADE; + +DROP OPERATOR IF EXISTS pg_catalog.<=(binary, time) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(binary, numeric) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(binary, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(binary, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(binary, uint4) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(binary, uint8) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.binary_time_le(binary, time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_numeric_le(binary, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint1_le(binary, uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint2_le(binary, uint2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint4_le(binary, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint8_le(binary, uint8) CASCADE; + +DROP OPERATOR IF EXISTS pg_catalog.<=(time, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(numeric, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(uint1, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(uint2, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(uint4, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(uint8, binary) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_binary_le(time, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_binary_le(numeric, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint1_binary_le(uint1, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint2_binary_le(uint2, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint4_binary_le(uint4, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint8_binary_le(uint8, binary) CASCADE; + +DROP OPERATOR IF EXISTS pg_catalog.>(binary, time) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(binary, numeric) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(binary, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(binary, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(binary, uint4) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(binary, uint8) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.binary_time_gt(binary, time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_numeric_gt(binary, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint1_gt(binary, uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint2_gt(binary, uint2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint4_gt(binary, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint8_gt(binary, uint8) CASCADE; + +DROP OPERATOR IF EXISTS pg_catalog.>(time, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(numeric, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(uint1, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(uint2, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(uint4, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(uint8, binary) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_binary_gt(time, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_binary_gt(numeric, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint1_binary_gt(uint1, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint2_binary_gt(uint2, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint4_binary_gt(uint4, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint8_binary_gt(uint8, binary) CASCADE; + +DROP OPERATOR IF EXISTS pg_catalog.<(binary, time) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(binary, numeric) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(binary, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(binary, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(binary, uint4) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(binary, uint8) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.binary_time_lt(binary, time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_numeric_lt(binary, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint1_lt(binary, uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint2_lt(binary, uint2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint4_lt(binary, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint8_lt(binary, uint8) CASCADE; + +DROP OPERATOR IF EXISTS pg_catalog.<(time, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(numeric, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(uint1, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(uint2, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(uint4, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(uint8, binary) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_binary_lt(time, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_binary_lt(numeric, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint1_binary_lt(uint1, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint2_binary_lt(uint2, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint4_binary_lt(uint4, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint8_binary_lt(uint8, binary) CASCADE; + +DROP OPERATOR IF EXISTS pg_catalog.!~~(binary, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.!~~*(binary, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.~~(binary, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.~~*(binary, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.!~~(name, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.!~~*(name, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.~~(name, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.~~*(name, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.!~~(char, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.!~~*(char, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.~~(char, binary) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.~~*(char, binary) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.bpcharbinarylike(char, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bpcharbinarynlike(char, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.namebinarylike(name, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.namebinarynlike(name, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binarylike(binary, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binarynlike(binary, binary) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_ui8(anyelement) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_ui4(anyelement) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_ui2(anyelement) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_ui1(anyelement) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.bit_cast_int8(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float4_cast_int8(float4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float8_cast_int8(float8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_cast_int8(numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.date_cast_int8(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamp_cast_int8(timestamp without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_cast_int8(timestamptz) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_cast_date(time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timetz_cast_date(timetz) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set_cast_int8(anyset) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint8_cast_int8(uint8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_cast_int8(year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_cast_int8(char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_int8(varchar) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.text_cast_int8(text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_int8(anyelement) CASCADE; + + +DROP CAST IF EXISTS ("binary" AS uint1) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS uint1) CASCADE; +DROP CAST IF EXISTS (blob AS uint1) CASCADE; +DROP CAST IF EXISTS (tinyblob AS uint1) CASCADE; +DROP CAST IF EXISTS (mediumblob AS uint1) CASCADE; +DROP CAST IF EXISTS (longblob AS uint1) CASCADE; +DROP CAST IF EXISTS (json AS uint1) CASCADE; +DROP CAST IF EXISTS ("binary" AS uint2) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS uint2) CASCADE; +DROP CAST IF EXISTS (blob AS uint2) CASCADE; +DROP CAST IF EXISTS (tinyblob AS uint2) CASCADE; +DROP CAST IF EXISTS (mediumblob AS uint2) CASCADE; +DROP CAST IF EXISTS (longblob AS uint2) CASCADE; +DROP CAST IF EXISTS (json AS uint2) CASCADE; +DROP CAST IF EXISTS ("binary" AS uint4) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS uint4) CASCADE; +DROP CAST IF EXISTS (blob AS uint4) CASCADE; +DROP CAST IF EXISTS (tinyblob AS uint4) CASCADE; +DROP CAST IF EXISTS (mediumblob AS uint4) CASCADE; +DROP CAST IF EXISTS (longblob AS uint4) CASCADE; +DROP CAST IF EXISTS (json AS uint4) CASCADE; +DROP CAST IF EXISTS ("binary" AS uint8) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS uint8) CASCADE; +DROP CAST IF EXISTS (blob AS uint8) CASCADE; +DROP CAST IF EXISTS (tinyblob AS uint8) CASCADE; +DROP CAST IF EXISTS (mediumblob AS uint8) CASCADE; +DROP CAST IF EXISTS (longblob AS uint8) CASCADE; +DROP CAST IF EXISTS (json AS uint8) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.varlena2ui1(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2ui2(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2ui4(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2ui8(anyelement) cascade; + +DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_ui8(char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_ui4(char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_ui2(char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_ui1(char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.char_cast_ui8(char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.char_cast_ui4(char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.char_cast_ui2(char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.char_cast_ui1(char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_cast_ui8(time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_cast_ui4(time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_cast_ui2(time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_cast_ui1(time) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.-(timestamptz, int4) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.+(timestamptz, int4) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.-(timestamp without time zone, int4) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.+(timestamp without time zone, int4) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.timestamp_add (text, timestamptz, "any") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_format(timestamp without time zone, text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamp_mi_int4(timestamptz, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamp_pl_int4(timestamptz, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_mi_int4(timestamp without time zone, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_pl_int4(timestamp without time zone, int4) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.atan2 (boolean, boolean); +DROP FUNCTION IF EXISTS pg_catalog.atan2 (boolean, float8); +DROP FUNCTION IF EXISTS pg_catalog.atan2 (float8, boolean); +DROP FUNCTION IF EXISTS pg_catalog.atan (float8, float8); +DROP FUNCTION IF EXISTS pg_catalog.atan (boolean, boolean); +DROP FUNCTION IF EXISTS pg_catalog.atan (boolean, float8); +DROP FUNCTION IF EXISTS pg_catalog.atan (float8, boolean); +DROP FUNCTION IF EXISTS pg_catalog.atan (boolean); + +DROP FUNCTION IF EXISTS pg_catalog.dolphin_invoke(); +CREATE FUNCTION pg_catalog.dolphin_invoke() + RETURNS VOID AS '$libdir/dolphin','dolphin_invoke' LANGUAGE C STRICT; + +DROP CAST IF EXISTS (bool AS bit) CASCADE; +DROP CAST IF EXISTS (bool AS float4) CASCADE; +DROP CAST IF EXISTS (bool AS float8) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.booltobit(bool, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.booltofloat4(bool) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.booltofloat8(bool) CASCADE; + +--rollback castcontext +CREATE FUNCTION pg_catalog.rollback_castcontext(varchar, varchar, varchar) RETURNS varchar AS +$$ +DECLARE + s_type ALIAS FOR $1; + t_type ALIAS FOR $2; + context ALIAS FOR $3; +BEGIN + update pg_cast set castcontext=context, castowner=10 where castsource=(select oid from pg_type where typname=s_type) and casttarget=(select oid from pg_type where typname=t_type); + RETURN 'SUCCESS'; +END; +$$ +LANGUAGE plpgsql; + +DO +$$ +BEGIN + PERFORM pg_catalog.rollback_castcontext('int8', 'int1', 'a'); + PERFORM pg_catalog.rollback_castcontext('int8', 'int2', 'a'); + PERFORM pg_catalog.rollback_castcontext('int8', 'int4', 'a'); + + PERFORM pg_catalog.rollback_castcontext('date', 'int4', 'e'); + PERFORM pg_catalog.rollback_castcontext('date', 'int8', 'e'); + PERFORM pg_catalog.rollback_castcontext('date', 'uint4', 'e'); + PERFORM pg_catalog.rollback_castcontext('date', 'uint8', 'e'); + PERFORM pg_catalog.rollback_castcontext('date', 'float4', 'e'); + PERFORM pg_catalog.rollback_castcontext('date', 'float8', 'e'); + PERFORM pg_catalog.rollback_castcontext('date', 'numeric', 'e'); + PERFORM pg_catalog.rollback_castcontext('timestamp', 'int8', 'e'); + PERFORM pg_catalog.rollback_castcontext('timestamp', 'uint8', 'e'); + PERFORM pg_catalog.rollback_castcontext('timestamp', 'float4', 'e'); + PERFORM pg_catalog.rollback_castcontext('timestamp', 'numeric', 'e'); + PERFORM pg_catalog.rollback_castcontext('timestamptz', 'int8', 'e'); + PERFORM pg_catalog.rollback_castcontext('timestamptz', 'uint8', 'e'); + PERFORM pg_catalog.rollback_castcontext('timestamptz', 'float4', 'e'); + PERFORM pg_catalog.rollback_castcontext('timestamptz', 'float8', 'e'); + PERFORM pg_catalog.rollback_castcontext('timestamptz', 'numeric', 'e'); + PERFORM pg_catalog.rollback_castcontext('time', 'int4', 'e'); + PERFORM pg_catalog.rollback_castcontext('time', 'int8', 'e'); + PERFORM pg_catalog.rollback_castcontext('time', 'uint4', 'e'); + PERFORM pg_catalog.rollback_castcontext('time', 'uint8', 'e'); + PERFORM pg_catalog.rollback_castcontext('time', 'float4', 'e'); + PERFORM pg_catalog.rollback_castcontext('time', 'numeric', 'e'); +END +$$ +LANGUAGE plpgsql; + +DROP FUNCTION IF EXISTS pg_catalog.rollback_castcontext(varchar, varchar, varchar) CASCADE; + +--dolphin_binary_function.sql rollback +DROP OPERATOR IF EXISTS pg_catalog.^(blob, date) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(date, blob) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(blob, timestamptz) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(timestamptz, blob) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(time, bit) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(bit, time) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.blob_date_xor( + blob, + date +) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.date_blob_xor( + date, + blob +) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.blob_timestamptz_xor( + blob, + timestamptz +) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_blob_xor( + timestamptz, + blob +) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_xor_bit( + time, + bit +) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bit_xor_time( + bit, + time +) CASCADE; + + +DROP CAST IF EXISTS (bit AS binary) CASCADE; +DROP CAST IF EXISTS (bit AS varbinary) CASCADE; +DROP CAST IF EXISTS (bit AS tinyblob) CASCADE; +DROP CAST IF EXISTS (bit AS mediumblob) CASCADE; +DROP CAST IF EXISTS (bit AS blob) CASCADE; +DROP CAST IF EXISTS (bit AS longblob) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.bittobinary(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittovarbinary(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittotinyblob(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittomediumblob(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittoblob(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittolongblob(bit) CASCADE; + + +DROP CAST IF EXISTS (binary as json) CASCADE; +DROP CAST IF EXISTS (varbinary as json) CASCADE; +DROP CAST IF EXISTS (tinyblob as json) CASCADE; +DROP CAST IF EXISTS (blob as json) CASCADE; +DROP CAST IF EXISTS (mediumblob as json) CASCADE; +DROP CAST IF EXISTS (longblob as json) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.binary_json(binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varbinary_json(varbinary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.tinyblob_json(tinyblob) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.blob_json(blob) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.mediumblob_json(mediumblob) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.longblob_json(longblob) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (tinyblob) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (blob) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (mediumblob) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (longblob) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.varlena_json(anyelement) cascade; + +DROP CAST IF EXISTS (raw AS text); +CREATE CAST (raw AS text) WITH FUNCTION pg_catalog.rawtohex(raw) AS IMPLICIT; + + +DROP CAST IF EXISTS ("binary" AS int1) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS int1) CASCADE; +DROP CAST IF EXISTS (blob AS int1) CASCADE; +DROP CAST IF EXISTS (tinyblob AS int1) CASCADE; +DROP CAST IF EXISTS (mediumblob AS int1) CASCADE; +DROP CAST IF EXISTS (longblob AS int1) CASCADE; +DROP CAST IF EXISTS (json AS int1) CASCADE; +DROP CAST IF EXISTS ("binary" AS int2) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS int2) CASCADE; +DROP CAST IF EXISTS (blob AS int2) CASCADE; +DROP CAST IF EXISTS (tinyblob AS int2) CASCADE; +DROP CAST IF EXISTS (mediumblob AS int2) CASCADE; +DROP CAST IF EXISTS (longblob AS int2) CASCADE; +DROP CAST IF EXISTS (json AS int2) CASCADE; +DROP CAST IF EXISTS ("binary" AS int4) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS int4) CASCADE; +DROP CAST IF EXISTS (blob AS int4) CASCADE; +DROP CAST IF EXISTS (tinyblob AS int4) CASCADE; +DROP CAST IF EXISTS (mediumblob AS int4) CASCADE; +DROP CAST IF EXISTS (longblob AS int4) CASCADE; +DROP CAST IF EXISTS (json AS int4) CASCADE; +DROP CAST IF EXISTS ("binary" AS int8) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS int8) CASCADE; +DROP CAST IF EXISTS (blob AS int8) CASCADE; +DROP CAST IF EXISTS (tinyblob AS int8) CASCADE; +DROP CAST IF EXISTS (mediumblob AS int8) CASCADE; +DROP CAST IF EXISTS (longblob AS int8) CASCADE; +DROP CAST IF EXISTS (json AS int8) CASCADE; +DROP CAST IF EXISTS ("binary" AS float4) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS float4) CASCADE; +DROP CAST IF EXISTS (blob AS float4) CASCADE; +DROP CAST IF EXISTS (tinyblob AS float4) CASCADE; +DROP CAST IF EXISTS (mediumblob AS float4) CASCADE; +DROP CAST IF EXISTS (longblob AS float4) CASCADE; +DROP CAST IF EXISTS (json AS float4) CASCADE; +DROP CAST IF EXISTS ("binary" AS numeric) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS numeric) CASCADE; +DROP CAST IF EXISTS (blob AS numeric) CASCADE; +DROP CAST IF EXISTS (tinyblob AS numeric) CASCADE; +DROP CAST IF EXISTS (mediumblob AS numeric) CASCADE; +DROP CAST IF EXISTS (longblob AS numeric) CASCADE; +DROP CAST IF EXISTS (json AS numeric) CASCADE; +DROP CAST IF EXISTS ("binary" AS char) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS char) CASCADE; +DROP CAST IF EXISTS (blob AS char) CASCADE; +DROP CAST IF EXISTS (tinyblob AS char) CASCADE; +DROP CAST IF EXISTS (mediumblob AS char) CASCADE; +DROP CAST IF EXISTS (longblob AS char) CASCADE; +DROP CAST IF EXISTS (json AS char) CASCADE; +DROP CAST IF EXISTS ("binary" AS varchar) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS varchar) CASCADE; +DROP CAST IF EXISTS (blob AS varchar) CASCADE; +DROP CAST IF EXISTS (tinyblob AS varchar) CASCADE; +DROP CAST IF EXISTS (mediumblob AS varchar) CASCADE; +DROP CAST IF EXISTS (longblob AS varchar) CASCADE; +DROP CAST IF EXISTS (json AS varchar) CASCADE; +DROP CAST IF EXISTS ("binary" AS text) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS text) CASCADE; +DROP CAST IF EXISTS (blob AS text) CASCADE; +DROP CAST IF EXISTS (tinyblob AS text) CASCADE; +DROP CAST IF EXISTS (mediumblob AS text) CASCADE; +DROP CAST IF EXISTS (longblob AS text) CASCADE; +DROP CAST IF EXISTS (json AS text) CASCADE; +DROP CAST IF EXISTS ("binary" AS date) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS date) CASCADE; +DROP CAST IF EXISTS (blob AS date) CASCADE; +DROP CAST IF EXISTS (tinyblob AS date) CASCADE; +DROP CAST IF EXISTS (mediumblob AS date) CASCADE; +DROP CAST IF EXISTS (longblob AS date) CASCADE; +DROP CAST IF EXISTS (json AS date) CASCADE; +DROP CAST IF EXISTS ("binary" AS timestamptz) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS timestamptz) CASCADE; +DROP CAST IF EXISTS (blob AS timestamptz) CASCADE; +DROP CAST IF EXISTS (tinyblob AS timestamptz) CASCADE; +DROP CAST IF EXISTS (mediumblob AS timestamptz) CASCADE; +DROP CAST IF EXISTS (longblob AS timestamptz) CASCADE; +DROP CAST IF EXISTS (json AS timestamptz) CASCADE; +DROP CAST IF EXISTS ("binary" AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS (blob AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS (tinyblob AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS (mediumblob AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS (longblob AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS (json AS timestamp without time zone)CASCADE; +DROP CAST IF EXISTS ("binary" AS time) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS time) CASCADE; +DROP CAST IF EXISTS (blob AS time) CASCADE; +DROP CAST IF EXISTS (tinyblob AS time) CASCADE; +DROP CAST IF EXISTS (mediumblob AS time) CASCADE; +DROP CAST IF EXISTS (longblob AS time) CASCADE; +DROP CAST IF EXISTS (json AS time) CASCADE; +DROP CAST IF EXISTS ("binary" AS year) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS year) CASCADE; +DROP CAST IF EXISTS (blob AS year) CASCADE; +DROP CAST IF EXISTS (tinyblob AS year) CASCADE; +DROP CAST IF EXISTS (mediumblob AS year) CASCADE; +DROP CAST IF EXISTS (longblob AS year) CASCADE; +DROP CAST IF EXISTS (json AS year) CASCADE; +DROP CAST IF EXISTS ("binary" AS bit) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS bit) CASCADE; +DROP CAST IF EXISTS (blob AS bit) CASCADE; +DROP CAST IF EXISTS (tinyblob AS bit) CASCADE; +DROP CAST IF EXISTS (mediumblob AS bit) CASCADE; +DROP CAST IF EXISTS (longblob AS bit) CASCADE; +DROP CAST IF EXISTS (json AS bit) CASCADE; +DROP CAST IF EXISTS ("binary" AS anyset) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS anyset) CASCADE; +DROP CAST IF EXISTS (blob AS anyset) CASCADE; +DROP CAST IF EXISTS (tinyblob AS anyset) CASCADE; +DROP CAST IF EXISTS (mediumblob AS anyset) CASCADE; +DROP CAST IF EXISTS (longblob AS anyset) CASCADE; +DROP CAST IF EXISTS (json AS anyset) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.varlenatoset(anyelement, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Bit(anyelement, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Year(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Time(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Datetime(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Timestamptz(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Date(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Text(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Varchar(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Bpchar(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2numeric(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2float4(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2int8(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2int4(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2int2(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2int1(anyelement) cascade; + +DROP CAST IF EXISTS (json AS float8) CASCADE; + +--unsigned.sql rollback +DO $for_og_310$ +BEGIN + if working_version_num() > 92780 then + CREATE CAST (json AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement); + --DROP FUNCTION IF EXISTS pg_catalog.bit_longblob(uint8,longblob) CASCADE; + CREATE OR REPLACE FUNCTION pg_catalog.bit_longblob (t1 uint8, t2 longblob) RETURNS uint8 AS + $$ + DECLARE num NUMBER := to_number(unhex(substring(cast(t2 as text), 3))); + BEGIN + IF num > 9223372036854775807 then + num = 9223372036854775807; + ELSEIF num < -9223372036854775808 then + num = 9223372036854775808; + END IF; + RETURN (SELECT uint8_xor(t1, num)); + END; + $$ + LANGUAGE plpgsql; + end if; +END +$for_og_310$; + +--DROP FUNCTION IF EXISTS pg_catalog.bit2float4(bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bit2float4 (bit) RETURNS float4 AS +$$ +BEGIN + RETURN (SELECT int4($1)); +END; +$$ +LANGUAGE plpgsql; + +--DROP FUNCTION IF EXISTS pg_catalog.bit2float8(bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bit2float8 (bit) RETURNS float8 AS +$$ +BEGIN + RETURN (SELECT int8($1)); +END; +$$ +LANGUAGE plpgsql; + +--DROP FUNCTION IF EXISTS pg_catalog.varbinary_in(cstring) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.varbinary_in ( +cstring +) RETURNS varbinary LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteain'; + +DROP OPERATOR IF EXISTS pg_catalog.&(uint4, year) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.&(year, uint4) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.&(uint4, nvarchar2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.&(nvarchar2, uint4) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(uint4, year) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(year, uint4) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.|(uint4, year) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.|(year, uint4) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.|(uint4, nvarchar2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.|(nvarchar2, uint4) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.%(uint4, year) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.&(year, int8) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.&(nvarchar2, int8) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.&(int8, year) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.&(int8, nvarchar2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.#(year, int8) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.#(int8, year) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(year, int8) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(int8, year) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.#(nvarchar2, int8) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.#(int8, nvarchar2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.|(year, int8) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.|(nvarchar2, int8) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.|(int8, year) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.|(int8, nvarchar2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.%(int8, year) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(time, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(time, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(date, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>=(date, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(time, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(time, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(date, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<=(date, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(time, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(time, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(date, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.>(date, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(time, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(time, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(date, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<(date, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<>(uint2, time) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<>(uint1, time) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<>(uint2, date) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<>(uint1, date) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<>(time, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<>(time, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<>(date, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.<>(date, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.=(time, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.=(time, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.=(date, uint2) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.=(date, uint1) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(timestampTz, uint8) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(uint8, timestampTz) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(timestamp without time zone, uint8) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(uint8, timestamp without time zone) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(time, uint8) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(uint8, time) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(date, uint8) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(uint8, date) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_int8_xor( + date, + uint8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_date_xor( + uint8, + date +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_int8_xor( + time, + uint8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_time_xor( + uint8, + time +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.datetime_int8_xor( + timestamp without time zone, + uint8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_datetime_xor( + uint8, + timestamp without time zone +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int8_xor( + timestampTz, + uint8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_timestamptz_xor( + uint8, + timestampTz +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint1_eq( + date, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint2_eq( + date, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint1_eq( + time, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint2_eq( + time, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint1_ne( + date, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint2_ne( + date, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint1_ne( + time, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint2_ne( + time, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint1_date_ne( + uint1, + date +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint2_date_ne( + uint2, + date +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint1_time_ne( + uint1, + time +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint2_time_ne( + uint2, + time +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint1_lt( + date, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint2_lt( + date, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint1_lt( + time, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint2_lt( + time, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint1_gt( + date, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint2_gt( + date, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint1_gt( + time, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint2_gt( + time, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint1_le( + date, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint2_le( + date, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint1_le( + time, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint2_le( + time, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint1_ge( + date, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint2_ge( + date, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint1_ge( + time, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint2_ge( + time, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_year_mod( + int8, + year +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_or_nvarchar2( + int8, + nvarchar2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_or_year( + int8, + year +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_or_int8( + nvarchar2, + int8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.year_or_int8( + year, + int8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_xor_nvarchar2( + int8, + nvarchar2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_xor_year( + int8, + year +) CASCADE; + + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_xor_int8( + nvarchar2, + int8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.year_xor_int8( + year, + int8 +) CASCADE; + + +DROP FUNCTION IF EXISTS pg_catalog.int8_and_nvarchar2( + int8, + nvarchar2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_and_year( + int8, + year +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_and_int8( + nvarchar2, + int8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.year_and_int8( + year, + int8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint4_mod_year( + uint4, + year +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_or_uint4( + nvarchar2, + uint4 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint4_or_nvarchar2( + uint4, + nvarchar2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.year_or_uint4( + year, + uint4 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint4_or_year( + uint4, + year +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.year_xor_uint4( + year, + uint4 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint4_xor_year( + uint4, + year +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_and_uint4( + nvarchar2, + uint4 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint4_and_nvarchar2( + uint4, + nvarchar2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.year_and_uint4( + year, + uint4 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint4_and_year( + uint4, + year +) CASCADE; + + +DROP FUNCTION IF EXISTS pg_catalog.enum_uint1(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_uint2(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_uint4(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_uint8(anyenum) cascade; + +DROP FUNCTION IF EXISTS pg_catalog.uint1_enum(uint1, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.uint2_enum(uint2, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.uint4_enum(uint4, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.uint8_enum(uint8, int4, anyelement) cascade; + +DROP CAST IF EXISTS (int1 AS anyset) CASCADE; +DROP CAST IF EXISTS (uint1 AS anyset) CASCADE; +DROP CAST IF EXISTS (uint2 AS anyset) CASCADE; +DROP CAST IF EXISTS (uint4 AS anyset) CASCADE; +DROP CAST IF EXISTS (uint8 AS anyset) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.set(int1, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(uint1, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(uint2, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(uint4, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(uint8, int4) CASCADE; + +DROP CAST IF EXISTS (anyset AS bit) CASCADE; +DROP CAST IF EXISTS (anyset AS int1) CASCADE; +DROP CAST IF EXISTS (anyset AS uint1) CASCADE; +DROP CAST IF EXISTS (anyset AS uint2) CASCADE; +DROP CAST IF EXISTS (anyset AS uint4) CASCADE; +DROP CAST IF EXISTS (anyset AS uint8) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.settobit(anyset, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.settoint1(anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.settouint1(anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.settouint2(anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.settouint4(anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.settouint8(anyset) cascade; + +DROP CAST IF EXISTS (char AS uint1) CASCADE; +DROP CAST IF EXISTS (char AS uint2) CASCADE; +DROP CAST IF EXISTS (char AS uint4) CASCADE; +DROP CAST IF EXISTS (char AS uint8) CASCADE; +DROP CAST IF EXISTS (varchar AS uint1) CASCADE; +DROP CAST IF EXISTS (varchar AS uint2) CASCADE; +DROP CAST IF EXISTS (varchar AS uint4) CASCADE; +DROP CAST IF EXISTS (varchar AS uint8) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.bpchar_uint1 (char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_uint2 (char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_uint4 (char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_uint8 (char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_uint1 (varchar) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_uint2 (varchar) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_uint4 (varchar) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_uint8 (varchar) CASCADE; + +DROP CAST IF EXISTS (bit AS uint1) CASCADE; +DROP CAST IF EXISTS (bit AS uint2) CASCADE; +DROP CAST IF EXISTS (uint1 AS bit) CASCADE; +DROP CAST IF EXISTS (uint2 AS bit) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.bittouint1(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittouint2(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromuint1(uint1, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromuint2(uint2, int4) CASCADE; + +DROP CAST IF EXISTS (uint1 as json) cascade; +DROP CAST IF EXISTS (uint2 as json) cascade; +DROP CAST IF EXISTS (uint4 as json) cascade; +DROP CAST IF EXISTS (uint8 as json) cascade; + +DROP FUNCTION IF EXISTS pg_catalog.uint1_json(uint1) cascade; +DROP FUNCTION IF EXISTS pg_catalog.uint2_json(uint2) cascade; +DROP FUNCTION IF EXISTS pg_catalog.uint4_json(uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.uint8_json(uint8) cascade; + +DROP CAST IF EXISTS (uint8 AS year) CASCADE; +DROP CAST IF EXISTS (year AS uint1) CASCADE; +DROP CAST IF EXISTS (year AS uint2) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int64_year(uint8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_uint1(year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_uint2(year) CASCADE; + +DROP CAST IF EXISTS ("timestamptz" AS uint1) CASCADE; +DROP CAST IF EXISTS ("timestamptz" AS uint2) CASCADE; +DROP CAST IF EXISTS ("timestamptz" AS uint4) CASCADE; +DROP CAST IF EXISTS (uint1 AS year) CASCADE; +DROP CAST IF EXISTS (uint2 AS year) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_uint1 ("timestamptz") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_uint2 ("timestamptz") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_uint4 ("timestamptz") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int8_year(uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_year(uint2) CASCADE; + +DROP CAST IF EXISTS (timestamp(0) without time zone AS uint1) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS uint2) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS uint4) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS uint8) CASCADE; +DROP CAST IF EXISTS (uint1 AS timestamptz) CASCADE; +DROP CAST IF EXISTS (uint2 AS timestamptz) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.datetime_uint1 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_uint2 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_uint4 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_uint8 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_timestamp(uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_timestamp(uint2) CASCADE; + +DROP CAST IF EXISTS (uint8 AS time) CASCADE; +DROP CAST IF EXISTS (time AS uint1) CASCADE; +DROP CAST IF EXISTS (time AS uint2) CASCADE; +DROP CAST IF EXISTS (time AS uint4) CASCADE; +DROP CAST IF EXISTS (time AS uint8) CASCADE; +DROP CAST IF EXISTS (uint1 AS timestamp(0) without time zone) CASCADE; +DROP CAST IF EXISTS (uint2 AS timestamp(0) without time zone) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_time ( +uint4 +) RETURNS time LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int32_b_format_time'; + +DROP FUNCTION IF EXISTS pg_catalog.int64_b_format_time(uint8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_uint1 (time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_uint2 (time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_uint4 (time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_uint8 (time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_datetime(uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_datetime(uint2) CASCADE; + +DROP CAST IF EXISTS (uint8 AS date) CASCADE; +DROP CAST IF EXISTS ("date" as uint1) CASCADE; +DROP CAST IF EXISTS ("date" as uint2) CASCADE; +DROP CAST IF EXISTS ("date" as uint4) CASCADE; +DROP CAST IF EXISTS ("date" as uint8) CASCADE; +DROP CAST IF EXISTS (uint1 AS time) CASCADE; +DROP CAST IF EXISTS (uint2 AS time) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int64_b_format_date (uint8) cascade; +DROP FUNCTION IF EXISTS pg_catalog.date2uint1("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.date2uint2("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.date2uint4("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.date2uint8("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_time(uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_time(uint2) CASCADE; + +DROP CAST IF EXISTS (uint1 AS date) CASCADE; +DROP CAST IF EXISTS (uint2 AS date) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_date (uint1) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_date (uint2) cascade; + +--to_base64.sql rollback +DROP CAST IF EXISTS (bit as json); +DROP FUNCTION IF EXISTS pg_catalog.bit_json (bit) CASCADE; + +--json.sql rollback +DROP CAST IF EXISTS (year as json) cascade; +DROP FUNCTION IF EXISTS pg_catalog.year_json(year) cascade; + +DROP CAST IF EXISTS (int1 as json) cascade; +DROP CAST IF EXISTS (int2 as json) cascade; +DROP CAST IF EXISTS (int4 as json) cascade; +DROP CAST IF EXISTS (int8 as json) cascade; +DROP CAST IF EXISTS (float4 as json) cascade; +DROP CAST IF EXISTS (float8 as json) cascade; +DROP CAST IF EXISTS (numeric as json) cascade; +DROP CAST IF EXISTS (date as json) cascade; +DROP CAST IF EXISTS (timestamp without time zone as json) cascade; +DROP CAST IF EXISTS (timestamptz as json) cascade; +DROP CAST IF EXISTS (time as json) cascade; +DROP CAST IF EXISTS (anyset as json) cascade; + +DROP FUNCTION IF EXISTS pg_catalog.int1_json(int1) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int2_json(int2) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int4_json(int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int8_json(int8) cascade; +DROP FUNCTION IF EXISTS pg_catalog.float4_json(float4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.float8_json(float8) cascade; +DROP FUNCTION IF EXISTS pg_catalog.numeric_json(numeric) cascade; +DROP FUNCTION IF EXISTS pg_catalog.date_json(date) cascade; +DROP FUNCTION IF EXISTS pg_catalog.datetime_json(timestamp without time zone) cascade; +DROP FUNCTION IF EXISTS pg_catalog.timestamp_json(timestamptz) cascade; +DROP FUNCTION IF EXISTS pg_catalog.time_json(time) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set_json(anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_varlena(anyenum) cascade; + +--enum.sql rollback +DROP FUNCTION IF EXISTS pg_catalog.year_enum(year, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.bit_enum(bit, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.numeric_enum(numeric, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.float8_enum(float8, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.float4_enum(float4, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int8_enum(int8, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int4_enum(int4, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int2_enum(int2, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int1_enum(int1, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.time_enum(time, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.timestamp_enum(timestamptz, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.datetime_enum(timestamp without time zone, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.date_enum(date, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set_enum(anyset, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena_enum(anyelement, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varchar_enum(varchar, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_enum(char, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.text_enum(text, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_json(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_set(anyenum, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_year(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_time(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_timestamptz(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_timestamp(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_date(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_bit(anyenum, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_float4(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_numeric(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_int8(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_int4(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_int2(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_int1(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_float8(anyenum) cascade; + +DO $for_og_310$ +BEGIN + if working_version_num() > 92780 then + DROP FUNCTION IF EXISTS pg_catalog.enum2float8(anyenum) cascade; + CREATE OR REPLACE FUNCTION pg_catalog.enum2float8(anyenum) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'Enum2Float8'; + + INSERT INTO pg_catalog.pg_cast + -- castsource is anyenum(3500), casttarget(701) is float8, castowner is 10(superuser) + SELECT 3500, 701, oid, 'i', 'f', 10 + FROM pg_proc WHERE + proname = 'enum2float8' AND + -- namespace is pg_catalog + pronamespace = 11 AND + -- input arg is anyenum + proargtypes='3500' AND + -- return type is float8 + prorettype = 701; + end if; +END +$for_og_310$; + +--dolphin_time_functions.sql rollback +DROP OPERATOR IF EXISTS pg_catalog.^(time, timestampTz) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(timestampTz, time) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(boolean, date) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(boolean, timestamptz) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(date, boolean) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.^(timestamptz, boolean) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.-(nvarchar2, time) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.+(nvarchar2, time) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.+(date, numeric) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.-(date, numeric) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.*(time, numeric) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog./(time, numeric) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.*(timestamp without time zone, numeric) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog./(timestamp without time zone, numeric) CASCADE; +DROP OPERATOR IF EXISTS pg_catalog.*(timestamp without time zone, int4) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.b_db_date(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.dayname(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.b_db_last_day(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.week(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.yearweek(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.adddate(date, interval) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.date_add(date, interval) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.date_sub(date, interval) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_timestamptz_xor(time, timestamptz) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_time_xor(timestamptz, time) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.bool_date_xor(boolean, date) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.bool_timestamptz_xor(boolean, timestamptz) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_bool_xor(date, boolean) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_bool_xor(timestamptz, boolean) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_mi_time(nvarchar2, time) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_pl_time(nvarchar2, time) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_add_numeric(date, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_sub_numeric(date, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_mul_numeric(time, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_div_numeric(time, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.datetime_mul_numeric(timestamp without time zone, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.datetime_div_numeric(timestamp without time zone, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.datetime_mul_int4(timestamp without time zone, int4) CASCADE; + +DROP CAST IF EXISTS (year AS anyset) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(year, int4) cascade; + +DROP CAST IF EXISTS (time AS anyset) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(time, int4) cascade; + +DROP CAST IF EXISTS (timestamptz AS anyset) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(timestamptz, int4) cascade; + +DROP CAST IF EXISTS (timestamp without time zone AS anyset) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(timestamp without time zone, int4) cascade; + +DROP CAST IF EXISTS (date AS anyset) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set (date, int4) cascade; + +DROP CAST IF EXISTS (anyset as year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set_year (anyset) cascade; + +DROP CAST IF EXISTS (anyset as time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set_time (anyset) cascade; + +DROP CAST IF EXISTS (anyset as timestamptz) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set_timestamp (anyset) cascade; + +DROP CAST IF EXISTS (anyset as timestamp without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set_datetime (anyset) cascade; + +DROP CAST IF EXISTS (anyset as date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set_date (anyset) cascade; + +DROP CAST IF EXISTS (year AS bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromyear(year, int4) cascade; + +DROP CAST IF EXISTS (time AS char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_bpchar (time) cascade; + +DROP CAST IF EXISTS (time AS varchar) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_varchar (time) cascade; + +DROP CAST IF EXISTS (timestamptz AS char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_bpchar (timestamptz) cascade; + +DROP CAST IF EXISTS (timestamptz AS varchar) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_varchar (timestamptz) cascade; + +DROP CAST IF EXISTS (timestamp without time zone AS char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamp_bpchar (timestamp without time zone) cascade; + +DROP CAST IF EXISTS (varchar as time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_time (varchar) cascade; + +DROP CAST IF EXISTS (char as time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_time (char) cascade; + +DROP CAST IF EXISTS (varchar AS timestamptz) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_timestamptz (varchar) cascade; + +DROP CAST IF EXISTS (char AS timestamptz) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_timestamptz (char) cascade; + +DROP CAST IF EXISTS (time AS timestamptz) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_timestamp (time) cascade; + +DROP CAST IF EXISTS (time AS timestamp without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_datetime (time) cascade; + +DROP CAST IF EXISTS (time AS date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_date (time) cascade; + +DROP CAST IF EXISTS (date AS time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.date_time (date) cascade; + +DROP CAST IF EXISTS (date AS year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.date_year(date) cascade; + +DROP CAST IF EXISTS (time AS year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_year(time) cascade; + +DROP CAST IF EXISTS (timestamptz AS year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamp_year(timestamptz) cascade; + +DROP CAST IF EXISTS (timestamp(0) without time zone AS year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_year(timestamp(0) without time zone) cascade; + +DROP CAST IF EXISTS (year AS time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_time("year") cascade; + +DROP CAST IF EXISTS (year AS timestamptz) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_timestamp("year") cascade; + +DROP CAST IF EXISTS (year AS timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_datetime("year") cascade; + +DROP CAST IF EXISTS (year AS date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_date("year") cascade; + + +DROP CAST IF EXISTS ("date" as int1) CASCADE; +DROP CAST IF EXISTS ("date" as int2) CASCADE; +DROP CAST IF EXISTS ("date" as float4) CASCADE; +DROP CAST IF EXISTS (year AS float4) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date2int1("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.date2int2("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.date2float4("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.year_float4("year") cascade; + +DROP CAST IF EXISTS ("timestamptz" AS int1) CASCADE; +DROP CAST IF EXISTS ("timestamptz" AS int2) CASCADE; +DROP CAST IF EXISTS ("timestamptz" AS int4) CASCADE; +DROP CAST IF EXISTS ("timestamptz" AS float4) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int1 ("timestamptz") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int2 ("timestamptz") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int4 ("timestamptz") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_float4 ("timestamptz") CASCADE; + +DROP CAST IF EXISTS (timestamp(0) without time zone AS int1) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS int2) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS int4) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS float4) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.datetime_int1 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_int2 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_int4 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_float4 (timestamp(0) without time zone) CASCADE; + +DROP CAST IF EXISTS (time AS int1) CASCADE; +DROP CAST IF EXISTS (time AS int2) CASCADE; +DROP CAST IF EXISTS (time AS float4) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_int1 (time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_int2 (time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_float4 (time) CASCADE; + +DROP CAST IF EXISTS (float4 AS timestamptz) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float4_b_format_timestamp (float4) CASCADE; + +DROP CAST IF EXISTS (int1 AS timestamptz) CASCADE; +DROP CAST IF EXISTS (int2 AS timestamptz) CASCADE; +DROP CAST IF EXISTS (float8 AS timestamptz) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_timestamp (int1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_timestamp (int2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float8_b_format_timestamp (float8) CASCADE; + +DROP CAST IF EXISTS (float4 AS timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float4_b_format_datetime (float4) CASCADE; + +DROP CAST IF EXISTS (int1 AS timestamp(0) without time zone) CASCADE; +DROP CAST IF EXISTS (int2 AS timestamp(0) without time zone) CASCADE; +DROP CAST IF EXISTS (float8 AS timestamp(0) without time zone) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_datetime (int1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_datetime (int2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float8_b_format_datetime (float8) CASCADE; + +DROP CAST IF EXISTS (float4 AS time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float4_b_format_time (float4) CASCADE; + +DROP CAST IF EXISTS (int1 AS time) CASCADE; +DROP CAST IF EXISTS (int2 AS time) CASCADE; +DROP CAST IF EXISTS (float8 AS time) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_time (int1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_time (int2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float8_b_format_time (float8) CASCADE; + +DROP CAST IF EXISTS (float4 AS date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float4_b_format_date (float4) CASCADE; + +DROP CAST IF EXISTS (bit AS time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittotime(bit) CASCADE; + +DROP CAST IF EXISTS (bit AS timestamptz) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittotimestamp(bit) CASCADE; + +DROP CAST IF EXISTS (bit AS timestamp without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittodatetime(bit) CASCADE; + +DROP CAST IF EXISTS (bit AS date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittodate(bit) CASCADE; + +DROP CAST IF EXISTS (int1 AS date) CASCADE; +DROP CAST IF EXISTS (int2 AS date) CASCADE; +DROP CAST IF EXISTS (int8 AS date) CASCADE; +DROP CAST IF EXISTS (numeric AS date) CASCADE; +DROP CAST IF EXISTS (float8 AS date) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_date (int1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_date (int2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int64_b_format_date (int8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_b_format_date (numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float8_b_format_date (float8) CASCADE; + +DROP CAST IF EXISTS (bit AS year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bit_year (bit) CASCADE; + +DROP CAST IF EXISTS (float8 AS year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float8_year (float8) CASCADE; + +DROP CAST IF EXISTS (float4 AS year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float4_year (float4) CASCADE; + +DROP CAST IF EXISTS (numeric AS year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_year (numeric) CASCADE; + +DROP CAST IF EXISTS (year AS int8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_int64 (year) CASCADE; + +DROP CAST IF EXISTS (year AS int2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_int16 (year) CASCADE; + +DROP CAST IF EXISTS (year AS int1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_int8 (year) CASCADE; + +DROP CAST IF EXISTS (int8 AS year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int64_year (int8) CASCADE; + +DROP CAST IF EXISTS (int2 AS year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_year (int2) CASCADE; + +DROP CAST IF EXISTS (int1 AS year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int8_year (int1) CASCADE; + +--bit_functions.sql rollback +DROP CAST IF EXISTS (bit AS anyset) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(bit, int4) CASCADE; + +DROP CAST IF EXISTS (time as bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromtime(time, int4) CASCADE; + +DROP CAST IF EXISTS (timestamptz as bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromtimestamp(timestamptz, int4) CASCADE; + +DROP CAST IF EXISTS (timestamp without time zone as bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromdatetime(timestamp without time zone, int4) CASCADE; + +DROP CAST IF EXISTS (date as bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromdate(date, int4) CASCADE; + +DROP CAST IF EXISTS (float8 as bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromfloat8(float8, int4) CASCADE; + +DROP CAST IF EXISTS (float4 as bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromfloat4(float4, int4) CASCADE; + +DROP CAST IF EXISTS (numeric as bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromnumeric(numeric, int4) CASCADE; + +DROP CAST IF EXISTS (bit AS varchar) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittovarchar(bit, int4) CASCADE; + +DROP CAST IF EXISTS (bit AS char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittochar(bit, int4) CASCADE; + +DROP CAST IF EXISTS (bit AS text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittotext(bit) CASCADE; + +drop CAST IF EXISTS (bit AS int1) CASCADE; +drop CAST IF EXISTS (bit AS int2) CASCADE; +drop CAST IF EXISTS (int1 AS bit) CASCADE; +drop CAST IF EXISTS (int2 AS bit) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.bittoint1(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittoint2(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromint1(int1, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromint2(int2, int4) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.ord(varbit); +DROP FUNCTION IF EXISTS pg_catalog.oct(bit); +DROP FUNCTION IF EXISTS pg_catalog.substring_index ("any", "any", text); +DROP FUNCTION IF EXISTS pg_catalog.substring_index ("any", "any", numeric); + +DO $for_og_310$ +BEGIN + if working_version_num() > 92780 then + DROP FUNCTION IF EXISTS pg_catalog.substring_index (text, text, numeric) CASCADE; + CREATE FUNCTION pg_catalog.substring_index ( + text, + text, + numeric + ) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index'; + + DROP FUNCTION IF EXISTS pg_catalog.substring_index (boolean, text, numeric) CASCADE; + CREATE FUNCTION pg_catalog.substring_index ( + boolean, + text, + numeric + ) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_bool_1'; + + DROP FUNCTION IF EXISTS pg_catalog.substring_index (text, boolean, numeric) CASCADE; + CREATE FUNCTION pg_catalog.substring_index ( + text, + boolean, + numeric + ) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_bool_2'; + + DROP FUNCTION IF EXISTS pg_catalog.substring_index (boolean, boolean, numeric) CASCADE; + CREATE FUNCTION pg_catalog.substring_index ( + boolean, + boolean, + numeric + ) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_2bool'; + DROP FUNCTION IF EXISTS pg_catalog.bit_count(numeric) CASCADE; + CREATE OR REPLACE FUNCTION pg_catalog.bit_count (numeric) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_numeric'; + + DROP FUNCTION IF EXISTS pg_catalog.bit_count(text) CASCADE; + CREATE OR REPLACE FUNCTION pg_catalog.bit_count (text) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_text'; + + DROP FUNCTION IF EXISTS pg_catalog.bit_count_bit(text) CASCADE; + CREATE OR REPLACE FUNCTION pg_catalog.bit_count_bit (text) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_bit'; + + DROP FUNCTION IF EXISTS pg_catalog.bit_count(bit) CASCADE; + CREATE OR REPLACE FUNCTION pg_catalog.bit_count (bit) RETURNS int8 AS $$ SELECT pg_catalog.bit_count_bit(cast($1 as text)) $$ LANGUAGE SQL; + + DROP FUNCTION IF EXISTS pg_catalog.connection_id() CASCADE; + CREATE OR REPLACE FUNCTION pg_catalog.connection_id() + RETURNS int8 AS + $$ + BEGIN + RETURN (select pg_backend_pid()); + END; + $$ + LANGUAGE plpgsql; + end if; +END +$for_og_310$; + +DROP FUNCTION IF EXISTS pg_catalog.conv(date, int4, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.conv(timestamp without time zone, int4, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.conv(timestamptz, int4, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.conv(time, int4, int4) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.oct(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(timestamp without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(timestamptz) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(boolean) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.bit_count(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (boolean) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.unhex (bit) CASCADE; + +DO $for_og_310$ +BEGIN + if working_version_num() > 92780 then + DROP FUNCTION IF EXISTS pg_catalog.system_user() CASCADE; + + CREATE OR REPLACE FUNCTION pg_catalog.system_user () + RETURNS text + AS + $$ + BEGIN + RETURN (SELECT session_user); + END; + $$ + LANGUAGE plpgsql; + DROP FUNCTION IF EXISTS pg_catalog.schema() CASCADE; + CREATE OR REPLACE FUNCTION pg_catalog.schema () + RETURNS text + AS + $$ + BEGIN + RETURN (SELECT CURRENT_SCHEMA()); + END; + $$ + LANGUAGE plpgsql; + DROP FUNCTION IF EXISTS pg_catalog.from_base64 (text) CASCADE; + DROP FUNCTION IF EXISTS pg_catalog.from_base64 (bool) CASCADE; + DROP FUNCTION IF EXISTS pg_catalog.from_base64 (bit) CASCADE; + CREATE OR REPLACE FUNCTION pg_catalog.from_base64 (text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_decode'; + + CREATE OR REPLACE FUNCTION pg_catalog.from_base64 (bool1 bool) + RETURNS text + AS + $$ + BEGIN + RETURN (SELECT from_base64('')); + END; + $$ + LANGUAGE plpgsql; + + CREATE OR REPLACE FUNCTION pg_catalog.from_base64(bit1 bit) + RETURNS text + AS + $$ + BEGIN + RETURN (SELECT from_base64(encode((decode(hex(bit1), 'hex')), 'escape'))); + END; + $$ + LANGUAGE plpgsql; + + DROP FUNCTION IF EXISTS pg_catalog.oct(text) CASCADE; + DROP FUNCTION IF EXISTS pg_catalog.oct(boolean) CASCADE; + DROP FUNCTION IF EXISTS pg_catalog.oct(bit) CASCADE; + + CREATE OR REPLACE FUNCTION pg_catalog.oct(t1 text) RETURNS text AS + $$ + BEGIN + RETURN (SELECT conv(t1, 10, 8)); + END; + $$ + LANGUAGE plpgsql; + + CREATE OR REPLACE FUNCTION pg_catalog.oct(t1 bit) RETURNS text AS + $$ + BEGIN + RETURN (SELECT conv(t1, 10, 8)); + END; + $$ + LANGUAGE plpgsql; + + CREATE OR REPLACE FUNCTION pg_catalog.oct(t1 boolean) RETURNS text AS + $$ + BEGIN + RETURN int4(t1); + END; + $$ + LANGUAGE plpgsql; + DROP FUNCTION IF EXISTS pg_catalog.to_base64 (bytea) CASCADE; + DROP FUNCTION IF EXISTS pg_catalog.to_base64 (numeric) CASCADE; + DROP FUNCTION IF EXISTS pg_catalog.to_base64 (text) CASCADE; + DROP FUNCTION IF EXISTS pg_catalog.to_base64 (bit) CASCADE; + CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (bytea) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode'; + + CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (num1 numeric) + RETURNS text + AS + $$ + BEGIN + RETURN (SELECT to_base64(cast(to_char(num1) AS bytea))); + END; + $$ + LANGUAGE plpgsql; + + CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (t1 text) + RETURNS text + AS + $$ + BEGIN + RETURN (SELECT to_base64(cast(t1 AS bytea))); + END; + $$ + LANGUAGE plpgsql; + + CREATE OR REPLACE FUNCTION pg_catalog.to_base64(bit1 bit) + RETURNS text + AS + $$ + BEGIN + RETURN (SELECT to_base64((decode(hex(bit1), 'hex')))); + END; + $$ + LANGUAGE plpgsql; + + DROP FUNCTION IF EXISTS pg_catalog.unhex (text) CASCADE; + DROP FUNCTION IF EXISTS pg_catalog.unhex (numeric) CASCADE; + DROP FUNCTION IF EXISTS pg_catalog.unhex (bool) CASCADE; + DROP FUNCTION IF EXISTS pg_catalog.unhex (boolean) CASCADE; + DROP FUNCTION IF EXISTS pg_catalog.unhex (bytea) CASCADE; + DROP FUNCTION IF EXISTS pg_catalog.unhex ("timestamp") CASCADE; + + CREATE OR REPLACE FUNCTION pg_catalog.unhex (text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'unhex'; + + CREATE OR REPLACE FUNCTION pg_catalog.unhex (num1 numeric) + RETURNS text + AS + $$ + BEGIN + RETURN (SELECT unhex(to_char(num1))); + END; + $$ + LANGUAGE plpgsql; + + CREATE OR REPLACE FUNCTION pg_catalog.unhex (bool1 bool) + RETURNS text + AS + $$ + BEGIN + RETURN (SELECT unhex(cast(bool1 AS numeric))); + END; + $$ + LANGUAGE plpgsql; + + CREATE OR REPLACE FUNCTION pg_catalog.unhex (bin1 bytea) + RETURNS text + AS + $$ + BEGIN + RETURN NULL; + END; + $$ + LANGUAGE plpgsql; + + CREATE OR REPLACE FUNCTION pg_catalog.unhex (datetime1 "timestamp") + RETURNS text + AS + $$ + BEGIN + RETURN NULL; + END; + $$ + LANGUAGE plpgsql; + end if; +END +$for_og_310$; + +DROP FUNCTION IF EXISTS pg_catalog.export_set (bit, "any", "any") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.export_set (bit, "any", "any", "any") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.export_set (int16, "any", "any", "any", bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.export_set (bit, "any", "any", "any", int8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.export_set (bit, "any", "any", "any", bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.export_set (int16, "any", "any", "any", int8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.export_set (int16, "any", "any", "any") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.export_set (int16, "any", "any") CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.export_set (numeric, text, text, text, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.export_set (numeric, text, text, text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.export_set (numeric, text, text) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.export_set (numeric, text, text, text, numeric) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_5args'; +CREATE OR REPLACE FUNCTION pg_catalog.export_set (numeric, text, text, text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_4args'; +CREATE OR REPLACE FUNCTION pg_catalog.export_set (numeric, text, text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_3args'; +DROP FUNCTION IF EXISTS pg_catalog.sleep(d date) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.pg_open_tables() CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.pg_open_tables(TEXT) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.compress (text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.compress (bytea) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.compress (boolean) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.compress (bit) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uncompress (text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uncompress (bytea) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uncompress (boolean) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uncompress (bit) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length (text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length (bytea) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length (boolean) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length (bit) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.weight_string (TEXT, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (TEXT, TEXT, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (TEXT, TEXT, uint4, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (bytea, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (bytea, text, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (bytea, text, uint4, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (boolean, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (boolean, TEXT, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (boolean, TEXT, uint4, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (numeric, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (numeric, TEXT, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (numeric, TEXT, uint4, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (numeric, TEXT, TEXT, uint4); +DROP FUNCTION IF EXISTS pg_catalog.weight_string (date, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (date, TEXT, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (date, TEXT, uint4, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (time, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (time, TEXT, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (time, TEXT, uint4, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (timestamp without time zone, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (timestamp without time zone, TEXT, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (timestamp without time zone, TEXT, uint4, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (timestamptz, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (timestamptz, TEXT, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (timestamptz, TEXT, uint4, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (interval, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (interval, TEXT, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (interval, TEXT, uint4, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (bit, uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (bit, text, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (bit, text, uint4, uint4) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.sleep(d date) CASCADE; + +DO $for_og_310$ +BEGIN + if working_version_num() > 92780 then + CREATE OR REPLACE FUNCTION pg_catalog.text_xor (t1 uint8,t2 text) RETURNS uint8 AS + $$ + DECLARE num NUMBER := to_number(t2); + BEGIN + IF num > 9223372036854775807 then + num = 9223372036854775807; + ELSEIF num < -9223372036854775808 then + num = 9223372036854775808; + END IF; + RETURN (SELECT uint8_xor(t1, num)); + END; + $$ + LANGUAGE plpgsql; + drop aggregate if exists pg_catalog.bit_xor(text); + create aggregate pg_catalog.bit_xor(text) (SFUNC=text_xor, STYPE= uint8); + end if; +END +$for_og_310$; + +drop view performance_schema.events_statements_current; +drop view performance_schema.events_statements_history; +drop view performance_schema.events_statements_summary_by_digest; +drop view performance_schema.statement_history; +drop view performance_schema.events_waits_current; +drop view performance_schema.events_waits_summary_global_by_event_name; +drop view performance_schema.file_summary_by_instance; +drop view performance_schema.table_io_waits_summary_by_table; +drop view performance_schema.table_io_waits_summary_by_index_usage; +drop schema if exists performance_schema CASCADE; +drop function if exists pg_catalog.get_statement_history(); + +-- left operator +DROP OPERATOR IF EXISTS pg_catalog.+(NONE, json); +DROP FUNCTION IF EXISTS pg_catalog.json_uplus(json); + +-- binary cmp operator +DROP OPERATOR IF EXISTS pg_catalog.=(json, "any"); +DROP FUNCTION IF EXISTS pg_catalog.json_eq(json, "any"); +DROP OPERATOR IF EXISTS pg_catalog.=(text, json); +DROP FUNCTION IF EXISTS pg_catalog.json_eq(text, json); +DROP OPERATOR IF EXISTS pg_catalog.=(bit, json); +DROP FUNCTION IF EXISTS pg_catalog.json_eq(bit, json); +DROP OPERATOR IF EXISTS pg_catalog.=(boolean, json); +DROP FUNCTION IF EXISTS pg_catalog.json_eq(boolean, json); +DROP OPERATOR IF EXISTS pg_catalog.=(year, json); +DROP FUNCTION IF EXISTS pg_catalog.json_eq(year, json); + +DROP OPERATOR IF EXISTS pg_catalog.!=(json, "any"); +DROP FUNCTION IF EXISTS pg_catalog.json_ne(json, "any"); +DROP OPERATOR IF EXISTS pg_catalog.!=(text, json); +DROP FUNCTION IF EXISTS pg_catalog.json_ne(text, json); +DROP OPERATOR IF EXISTS pg_catalog.!=(bit, json); +DROP FUNCTION IF EXISTS pg_catalog.json_ne(bit, json); +DROP OPERATOR IF EXISTS pg_catalog.!=(boolean, json); +DROP FUNCTION IF EXISTS pg_catalog.json_ne(boolean, json); +DROP OPERATOR IF EXISTS pg_catalog.!=(year, json); +DROP FUNCTION IF EXISTS pg_catalog.json_ne(year, json); + +DROP OPERATOR IF EXISTS pg_catalog.>(json, "any"); +DROP FUNCTION IF EXISTS pg_catalog.json_gt(json, "any"); +DROP OPERATOR IF EXISTS pg_catalog.>(text, json); +DROP FUNCTION IF EXISTS pg_catalog.json_gt(text, json); +DROP OPERATOR IF EXISTS pg_catalog.>(bit, json); +DROP FUNCTION IF EXISTS pg_catalog.json_gt(bit, json); +DROP OPERATOR IF EXISTS pg_catalog.>(boolean, json); +DROP FUNCTION IF EXISTS pg_catalog.json_gt(boolean, json); +DROP OPERATOR IF EXISTS pg_catalog.>(year, json); +DROP FUNCTION IF EXISTS pg_catalog.json_gt(year, json); + +DROP OPERATOR IF EXISTS pg_catalog.>=(json, "any"); +DROP FUNCTION IF EXISTS pg_catalog.json_ge(json, "any"); +DROP OPERATOR IF EXISTS pg_catalog.>=(text, json); +DROP FUNCTION IF EXISTS pg_catalog.json_ge(text, json); +DROP OPERATOR IF EXISTS pg_catalog.>=(bit, json); +DROP FUNCTION IF EXISTS pg_catalog.json_ge(bit, json); +DROP OPERATOR IF EXISTS pg_catalog.>=(boolean, json); +DROP FUNCTION IF EXISTS pg_catalog.json_ge(boolean, json); +DROP OPERATOR IF EXISTS pg_catalog.>=(year, json); +DROP FUNCTION IF EXISTS pg_catalog.json_ge(year, json); + +DROP OPERATOR IF EXISTS pg_catalog.<(json, "any"); +DROP FUNCTION IF EXISTS pg_catalog.json_lt(json, "any"); +DROP OPERATOR IF EXISTS pg_catalog.<(text, json); +DROP FUNCTION IF EXISTS pg_catalog.json_lt(text, json); +DROP OPERATOR IF EXISTS pg_catalog.<(bit, json); +DROP FUNCTION IF EXISTS pg_catalog.json_lt(bit, json); +DROP OPERATOR IF EXISTS pg_catalog.<(boolean, json); +DROP FUNCTION IF EXISTS pg_catalog.json_lt(boolean, json); +DROP OPERATOR IF EXISTS pg_catalog.<(year, json); +DROP FUNCTION IF EXISTS pg_catalog.json_lt(year, json); + +DROP OPERATOR IF EXISTS pg_catalog.<=(json, "any"); +DROP FUNCTION IF EXISTS pg_catalog.json_le(json, "any"); +DROP OPERATOR IF EXISTS pg_catalog.<=(text, json); +DROP FUNCTION IF EXISTS pg_catalog.json_le(text, json); +DROP OPERATOR IF EXISTS pg_catalog.<=(bit, json); +DROP FUNCTION IF EXISTS pg_catalog.json_le(bit, json); +DROP OPERATOR IF EXISTS pg_catalog.<=(boolean, json); +DROP FUNCTION IF EXISTS pg_catalog.json_le(boolean, json); +DROP OPERATOR IF EXISTS pg_catalog.<=(year, json); +DROP FUNCTION IF EXISTS pg_catalog.json_le(year, json); + +DROP FUNCTION IF EXISTS pg_catalog.b_mod(json, anyelement); +DROP FUNCTION IF EXISTS pg_catalog.b_mod(anyelement, json); +DROP FUNCTION IF EXISTS pg_catalog.b_mod(json, json); + +DROP FUNCTION IF EXISTS pg_catalog.div(json, anyelement); +DROP FUNCTION IF EXISTS pg_catalog.div(anyelement, json); +DROP FUNCTION IF EXISTS pg_catalog.div(json, json); + +DROP FUNCTION IF EXISTS pg_catalog.xor(json, anyelement); +DROP FUNCTION IF EXISTS pg_catalog.xor(anyelement, json); +DROP FUNCTION IF EXISTS pg_catalog.xor(json, json); + +DROP FUNCTION IF EXISTS pg_catalog.a_sysdate(); + +DROP CAST IF EXISTS (json AS boolean); +DROP FUNCTION IF EXISTS pg_catalog.json_to_bool(json); + +DROP FUNCTION IF EXISTS pg_catalog.hex(int8); +DROP FUNCTION IF EXISTS pg_catalog.hex(int16); +CREATE OR REPLACE FUNCTION pg_catalog.hex(int8) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int_to_hex'; + +DROP FUNCTION IF EXISTS pg_catalog.bit_bin_in(cstring, oid, integer); + +DROP FUNCTION IF EXISTS pg_catalog.b_mod(a numeric, b numeric); +CREATE OR REPLACE FUNCTION pg_catalog.b_mod(a numeric, b numeric) +returns numeric +as +$$ +begin + IF b = 0 then + return null; + else + return (select a % b); + end if; +end; +$$ +language plpgsql; diff --git a/contrib/dolphin/upgrade_script/dolphin--1.0--1.1.sql b/contrib/dolphin/upgrade_script/dolphin--1.0--1.2.sql similarity index 100% rename from contrib/dolphin/upgrade_script/dolphin--1.0--1.1.sql rename to contrib/dolphin/upgrade_script/dolphin--1.0--1.2.sql diff --git a/contrib/dolphin/upgrade_script/dolphin--1.2--2.0.sql b/contrib/dolphin/upgrade_script/dolphin--1.2--2.0.sql new file mode 100644 index 000000000..4fd0070b8 --- /dev/null +++ b/contrib/dolphin/upgrade_script/dolphin--1.2--2.0.sql @@ -0,0 +1,4196 @@ +DROP FUNCTION IF EXISTS pg_catalog.dolphin_invoke(); +CREATE FUNCTION pg_catalog.dolphin_invoke() + RETURNS VOID AS '$libdir/dolphin','dolphin_invoke' LANGUAGE C STRICT; + +DROP FUNCTION IF EXISTS pg_catalog.bit_count(numeric) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bit_count (numeric) RETURNS int LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_numeric'; +DROP FUNCTION IF EXISTS pg_catalog.bit_count(text) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bit_count (text) RETURNS int LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_text'; +DROP FUNCTION IF EXISTS pg_catalog.bit_count_bit(text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bit_count(date) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bit_count (date) RETURNS int LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_date'; +DROP FUNCTION IF EXISTS pg_catalog.bit_count(bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bit_count(bit) RETURNS int LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_bit'; + +DROP FUNCTION IF EXISTS pg_catalog.connection_id() CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.connection_id() RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'connection_id'; + +DROP FUNCTION IF EXISTS pg_catalog.system_user() CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.system_user( +) RETURNS name LANGUAGE C STABLE STRICT AS '$libdir/dolphin','get_b_session_user'; +DROP FUNCTION IF EXISTS pg_catalog.schema() CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.schema( +) RETURNS name LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'get_b_schema'; + +DROP FUNCTION IF EXISTS pg_catalog.from_base64 (text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.from_base64 (bool) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.from_base64 (boolean) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.from_base64 (bit) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.from_base64 (text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_decode_text'; +CREATE OR REPLACE FUNCTION pg_catalog.from_base64 (boolean) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_decode_bool'; +CREATE OR REPLACE FUNCTION pg_catalog.from_base64 (bit) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_decode_bit'; + +DROP FUNCTION IF EXISTS pg_catalog.atan2 (boolean, boolean); +CREATE OR REPLACE FUNCTION pg_catalog.atan2 (boolean, boolean) RETURNS float8 AS $$ SELECT pg_catalog.atan2($1::int4, $2::int4) $$ LANGUAGE SQL; +DROP FUNCTION IF EXISTS pg_catalog.atan2 (boolean, float8); +CREATE OR REPLACE FUNCTION pg_catalog.atan2 (boolean, float8) RETURNS float8 AS $$ SELECT pg_catalog.atan2($1::int4, $2) $$ LANGUAGE SQL; +DROP FUNCTION IF EXISTS pg_catalog.atan2 (float8, boolean); +CREATE OR REPLACE FUNCTION pg_catalog.atan2 (float8, boolean) RETURNS float8 AS $$ SELECT pg_catalog.atan2($1, $2::int4) $$ LANGUAGE SQL; +DROP FUNCTION IF EXISTS pg_catalog.atan (float8, float8); +CREATE OR REPLACE FUNCTION pg_catalog.atan (float8, float8) RETURNS float8 AS $$ SELECT pg_catalog.atan2($1, $2) $$ LANGUAGE SQL; +DROP FUNCTION IF EXISTS pg_catalog.atan (boolean, boolean); +CREATE OR REPLACE FUNCTION pg_catalog.atan (boolean, boolean) RETURNS float8 AS $$ SELECT pg_catalog.atan2($1::int4, $2::int4) $$ LANGUAGE SQL; +DROP FUNCTION IF EXISTS pg_catalog.atan (boolean, float8); +CREATE OR REPLACE FUNCTION pg_catalog.atan (boolean, float8) RETURNS float8 AS $$ SELECT pg_catalog.atan2($1::int4, $2) $$ LANGUAGE SQL; +DROP FUNCTION IF EXISTS pg_catalog.atan (float8, boolean); +CREATE OR REPLACE FUNCTION pg_catalog.atan (float8, boolean) RETURNS float8 AS $$ SELECT pg_catalog.atan2($1, $2::int4) $$ LANGUAGE SQL; +DROP FUNCTION IF EXISTS pg_catalog.atan (boolean); +CREATE OR REPLACE FUNCTION pg_catalog.atan (boolean) RETURNS float8 AS $$ SELECT pg_catalog.atan($1::int4) $$ LANGUAGE SQL; + +DROP FUNCTION IF EXISTS pg_catalog.oct(text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(boolean) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(timestamp without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(timestamptz) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.oct(time) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.oct(text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'oct_str'; +CREATE OR REPLACE FUNCTION pg_catalog.oct(numeric) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'oct_num'; + +CREATE OR REPLACE FUNCTION pg_catalog.oct(date) RETURNS text AS $$ SELECT pg_catalog.oct($1::text) $$ LANGUAGE SQL; +CREATE OR REPLACE FUNCTION pg_catalog.oct(timestamp without time zone) RETURNS text AS $$ SELECT pg_catalog.oct($1::text) $$ LANGUAGE SQL; +CREATE OR REPLACE FUNCTION pg_catalog.oct(timestamptz) RETURNS text AS $$ SELECT pg_catalog.oct($1::text) $$ LANGUAGE SQL; +CREATE OR REPLACE FUNCTION pg_catalog.oct(time) RETURNS text AS $$ SELECT pg_catalog.oct($1::text) $$ LANGUAGE SQL; + +DROP FUNCTION IF EXISTS pg_catalog.conv(date, int4, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.conv(timestamp without time zone, int4, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.conv(timestamptz, int4, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.conv(time, int4, int4) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.conv ( +date, int4, int4 +) RETURNS text AS $$ SELECT pg_catalog.conv($1::text, $2, $3) $$ LANGUAGE SQL; + +CREATE OR REPLACE FUNCTION pg_catalog.conv ( +timestamp without time zone, int4, int4 +) RETURNS text AS $$ SELECT pg_catalog.conv($1::text, $2, $3) $$ LANGUAGE SQL; + +CREATE OR REPLACE FUNCTION pg_catalog.conv ( +timestamptz, int4, int4 +) RETURNS text AS $$ SELECT pg_catalog.conv($1::text, $2, $3) $$ LANGUAGE SQL; + +CREATE OR REPLACE FUNCTION pg_catalog.conv ( +time, int4, int4 +) RETURNS text AS $$ SELECT pg_catalog.conv($1::text, $2, $3) $$ LANGUAGE SQL; + +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (bytea) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (boolean) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (bytea) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode'; +CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode_text'; +CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (boolean) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode_bool'; +CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (bit) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode_bit'; + +DROP FUNCTION IF EXISTS pg_catalog.unhex ("timestamp") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.unhex (numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.unhex (text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.unhex (boolean) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.unhex (bytea) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.unhex (bit) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.unhex (text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'hex_decode_text'; +CREATE OR REPLACE FUNCTION pg_catalog.unhex (boolean) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'hex_decode_bool'; +CREATE OR REPLACE FUNCTION pg_catalog.unhex (bytea) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'hex_decode_bytea'; +CREATE OR REPLACE FUNCTION pg_catalog.unhex (bit) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'hex_decode_bit'; + +--bit_functions.sql +DROP FUNCTION IF EXISTS pg_catalog.bittoint1(bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bittoint1 ( +bit +) RETURNS int1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittoint1'; +DROP FUNCTION IF EXISTS pg_catalog.bittoint2(bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bittoint2 ( +bit +) RETURNS int2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittoint2'; +DROP FUNCTION IF EXISTS pg_catalog.bitfromint1(int1, int4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bitfromint1 ( +int1, int4 +) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitfromint1'; +DROP FUNCTION IF EXISTS pg_catalog.bitfromint2(int2, int4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bitfromint2 ( +int2, int4 +) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitfromint2'; + +drop CAST IF EXISTS (bit AS int1) CASCADE; +drop CAST IF EXISTS (bit AS int2) CASCADE; +drop CAST IF EXISTS (int1 AS bit) CASCADE; +drop CAST IF EXISTS (int2 AS bit) CASCADE; + +CREATE CAST (bit AS int1) WITH FUNCTION bittoint1(bit) AS ASSIGNMENT; +CREATE CAST (bit AS int2) WITH FUNCTION bittoint2(bit) AS ASSIGNMENT; +CREATE CAST (int1 AS bit) WITH FUNCTION bitfromint1(int1, int4) AS ASSIGNMENT; +CREATE CAST (int2 AS bit) WITH FUNCTION bitfromint2(int2, int4) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bittotext(bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bittotext(bit) +RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittotext'; +DROP CAST IF EXISTS (bit AS text) CASCADE; +CREATE CAST (bit AS text) WITH FUNCTION bittotext(bit) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bittochar(bit, int4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bittochar(bit, int4) +RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittobpchar'; +DROP CAST IF EXISTS (bit AS char) CASCADE; +CREATE CAST (bit AS char) WITH FUNCTION bittochar(bit, int4) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bittovarchar(bit, int4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bittovarchar(bit, int4) +RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittovarchar'; +DROP CAST IF EXISTS (bit AS varchar) CASCADE; +CREATE CAST (bit AS varchar) WITH FUNCTION bittovarchar(bit, int4) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bitfromnumeric(numeric, int4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bitfromnumeric(numeric, int4) +RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitfromnumeric'; +DROP CAST IF EXISTS (numeric as bit) CASCADE; +CREATE CAST (numeric as bit) WITH FUNCTION bitfromnumeric(numeric, int4) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bitfromfloat4(float4, int4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bitfromfloat4(float4, int4) +RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitfromfloat4'; +DROP CAST IF EXISTS (float4 as bit) CASCADE; +CREATE CAST (float4 as bit) WITH FUNCTION bitfromfloat4(float4, int4) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bitfromfloat8(float8, int4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bitfromfloat8(float8, int4) +RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitfromfloat8'; +DROP CAST IF EXISTS (float8 as bit) CASCADE; +CREATE CAST (float8 as bit) WITH FUNCTION bitfromfloat8(float8, int4) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bitfromdate(date, int4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bitfromdate(date, int4) +RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitfromdate'; +DROP CAST IF EXISTS (date as bit) CASCADE; +CREATE CAST (date as bit) WITH FUNCTION bitfromdate(date, int4) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bitfromdatetime(timestamp without time zone, int4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bitfromdatetime(timestamp without time zone, int4) +RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitfromdatetime'; +DROP CAST IF EXISTS (timestamp without time zone as bit) CASCADE; +CREATE CAST (timestamp without time zone as bit) WITH FUNCTION bitfromdatetime(timestamp without time zone, int4) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bitfromtimestamp(timestamptz, int4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bitfromtimestamp(timestamptz, int4) +RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitfromtimestamp'; +DROP CAST IF EXISTS (timestamptz as bit) CASCADE; +CREATE CAST (timestamptz as bit) WITH FUNCTION bitfromtimestamp(timestamptz, int4) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bitfromtime(time, int4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bitfromtime(time, int4) +RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitfromtime'; +DROP CAST IF EXISTS (time as bit) CASCADE; +CREATE CAST (time as bit) WITH FUNCTION bitfromtime(time, int4) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.set(bit, int4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.set (bit, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittoset'; +DROP CAST IF EXISTS (bit AS anyset) CASCADE; +CREATE CAST (bit AS anyset) WITH FUNCTION pg_catalog.set(bit, int4) AS ASSIGNMENT; + +--dolphin_time_functions.sql +DROP FUNCTION IF EXISTS pg_catalog.int8_year (int1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_year (int2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int64_year (int8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_int8 (year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_int16 (year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_int64 (year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_year (numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float4_year (float4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float8_year (float8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bit_year (bit) CASCADE; + +DROP CAST IF EXISTS (int1 AS year) CASCADE; +DROP CAST IF EXISTS (int2 AS year) CASCADE; +DROP CAST IF EXISTS (int8 AS year) CASCADE; +DROP CAST IF EXISTS (year AS int1) CASCADE; +DROP CAST IF EXISTS (year AS int2) CASCADE; +DROP CAST IF EXISTS (year AS int8) CASCADE; +DROP CAST IF EXISTS (numeric AS year) CASCADE; +DROP CAST IF EXISTS (float4 AS year) CASCADE; +DROP CAST IF EXISTS (float8 AS year) CASCADE; +DROP CAST IF EXISTS (bit AS year) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.int8_year (int1) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_year'; +CREATE CAST(int1 AS year) WITH FUNCTION int8_year(int1) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.int16_year (int2) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_year'; +CREATE CAST(int2 AS year) WITH FUNCTION int16_year(int2) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.int64_year (int8) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_year'; +CREATE CAST(int8 AS year) WITH FUNCTION int64_year(int8) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.year_int8 (year) RETURNS int1 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_int8'; +CREATE CAST(year AS int1) WITH FUNCTION year_int8(year) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.year_int16 (year) RETURNS int2 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_int16'; +CREATE CAST(year AS int2) WITH FUNCTION year_int16(year) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.year_int64 (year) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_int64'; +CREATE CAST(year AS int8) WITH FUNCTION year_int64(year) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.numeric_year (numeric) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)'; +CREATE CAST(numeric AS year) WITH FUNCTION numeric_year(numeric) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.float4_year (float4) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)'; +CREATE CAST(float4 AS year) WITH FUNCTION float4_year(float4) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.float8_year (float8) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)'; +CREATE CAST(float8 AS year) WITH FUNCTION float8_year(float8) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.bit_year (bit) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)'; +CREATE CAST(bit AS year) WITH FUNCTION bit_year(bit) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_date (int1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_date (int2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int64_b_format_date (int8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_b_format_date (numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float8_b_format_date (float8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float4_b_format_date (float4) CASCADE; + +DROP CAST IF EXISTS (int1 AS date) CASCADE; +DROP CAST IF EXISTS (int2 AS date) CASCADE; +DROP CAST IF EXISTS (int8 AS date) CASCADE; +DROP CAST IF EXISTS (numeric AS date) CASCADE; +DROP CAST IF EXISTS (float8 AS date) CASCADE; +DROP CAST IF EXISTS (float4 AS date) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_date (int1) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_b_format_date'; +CREATE CAST(int1 AS date) WITH FUNCTION int8_b_format_date(int1) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_date (int2) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_b_format_date'; +CREATE CAST(int2 AS date) WITH FUNCTION int16_b_format_date(int2) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_date (int8) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_b_format_date'; +CREATE CAST(int8 AS date) WITH FUNCTION int64_b_format_date(int8) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.numeric_b_format_date (numeric) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_b_format_date'; +CREATE CAST(numeric AS date) WITH FUNCTION numeric_b_format_date(numeric) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.float8_b_format_date (float8) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float8_b_format_date'; +CREATE CAST(float8 AS date) WITH FUNCTION float8_b_format_date(float8) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.float4_b_format_date (float4) RETURNS date LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as float8) as date)'; +CREATE CAST(float4 AS date) WITH FUNCTION float4_b_format_date(float4) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bittodate(bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bittodate(bit) +RETURNS date LANGUAGE SQL IMMUTABLE STRICT as +'select cast(cast($1 as int8) as date)'; +DROP CAST IF EXISTS (bit AS date) CASCADE; +CREATE CAST (bit AS date) WITH FUNCTION bittodate(bit) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bittodatetime(bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bittodatetime(bit) +RETURNS timestamp without time zone LANGUAGE SQL IMMUTABLE STRICT as +'select cast(cast($1 as int8) as timestamp without time zone)'; +DROP CAST IF EXISTS (bit AS timestamp without time zone) CASCADE; +CREATE CAST (bit AS timestamp without time zone) WITH FUNCTION bittodatetime(bit) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bittotimestamp(bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bittotimestamp(bit) +RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as +'select cast(cast($1 as int8) as timestamptz)'; +DROP CAST IF EXISTS (bit AS timestamptz) CASCADE; +CREATE CAST (bit AS timestamptz) WITH FUNCTION bittotimestamp(bit) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.bittotime(bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bittotime(bit) +RETURNS time LANGUAGE SQL IMMUTABLE STRICT as +'select cast(cast($1 as int8) as time)'; +DROP CAST IF EXISTS (bit AS time) CASCADE; +CREATE CAST (bit AS time) WITH FUNCTION bittotime(bit) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_time (int1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_time (int2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float8_b_format_time (float8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float4_b_format_time (float4) CASCADE; + +DROP CAST IF EXISTS (int1 AS time) CASCADE; +DROP CAST IF EXISTS (int2 AS time) CASCADE; +DROP CAST IF EXISTS (float8 AS time) CASCADE; +DROP CAST IF EXISTS (float4 AS time) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_time (int1) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_b_format_time'; +CREATE CAST(int1 AS time) WITH FUNCTION int8_b_format_time(int1) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_time (int2) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_b_format_time'; +CREATE CAST(int2 AS time) WITH FUNCTION int16_b_format_time(int2) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.float8_b_format_time (float8) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float8_b_format_time'; +CREATE CAST(float8 AS time) WITH FUNCTION float8_b_format_time(float8) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.float4_b_format_time (float4) RETURNS time LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as float8) as time)'; +CREATE CAST(float4 AS time) WITH FUNCTION float4_b_format_time(float4) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_datetime (int1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_datetime (int2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float8_b_format_datetime (float8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float4_b_format_datetime (float4) CASCADE; + +DROP CAST IF EXISTS (int1 AS timestamp(0) without time zone) CASCADE; +DROP CAST IF EXISTS (int2 AS timestamp(0) without time zone) CASCADE; +DROP CAST IF EXISTS (float8 AS timestamp(0) without time zone) CASCADE; +DROP CAST IF EXISTS (float4 AS timestamp(0) without time zone) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_datetime (int1) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_b_format_datetime'; +CREATE CAST(int1 AS timestamp(0) without time zone) WITH FUNCTION int8_b_format_datetime(int1) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_datetime (int2) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_b_format_datetime'; +CREATE CAST(int2 AS timestamp(0) without time zone) WITH FUNCTION int16_b_format_datetime(int2) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.float8_b_format_datetime (float8) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float8_b_format_datetime'; +CREATE CAST(float8 AS timestamp(0) without time zone) WITH FUNCTION float8_b_format_datetime(float8) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.float4_b_format_datetime (float4) RETURNS timestamp(0) without time zone LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as float8) as timestamp(0) without time zone)'; +CREATE CAST(float4 AS timestamp(0) without time zone) WITH FUNCTION float4_b_format_datetime(float4) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_timestamp (int1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_timestamp (int2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float8_b_format_timestamp (float8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.float4_b_format_timestamp (float4) CASCADE; + + +DROP CAST IF EXISTS (int1 AS timestamptz) CASCADE; +DROP CAST IF EXISTS (int2 AS timestamptz) CASCADE; +DROP CAST IF EXISTS (float8 AS timestamptz) CASCADE; +DROP CAST IF EXISTS (float4 AS timestamptz) CASCADE; + + +CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_timestamp (int1) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_b_format_timestamp'; +CREATE CAST(int1 AS timestamptz) WITH FUNCTION int8_b_format_timestamp(int1) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_timestamp (int2) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_b_format_timestamp'; +CREATE CAST(int2 AS timestamptz) WITH FUNCTION int16_b_format_timestamp(int2) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.float8_b_format_timestamp (float8) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float8_b_format_timestamp'; +CREATE CAST(float8 AS timestamptz) WITH FUNCTION float8_b_format_timestamp(float8) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.float4_b_format_timestamp (float4) RETURNS timestamptz LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as float8) as timestamptz)'; +CREATE CAST(float4 AS timestamptz) WITH FUNCTION float4_b_format_timestamp(float4) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.time_int1 (time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_int2 (time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_float4 (time) CASCADE; + +DROP CAST IF EXISTS (time AS int1) CASCADE; +DROP CAST IF EXISTS (time AS int2) CASCADE; +DROP CAST IF EXISTS (time AS float4) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.time_int1 (time) RETURNS int1 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.time_float($1) as int1)'; +CREATE CAST(time AS int1) WITH FUNCTION time_int1(time) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.time_int2 (time) RETURNS int2 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.time_float($1) as int2)'; +CREATE CAST(time AS int2) WITH FUNCTION time_int2(time) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.time_float4 (time) RETURNS float4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.time_float($1) as float4)'; +CREATE CAST(time AS float4) WITH FUNCTION time_float4(time) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.datetime_int1 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_int2 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_int4 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_float4 (timestamp(0) without time zone) CASCADE; + +DROP CAST IF EXISTS (timestamp(0) without time zone AS int1) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS int2) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS int4) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS float4) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.datetime_int1 (timestamp(0) without time zone) RETURNS int1 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as int1)'; +CREATE CAST(timestamp(0) without time zone AS int1) WITH FUNCTION datetime_int1(timestamp(0) without time zone) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.datetime_int2 (timestamp(0) without time zone) RETURNS int2 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as int2)'; +CREATE CAST(timestamp(0) without time zone AS int2) WITH FUNCTION datetime_int2(timestamp(0) without time zone) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.datetime_int4 (timestamp(0) without time zone) RETURNS int4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as int4)'; +CREATE CAST(timestamp(0) without time zone AS int4) WITH FUNCTION datetime_int4(timestamp(0) without time zone) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.datetime_float4 (timestamp(0) without time zone) RETURNS float4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as float4)'; +CREATE CAST(timestamp(0) without time zone AS float4) WITH FUNCTION datetime_float4(timestamp(0) without time zone) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int1 ("timestamptz") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int2 ("timestamptz") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int4 ("timestamptz") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_float4 ("timestamptz") CASCADE; + +DROP CAST IF EXISTS ("timestamptz" AS int1) CASCADE; +DROP CAST IF EXISTS ("timestamptz" AS int2) CASCADE; +DROP CAST IF EXISTS ("timestamptz" AS int4) CASCADE; +DROP CAST IF EXISTS ("timestamptz" AS float4) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_int1 ("timestamptz") RETURNS int1 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as int1)'; +CREATE CAST("timestamptz" AS int1) WITH FUNCTION timestamptz_int1("timestamptz") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_int2 ("timestamptz") RETURNS int2 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as int2)'; +CREATE CAST("timestamptz" AS int2) WITH FUNCTION timestamptz_int2("timestamptz") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_int4 ("timestamptz") RETURNS int4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as int4)'; +CREATE CAST("timestamptz" AS int4) WITH FUNCTION timestamptz_int4("timestamptz") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_float4 ("timestamptz") RETURNS float4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as float4)'; +CREATE CAST("timestamptz" AS float4) WITH FUNCTION timestamptz_float4("timestamptz") AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.date2int1("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.date2int2("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.date2float4("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.year_float4("year") cascade; + +DROP CAST IF EXISTS ("date" as int1) CASCADE; +DROP CAST IF EXISTS ("date" as int2) CASCADE; +DROP CAST IF EXISTS ("date" as float4) CASCADE; +DROP CAST IF EXISTS (year AS float4) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.date2int1("date") RETURNS int1 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::int1; $$; +CREATE CAST ("date" as int1) with function pg_catalog.date2int1("date") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.date2int2("date") RETURNS int2 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::int2; $$; +CREATE CAST ("date" as int2) with function pg_catalog.date2int2("date") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.date2float4("date") RETURNS float4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::float4; $$; +CREATE CAST ("date" as float4) with function pg_catalog.date2float4("date") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.year_float4("year") RETURNS float4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_float4'; +CREATE CAST ("year" as float4) with function pg_catalog.year_float4("year") AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.year_date("year") cascade; +DROP FUNCTION IF EXISTS pg_catalog.year_datetime("year") cascade; +DROP FUNCTION IF EXISTS pg_catalog.year_timestamp("year") cascade; +DROP FUNCTION IF EXISTS pg_catalog.year_time("year") cascade; +DROP FUNCTION IF EXISTS pg_catalog.datetime_year(timestamp(0) without time zone) cascade; +DROP FUNCTION IF EXISTS pg_catalog.timestamp_year(timestamptz) cascade; +DROP FUNCTION IF EXISTS pg_catalog.time_year(time) cascade; +DROP FUNCTION IF EXISTS pg_catalog.date_year(date) cascade; +DROP FUNCTION IF EXISTS pg_catalog.date_time (date) cascade; +DROP FUNCTION IF EXISTS pg_catalog.time_date (time) cascade; +DROP FUNCTION IF EXISTS pg_catalog.time_datetime (time) cascade; +DROP FUNCTION IF EXISTS pg_catalog.time_timestamp (time) cascade; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_timestamptz (char) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varchar_timestamptz (varchar) cascade; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_time (char) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varchar_time (varchar) cascade; +DROP FUNCTION IF EXISTS pg_catalog.timestamp_bpchar (timestamp without time zone) cascade; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_varchar (timestamptz) cascade; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_bpchar (timestamptz) cascade; +DROP FUNCTION IF EXISTS pg_catalog.time_varchar (time) cascade; +DROP FUNCTION IF EXISTS pg_catalog.time_bpchar (time) cascade; +DROP FUNCTION IF EXISTS pg_catalog.bitfromyear(year, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set_date (anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set_datetime (anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set_timestamp (anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set_time (anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set_year (anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set (date, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set(timestamp without time zone, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set(timestamptz, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set(time, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set(year, int4) cascade; + +DROP CAST IF EXISTS (year AS date) CASCADE; +DROP CAST IF EXISTS (year AS timestamp(0) without time zone) CASCADE; +DROP CAST IF EXISTS (year AS timestamptz) CASCADE; +DROP CAST IF EXISTS (year AS time) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS year) CASCADE; +DROP CAST IF EXISTS (timestamptz AS year) CASCADE; +DROP CAST IF EXISTS (time AS year) CASCADE; +DROP CAST IF EXISTS (date AS year) CASCADE; +DROP CAST IF EXISTS (date AS time) CASCADE; +DROP CAST IF EXISTS (time AS date) CASCADE; +DROP CAST IF EXISTS (time AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS (time AS timestamptz) CASCADE; +DROP CAST IF EXISTS (char AS timestamptz) CASCADE; +DROP CAST IF EXISTS (varchar AS timestamptz) CASCADE; +DROP CAST IF EXISTS (char as time) CASCADE; +DROP CAST IF EXISTS (varchar as time) CASCADE; +DROP CAST IF EXISTS (timestamp without time zone AS char) CASCADE; +DROP CAST IF EXISTS (timestamptz AS varchar) CASCADE; +DROP CAST IF EXISTS (timestamptz AS char) CASCADE; +DROP CAST IF EXISTS (time AS varchar) CASCADE; +DROP CAST IF EXISTS (time AS char) CASCADE; +DROP CAST IF EXISTS (year AS bit) CASCADE; +DROP CAST IF EXISTS (anyset as date) CASCADE; +DROP CAST IF EXISTS (anyset as timestamp without time zone) CASCADE; +DROP CAST IF EXISTS (anyset as timestamptz) CASCADE; +DROP CAST IF EXISTS (anyset as time) CASCADE; +DROP CAST IF EXISTS (anyset as year) CASCADE; +DROP CAST IF EXISTS (date AS anyset) CASCADE; +DROP CAST IF EXISTS (timestamp without time zone AS anyset) CASCADE; +DROP CAST IF EXISTS (timestamptz AS anyset) CASCADE; +DROP CAST IF EXISTS (time AS anyset) CASCADE; +DROP CAST IF EXISTS (year AS anyset) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.year_date("year") RETURNS date LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int4) as date)'; +CREATE CAST ("year" as date) with function pg_catalog.year_date("year") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.year_datetime("year") RETURNS timestamp(0) without time zone LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int4) as timestamp(0) without time zone)'; +CREATE CAST ("year" as timestamp(0) without time zone) with function pg_catalog.year_datetime("year") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.year_timestamp("year") RETURNS timestamptz LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int4) as timestamptz)'; +CREATE CAST ("year" as timestamptz) with function pg_catalog.year_timestamp("year") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.year_time("year") RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int4) as time)'; +CREATE CAST ("year" as time) with function pg_catalog.year_time("year") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.datetime_year(timestamp(0) without time zone) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)'; +CREATE CAST (timestamp(0) without time zone AS year) with function pg_catalog.datetime_year(timestamp(0) without time zone) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.timestamp_year(timestamptz) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)'; +CREATE CAST (timestamptz AS year) with function pg_catalog.timestamp_year(timestamptz) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.time_year(time) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)'; +CREATE CAST (time AS year) with function pg_catalog.time_year(time) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.date_year(date) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)'; +CREATE CAST (date AS year) with function pg_catalog.date_year(date) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.date_time (date) RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as timestamptz) as time)'; +CREATE CAST(date AS time) WITH FUNCTION date_time(date) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.time_date (time) RETURNS date LANGUAGE SQL IMMUTABLE STRICT as 'select addtime(curdate()::timestamptz, $1)::date'; +CREATE CAST(time AS date) WITH FUNCTION time_date(time) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.time_datetime (time) RETURNS timestamp without time zone LANGUAGE SQL IMMUTABLE STRICT as 'select addtime(curdate()::timestamp without time zone, $1)::timestamp without time zone'; +CREATE CAST(time AS timestamp without time zone) WITH FUNCTION time_datetime(time) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.time_timestamp (time) RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as 'select addtime(curdate()::timestamptz, $1)::timestamptz'; +CREATE CAST(time AS timestamptz) WITH FUNCTION time_timestamp(time) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.bpchar_timestamptz (char) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bpchar_timestamptz'; +CREATE CAST(char AS timestamptz) WITH FUNCTION bpchar_timestamptz(char) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.varchar_timestamptz (varchar) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'varchar_timestamptz'; +CREATE CAST(varchar AS timestamptz) WITH FUNCTION varchar_timestamptz(varchar) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.bpchar_time (char) RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as time)'; +CREATE CAST(char as time) WITH FUNCTION bpchar_time(char) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.varchar_time (varchar) RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as time)'; +CREATE CAST(varchar as time) WITH FUNCTION varchar_time(varchar) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.timestamp_bpchar (timestamp without time zone) RETURNS char LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_bpchar'; +CREATE CAST(timestamp without time zone AS char) WITH FUNCTION timestamp_bpchar(timestamp without time zone) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_varchar (timestamptz) RETURNS varchar LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_varchar'; +CREATE CAST(timestamptz AS varchar) WITH FUNCTION timestamptz_varchar(timestamptz) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_bpchar (timestamptz) RETURNS char LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_bpchar'; +CREATE CAST(timestamptz AS char) WITH FUNCTION timestamptz_bpchar(timestamptz) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.time_varchar (time) RETURNS varchar LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_varchar'; +CREATE CAST(time AS varchar) WITH FUNCTION time_varchar(time) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.time_bpchar (time) RETURNS char LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_bpchar'; +CREATE CAST(time AS char) WITH FUNCTION time_bpchar(time) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.bitfromyear(year, int4) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitfromyear'; +CREATE CAST (year as bit) WITH FUNCTION bitfromyear(year, int4) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set_date (anyset) RETURNS date LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as date)'; +CREATE CAST(anyset as date) WITH FUNCTION set_date(anyset) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set_datetime (anyset) RETURNS timestamp without time zone LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as timestamp without time zone)'; +CREATE CAST(anyset as timestamp without time zone) WITH FUNCTION set_datetime(anyset) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set_timestamp (anyset) RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as timestamptz)'; +CREATE CAST(anyset as timestamptz) WITH FUNCTION set_timestamp(anyset) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set_time (anyset) RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as time)'; +CREATE CAST(anyset as time) WITH FUNCTION set_time(anyset) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set_year (anyset) RETURNS year LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int8) as year)'; +CREATE CAST(anyset as year) WITH FUNCTION set_year(anyset) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set (date, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'datetoset'; +CREATE CAST (date AS anyset) WITH FUNCTION pg_catalog.set(date, int4) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set (timestamp without time zone, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'datetimetoset'; +CREATE CAST (timestamp without time zone AS anyset) WITH FUNCTION pg_catalog.set(timestamp without time zone, int4) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set (timestamptz, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptoset'; +CREATE CAST (timestamptz AS anyset) WITH FUNCTION pg_catalog.set(timestamptz, int4) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set (time, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timetoset'; +CREATE CAST (time AS anyset) WITH FUNCTION pg_catalog.set(time, int4) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set (year, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'yeartoset'; +CREATE CAST (year AS anyset) WITH FUNCTION pg_catalog.set(year, int4) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.time_timestamptz_xor(time, timestamptz) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_time_xor(timestamptz, time) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.bool_date_xor(boolean, date) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.bool_timestamptz_xor(boolean, timestamptz) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_bool_xor(date, boolean) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_bool_xor(timestamptz, boolean) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_mi_time(nvarchar2, time) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_pl_time(nvarchar2, time) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_add_numeric(date, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_sub_numeric(date, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_mul_numeric(time, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_div_numeric(time, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.datetime_mul_numeric(timestamp without time zone, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.datetime_div_numeric(timestamp without time zone, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.datetime_mul_int4(timestamp without time zone, int4) CASCADE; + +create function pg_catalog.time_timestamptz_xor( + time, + timestamptz +) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int8_timestamptz_xor($1::int8, $2) $$; + +create function pg_catalog.timestamptz_time_xor( + timestamptz, + time +) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int8_timestamptz_xor($2::int8, $1) $$; + +create function pg_catalog.bool_date_xor( + boolean, + date +) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int8_date_xor($1::int8, $2) $$; + +create function pg_catalog.bool_timestamptz_xor( + boolean, + timestamptz +) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int8_timestamptz_xor($1::int8, $2) $$; + +create function pg_catalog.date_bool_xor( + date, + boolean +) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.date_int8_xor($1, $2::int8) $$; + +create function pg_catalog.timestamptz_bool_xor( + timestamptz, + boolean +) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.timestamptz_int8_xor($1, $2::int8) $$; + +create function pg_catalog.nvarchar2_mi_time( + nvarchar2, + time +) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.datetime_mi_float($1::timestamp without time zone, $2::float8) $$; + +create function pg_catalog.nvarchar2_pl_time( + nvarchar2, + time +) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.datetime_pl_float($1::timestamp without time zone, $2::float8) $$; + +create function pg_catalog.date_add_numeric( + date, + numeric +) RETURNS date LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.date_pli($1, $2::int4) $$; + +create function pg_catalog.date_sub_numeric( + date, + numeric +) RETURNS date LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.date_mii($1, $2::int4) $$; + +create function pg_catalog.time_mul_numeric( + time, + numeric +) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8mul($1::float8, $2::float8) $$; + +create function pg_catalog.time_div_numeric( + time, + numeric +) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8div($1::float8, $2::float8) $$; + +create function pg_catalog.datetime_mul_numeric( + timestamp without time zone, + numeric +) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8mul($1::float8, $2::float8) $$; + +create function pg_catalog.datetime_div_numeric( + timestamp without time zone, + numeric +) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8div($1::float8, $2::float8) $$; + +create function pg_catalog.datetime_mul_int4( + timestamp without time zone, + int4 +) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8mul($1::float8, $2::float8) $$; + +create operator pg_catalog.^(leftarg = time, rightarg = timestampTz, procedure = pg_catalog.time_timestamptz_xor); +create operator pg_catalog.^(leftarg = timestampTz, rightarg = time, procedure = pg_catalog.timestamptz_time_xor); +create operator pg_catalog.^(leftarg = boolean, rightarg = date, procedure = pg_catalog.bool_date_xor); +create operator pg_catalog.^(leftarg = boolean, rightarg = timestamptz, procedure = pg_catalog.bool_timestamptz_xor); +create operator pg_catalog.^(leftarg = date, rightarg = boolean, procedure = pg_catalog.date_bool_xor); +create operator pg_catalog.^(leftarg = timestamptz, rightarg = boolean, procedure = pg_catalog.timestamptz_bool_xor); +create operator pg_catalog.-(leftarg = nvarchar2, rightarg = time, procedure = pg_catalog.nvarchar2_mi_time); +create operator pg_catalog.+(leftarg = nvarchar2, rightarg = time, procedure = pg_catalog.nvarchar2_pl_time); +create operator pg_catalog.+(leftarg = date, rightarg = numeric, procedure = pg_catalog.date_add_numeric); +create operator pg_catalog.-(leftarg = date, rightarg = numeric, procedure = pg_catalog.date_sub_numeric); +create operator pg_catalog.*(leftarg = time, rightarg = numeric, procedure = pg_catalog.time_mul_numeric); +create operator pg_catalog./(leftarg = time, rightarg = numeric, procedure = pg_catalog.time_div_numeric); +create operator pg_catalog.*(leftarg = timestamp without time zone, rightarg = numeric, procedure = pg_catalog.datetime_mul_numeric); +create operator pg_catalog./(leftarg = timestamp without time zone, rightarg = numeric, procedure = pg_catalog.datetime_div_numeric); +create operator pg_catalog.*(leftarg = timestamp without time zone, rightarg = int4, procedure = pg_catalog.datetime_mul_int4); + +DROP FUNCTION IF EXISTS pg_catalog.b_db_date(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.dayname(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.b_db_last_day(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.week(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.yearweek(date) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.adddate(date, interval) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.date_add(date, interval) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.date_sub(date, interval) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.b_db_date(date) RETURNS date LANGUAGE SQL STABLE STRICT as 'select pg_catalog.b_db_date($1::text)'; +CREATE OR REPLACE FUNCTION pg_catalog.dayname(date) RETURNS text LANGUAGE SQL STABLE STRICT as 'select pg_catalog.dayname($1::text)'; +CREATE OR REPLACE FUNCTION pg_catalog.b_db_last_day(date) RETURNS date LANGUAGE SQL STABLE STRICT as 'select pg_catalog.b_db_last_day($1::text)'; +CREATE OR REPLACE FUNCTION pg_catalog.week(date) RETURNS int4 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.week($1::text)'; +CREATE OR REPLACE FUNCTION pg_catalog.yearweek(date) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.yearweek($1::text)'; +CREATE OR REPLACE FUNCTION pg_catalog.adddate(date, interval) RETURNS text LANGUAGE SQL STABLE STRICT as 'select pg_catalog.adddate($1::text, $2)'; +CREATE OR REPLACE FUNCTION pg_catalog.date_add(date, interval) RETURNS text LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_add($1::text, $2)'; +CREATE OR REPLACE FUNCTION pg_catalog.date_sub(date, interval) RETURNS text LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_sub($1::text, $2)'; + +--enum.sql +DROP CAST IF EXISTS (anyenum as float8) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum2float8(anyenum) cascade; + +DROP FUNCTION IF EXISTS pg_catalog.enum_float8(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_int1(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_int2(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_int4(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_int8(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_numeric(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_float4(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_bit(anyenum, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_date(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_timestamp(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_timestamptz(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_time(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_year(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_set(anyenum, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_json(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.text_enum(text, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_enum(char, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varchar_enum(varchar, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena_enum(anyelement, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set_enum(anyset, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.date_enum(date, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.datetime_enum(timestamp without time zone, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.timestamp_enum(timestamptz, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.time_enum(time, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int1_enum(int1, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int2_enum(int2, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int4_enum(int4, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int8_enum(int8, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.float4_enum(float4, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.float8_enum(float8, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.numeric_enum(numeric, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.bit_enum(bit, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.year_enum(year, int4, anyelement) cascade; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_float8(anyenum) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'Enum2Float8'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_int1(anyenum) RETURNS int1 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int1)'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_int2(anyenum) RETURNS int2 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int2)'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_int4(anyenum) RETURNS int4 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int4)'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_int8(anyenum) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int8)'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_numeric(anyenum) RETURNS numeric LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as numeric)'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_float4(anyenum) RETURNS float4 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as float4)'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_bit(anyenum, int4) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'Enum2Bit'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_date(anyenum) RETURNS date LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as date)'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_timestamp(anyenum) RETURNS timestamp without time zone LANGUAGE SQL IMMUTABLE STRICT as +'select cast(cast($1 as text) as timestamp without time zone)'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_timestamptz(anyenum) RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as +'select cast(cast($1 as text) as timestaptz)'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_time(anyenum) RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as time)'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_year(anyenum) RETURNS year LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int8) as year)'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_set(anyenum, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtoset'; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_json(anyenum) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; + + +CREATE OR REPLACE FUNCTION pg_catalog.text_enum(text, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.bpchar_enum(char, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bpchar_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.varchar_enum(varchar, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varchar_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.varlena_enum(anyelement, int4) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.set_enum(anyset, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'set_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.date_enum(date, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.datetime_enum(timestamp without time zone, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'datetime_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.timestamp_enum(timestamptz, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamp_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.time_enum(time, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.int1_enum(int1, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int1_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.int2_enum(int2, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int2_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.int4_enum(int4, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int4_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.int8_enum(int8, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.float4_enum(float4, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float4_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.float8_enum(float8, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float8_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.numeric_enum(numeric, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'numeric_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.bit_enum(bit, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bit_enum'; + +CREATE OR REPLACE FUNCTION pg_catalog.year_enum(year, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_enum'; + +--json.sql +DROP FUNCTION IF EXISTS pg_catalog.int1_json(int1) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int2_json(int2) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int4_json(int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int8_json(int8) cascade; +DROP FUNCTION IF EXISTS pg_catalog.float4_json(float4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.float8_json(float8) cascade; +DROP FUNCTION IF EXISTS pg_catalog.numeric_json(numeric) cascade; +DROP FUNCTION IF EXISTS pg_catalog.date_json(date) cascade; +DROP FUNCTION IF EXISTS pg_catalog.datetime_json(timestamp without time zone) cascade; +DROP FUNCTION IF EXISTS pg_catalog.timestamp_json(timestamptz) cascade; +DROP FUNCTION IF EXISTS pg_catalog.time_json(time) cascade; +DROP FUNCTION IF EXISTS pg_catalog.year_json(year) cascade; +DROP FUNCTION IF EXISTS pg_catalog.set_json(anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_varlena(anyenum) cascade; + +DROP CAST IF EXISTS (int1 as json) cascade; +DROP CAST IF EXISTS (int2 as json) cascade; +DROP CAST IF EXISTS (int4 as json) cascade; +DROP CAST IF EXISTS (int8 as json) cascade; +DROP CAST IF EXISTS (float4 as json) cascade; +DROP CAST IF EXISTS (float8 as json) cascade; +DROP CAST IF EXISTS (numeric as json) cascade; +DROP CAST IF EXISTS (date as json) cascade; +DROP CAST IF EXISTS (timestamp without time zone as json) cascade; +DROP CAST IF EXISTS (timestamptz as json) cascade; +DROP CAST IF EXISTS (time as json) cascade; +DROP CAST IF EXISTS (year as json) cascade; +DROP CAST IF EXISTS (anyset as json) cascade; + + + +CREATE OR REPLACE FUNCTION pg_catalog.int1_json(int1) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (int1 as json) WITH FUNCTION pg_catalog.int1_json(int1); + +CREATE OR REPLACE FUNCTION pg_catalog.int2_json(int2) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (int2 as json) WITH FUNCTION pg_catalog.int2_json(int2); + +CREATE OR REPLACE FUNCTION pg_catalog.int4_json(int4) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (int4 as json) WITH FUNCTION pg_catalog.int4_json(int4); + +CREATE OR REPLACE FUNCTION pg_catalog.int8_json(int8) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (int8 as json) WITH FUNCTION pg_catalog.int8_json(int8); + +CREATE OR REPLACE FUNCTION pg_catalog.float4_json(float4) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (float4 as json) WITH FUNCTION pg_catalog.float4_json(float4); + +CREATE OR REPLACE FUNCTION pg_catalog.float8_json(float8) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (float8 as json) WITH FUNCTION pg_catalog.float8_json(float8); + +CREATE OR REPLACE FUNCTION pg_catalog.numeric_json(numeric) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (numeric as json) WITH FUNCTION pg_catalog.numeric_json(numeric); + +CREATE OR REPLACE FUNCTION pg_catalog.date_json(date) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (date as json) WITH FUNCTION pg_catalog.date_json(date); + +CREATE OR REPLACE FUNCTION pg_catalog.datetime_json(timestamp without time zone) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (timestamp without time zone as json) WITH FUNCTION pg_catalog.datetime_json(timestamp without time zone); + +CREATE OR REPLACE FUNCTION pg_catalog.timestamp_json(timestamptz) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (timestamptz as json) WITH FUNCTION pg_catalog.timestamp_json(timestamptz); + +CREATE OR REPLACE FUNCTION pg_catalog.time_json(time) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (time as json) WITH FUNCTION pg_catalog.time_json(time); + +CREATE OR REPLACE FUNCTION pg_catalog.year_json(year) RETURNS json LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int4) as json)'; +CREATE CAST (year as json) WITH FUNCTION pg_catalog.year_json(year); + +CREATE OR REPLACE FUNCTION pg_catalog.set_json(anyset) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (anyset as json) WITH FUNCTION pg_catalog.set_json(anyset); + +CREATE OR REPLACE FUNCTION pg_catalog.enum_varlena(anyenum) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; + +--to_base64.sql +DROP FUNCTION IF EXISTS pg_catalog.bit_json (bit) CASCADE; +DROP CAST IF EXISTS (bit as json); + +CREATE OR REPLACE FUNCTION pg_catalog.bit_json(bit) +RETURNS json +AS +$$ +BEGIN + RETURN (SELECT to_json(concat('base64:type16:', to_base64($1)))); +END; +$$ +LANGUAGE plpgsql; + +CREATE CAST (bit as json) WITH FUNCTION pg_catalog.bit_json(bit); + +--unsigned_int.sql +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_date (uint1) cascade; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_date (uint2) cascade; + +DROP CAST IF EXISTS (uint1 AS date) CASCADE; +DROP CAST IF EXISTS (uint2 AS date) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_date (uint1) +RETURNS date LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_b_format_date'; +CREATE CAST(uint1 AS date) WITH FUNCTION int8_b_format_date(uint1) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_date (uint2) +RETURNS date LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int16_b_format_date'; +CREATE CAST(uint2 AS date) WITH FUNCTION int16_b_format_date(uint2) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.int64_b_format_date (uint8) cascade; +DROP FUNCTION IF EXISTS pg_catalog.date2uint1("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.date2uint2("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.date2uint4("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.date2uint8("date") cascade; +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_time(uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_time(uint2) CASCADE; + +DROP CAST IF EXISTS (uint8 AS date) CASCADE; +DROP CAST IF EXISTS ("date" as uint1) CASCADE; +DROP CAST IF EXISTS ("date" as uint2) CASCADE; +DROP CAST IF EXISTS ("date" as uint4) CASCADE; +DROP CAST IF EXISTS ("date" as uint8) CASCADE; +DROP CAST IF EXISTS (uint1 AS time) CASCADE; +DROP CAST IF EXISTS (uint2 AS time) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_date (uint8) +RETURNS date LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int64_b_format_date'; +CREATE CAST(uint8 AS date) WITH FUNCTION int64_b_format_date(uint8) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.date2uint1("date") RETURNS uint1 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::uint1; $$; +CREATE CAST ("date" as uint1) with function pg_catalog.date2uint1("date") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.date2uint2("date") RETURNS uint2 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::uint2; $$; +CREATE CAST ("date" as uint2) with function pg_catalog.date2uint2("date") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.date2uint4("date") RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::uint4; $$; +CREATE CAST ("date" as uint4) with function pg_catalog.date2uint4("date") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.date2uint8("date") RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::uint8; $$; +CREATE CAST ("date" as uint8) with function pg_catalog.date2uint8("date") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_time ( +uint1 +) RETURNS time LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint8_b_format_time'; +CREATE CAST (uint1 AS time) WITH FUNCTION int8_b_format_time(uint1) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_time ( +uint2 +) RETURNS time LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint16_b_format_time'; +CREATE CAST (uint2 AS time) WITH FUNCTION int16_b_format_time(uint2) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.int64_b_format_time(uint8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_uint1 (time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_uint2 (time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_uint4 (time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_uint8 (time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_datetime(uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_datetime(uint2) CASCADE; + +DROP CAST IF EXISTS (uint8 AS time) CASCADE; +DROP CAST IF EXISTS (time AS uint1) CASCADE; +DROP CAST IF EXISTS (time AS uint2) CASCADE; +DROP CAST IF EXISTS (time AS uint4) CASCADE; +DROP CAST IF EXISTS (time AS uint8) CASCADE; +DROP CAST IF EXISTS (uint1 AS timestamp(0) without time zone) CASCADE; +DROP CAST IF EXISTS (uint2 AS timestamp(0) without time zone) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_time ( +uint8 +) RETURNS time LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint64_b_format_time'; +CREATE CAST (uint8 AS time) WITH FUNCTION int64_b_format_time(uint8) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_time ( +uint4 +) RETURNS time LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint32_b_format_time'; + +CREATE OR REPLACE FUNCTION pg_catalog.time_uint1 (time) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time2uint1'; +CREATE CAST(time AS uint1) WITH FUNCTION time_uint1(time) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.time_uint2 (time) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time2uint2'; +CREATE CAST(time AS uint2) WITH FUNCTION time_uint2(time) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.time_uint4 (time) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time2uint4'; +CREATE CAST(time AS uint4) WITH FUNCTION time_uint4(time) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.time_uint8 (time) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time2uint8'; +CREATE CAST(time AS uint8) WITH FUNCTION time_uint8(time) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_datetime ( +uint1 +) RETURNS timestamp(0) without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_b_format_datetime'; +CREATE CAST (uint1 AS timestamp(0) without time zone) WITH FUNCTION int8_b_format_datetime(uint1) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_datetime ( +uint2 +) RETURNS timestamp(0) without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int16_b_format_datetime'; +CREATE CAST (uint2 AS timestamp(0) without time zone) WITH FUNCTION int16_b_format_datetime(uint2) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.datetime_uint1 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_uint2 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_uint4 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.datetime_uint8 (timestamp(0) without time zone) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_timestamp(uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_timestamp(uint2) CASCADE; + +DROP CAST IF EXISTS (timestamp(0) without time zone AS uint1) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS uint2) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS uint4) CASCADE; +DROP CAST IF EXISTS (timestamp(0) without time zone AS uint8) CASCADE; +DROP CAST IF EXISTS (uint1 AS timestamptz) CASCADE; +DROP CAST IF EXISTS (uint2 AS timestamptz) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.datetime_uint1 (timestamp(0) without time zone) RETURNS uint1 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as uint1)'; +CREATE CAST(timestamp(0) without time zone AS uint1) WITH FUNCTION datetime_uint1(timestamp(0) without time zone) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.datetime_uint2 (timestamp(0) without time zone) RETURNS uint2 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as uint2)'; +CREATE CAST(timestamp(0) without time zone AS uint2) WITH FUNCTION datetime_uint2(timestamp(0) without time zone) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.datetime_uint4 (timestamp(0) without time zone) RETURNS uint4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as uint4)'; +CREATE CAST(timestamp(0) without time zone AS uint4) WITH FUNCTION datetime_uint4(timestamp(0) without time zone) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.datetime_uint8 (timestamp(0) without time zone) RETURNS uint8 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as uint8)'; +CREATE CAST(timestamp(0) without time zone AS uint8) WITH FUNCTION datetime_uint8(timestamp(0) without time zone) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_timestamp ( +uint1 +) RETURNS timestamptz LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_b_format_timestamp'; +CREATE CAST (uint1 AS timestamptz) WITH FUNCTION int8_b_format_timestamp(uint1) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_timestamp ( +uint2 +) RETURNS timestamptz LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int16_b_format_timestamp'; +CREATE CAST (uint2 AS timestamptz) WITH FUNCTION int16_b_format_timestamp(uint2) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_uint1 ("timestamptz") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_uint2 ("timestamptz") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_uint4 ("timestamptz") CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int8_year(uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.int16_year(uint2) CASCADE; + +DROP CAST IF EXISTS ("timestamptz" AS uint1) CASCADE; +DROP CAST IF EXISTS ("timestamptz" AS uint2) CASCADE; +DROP CAST IF EXISTS ("timestamptz" AS uint4) CASCADE; +DROP CAST IF EXISTS (uint1 AS year) CASCADE; +DROP CAST IF EXISTS (uint2 AS year) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_uint1 ("timestamptz") RETURNS uint1 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as uint1)'; +CREATE CAST("timestamptz" AS uint1) WITH FUNCTION timestamptz_uint1("timestamptz") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_uint2 ("timestamptz") RETURNS uint2 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as uint2)'; +CREATE CAST("timestamptz" AS uint2) WITH FUNCTION timestamptz_uint2("timestamptz") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_uint4 ("timestamptz") RETURNS uint4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as uint4)'; +CREATE CAST("timestamptz" AS uint4) WITH FUNCTION timestamptz_uint4("timestamptz") AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.int8_year ( +uint1 +) RETURNS year LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_year'; +CREATE CAST (uint1 AS year) WITH FUNCTION int8_year(uint1) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.int16_year ( +uint2 +) RETURNS year LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int16_year'; +CREATE CAST (uint2 AS year) WITH FUNCTION int16_year(uint2) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.int64_year(uint8) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_uint1(year) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.year_uint2(year) CASCADE; + +DROP CAST IF EXISTS (uint8 AS year) CASCADE; +DROP CAST IF EXISTS (year AS uint1) CASCADE; +DROP CAST IF EXISTS (year AS uint2) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.int64_year ( +uint8 +) RETURNS year LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int64_year'; +CREATE CAST (uint8 AS year) WITH FUNCTION int64_year(uint8) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.year_uint1 ( +year +) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_int8'; +CREATE CAST (year AS uint1) WITH FUNCTION year_uint1(year) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.year_uint2 ( +year +) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_int16'; +CREATE CAST (year AS uint2) WITH FUNCTION year_uint2(year) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.uint1_json(uint1) cascade; +DROP FUNCTION IF EXISTS pg_catalog.uint2_json(uint2) cascade; +DROP FUNCTION IF EXISTS pg_catalog.uint4_json(uint4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.uint8_json(uint8) cascade; + +DROP CAST IF EXISTS (uint1 as json) cascade; +DROP CAST IF EXISTS (uint2 as json) cascade; +DROP CAST IF EXISTS (uint4 as json) cascade; +DROP CAST IF EXISTS (uint8 as json) cascade; + +CREATE OR REPLACE FUNCTION pg_catalog.uint1_json(uint1) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (uint1 as json) WITH FUNCTION pg_catalog.uint1_json(uint1); + +CREATE OR REPLACE FUNCTION pg_catalog.uint2_json(uint2) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (uint2 as json) WITH FUNCTION pg_catalog.uint2_json(uint2); + +CREATE OR REPLACE FUNCTION pg_catalog.uint4_json(uint4) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (uint4 as json) WITH FUNCTION pg_catalog.uint4_json(uint4); + +CREATE OR REPLACE FUNCTION pg_catalog.uint8_json(uint8) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; +CREATE CAST (uint8 as json) WITH FUNCTION pg_catalog.uint8_json(uint8); + + +DROP FUNCTION IF EXISTS pg_catalog.bittouint1(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittouint2(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromuint1(uint1, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bitfromuint2(uint2, int4) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.bittouint1 ( +bit +) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittouint1'; +CREATE OR REPLACE FUNCTION pg_catalog.bittouint2 ( +bit +) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittouint2'; + +CREATE OR REPLACE FUNCTION pg_catalog.bitfromuint1 ( +uint1, int4 +) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitfromuint1'; +CREATE OR REPLACE FUNCTION pg_catalog.bitfromuint2 ( +uint2, int4 +) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitfromuint2'; + +DROP CAST IF EXISTS (bit AS uint1) CASCADE; +DROP CAST IF EXISTS (bit AS uint2) CASCADE; +DROP CAST IF EXISTS (uint1 AS bit) CASCADE; +DROP CAST IF EXISTS (uint2 AS bit) CASCADE; + +CREATE CAST (bit AS uint1) WITH FUNCTION bittouint1(bit) AS ASSIGNMENT; +CREATE CAST (bit AS uint2) WITH FUNCTION bittouint2(bit) AS ASSIGNMENT; +CREATE CAST (uint1 AS bit) WITH FUNCTION bitfromuint1(uint1, int4) AS ASSIGNMENT; +CREATE CAST (uint2 AS bit) WITH FUNCTION bitfromuint2(uint2, int4) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.bpchar_uint1 (char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_uint2 (char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_uint4 (char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bpchar_uint8 (char) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_uint1 (varchar) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_uint2 (varchar) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_uint4 (varchar) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varchar_uint8 (varchar) CASCADE; + +DROP CAST IF EXISTS (char AS uint1) CASCADE; +DROP CAST IF EXISTS (char AS uint2) CASCADE; +DROP CAST IF EXISTS (char AS uint4) CASCADE; +DROP CAST IF EXISTS (char AS uint8) CASCADE; +DROP CAST IF EXISTS (varchar AS uint1) CASCADE; +DROP CAST IF EXISTS (varchar AS uint2) CASCADE; +DROP CAST IF EXISTS (varchar AS uint4) CASCADE; +DROP CAST IF EXISTS (varchar AS uint8) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.bpchar_uint1 (char) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bpchar_uint1'; +CREATE CAST(char AS uint1) WITH FUNCTION bpchar_uint1(char) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.bpchar_uint2 (char) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bpchar_uint2'; +CREATE CAST(char AS uint2) WITH FUNCTION bpchar_uint2(char) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.bpchar_uint4 (char) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bpchar_uint4'; +CREATE CAST(char AS uint4) WITH FUNCTION bpchar_uint4(char) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.bpchar_uint8 (char) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bpchar_uint8'; +CREATE CAST(char AS uint8) WITH FUNCTION bpchar_uint8(char) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.varchar_uint1 (varchar) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varchar_uint1'; +CREATE CAST(varchar AS uint1) WITH FUNCTION varchar_uint1(varchar) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.varchar_uint2 (varchar) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varchar_uint2'; +CREATE CAST(varchar AS uint2) WITH FUNCTION varchar_uint2(varchar) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.varchar_uint4 (varchar) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varchar_uint4'; +CREATE CAST(varchar AS uint4) WITH FUNCTION varchar_uint4(varchar) AS IMPLICIT; + +CREATE OR REPLACE FUNCTION pg_catalog.varchar_uint8 (varchar) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varchar_uint8'; +CREATE CAST(varchar AS uint8) WITH FUNCTION varchar_uint8(varchar) AS IMPLICIT; + + +DROP FUNCTION IF EXISTS pg_catalog.settobit(anyset, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.settoint1(anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.settouint1(anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.settouint2(anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.settouint4(anyset) cascade; +DROP FUNCTION IF EXISTS pg_catalog.settouint8(anyset) cascade; + +DROP CAST IF EXISTS (anyset AS bit) CASCADE; +DROP CAST IF EXISTS (anyset AS int1) CASCADE; +DROP CAST IF EXISTS (anyset AS uint1) CASCADE; +DROP CAST IF EXISTS (anyset AS uint2) CASCADE; +DROP CAST IF EXISTS (anyset AS uint4) CASCADE; +DROP CAST IF EXISTS (anyset AS uint8) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.settobit(anyset, int4) +RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'settobit'; +CREATE CAST (anyset AS bit) WITH FUNCTION settobit(anyset, int4) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.settoint1(anyset) +RETURNS int1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'settoint1'; +CREATE CAST (anyset AS int1) WITH FUNCTION settoint1(anyset) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.settouint1(anyset) +RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'settouint1'; +CREATE CAST (anyset AS uint1) WITH FUNCTION settouint1(anyset) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.settouint2(anyset) +RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'settouint2'; +CREATE CAST (anyset AS uint2) WITH FUNCTION settouint2(anyset) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.settouint4(anyset) +RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'settouint4'; +CREATE CAST (anyset AS uint4) WITH FUNCTION settouint4(anyset) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.settouint8(anyset) +RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'settouint8'; +CREATE CAST (anyset AS uint8) WITH FUNCTION settouint8(anyset) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.set(int1, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(uint1, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(uint2, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(uint4, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.set(uint8, int4) CASCADE; + +DROP CAST IF EXISTS (int1 AS anyset) CASCADE; +DROP CAST IF EXISTS (uint1 AS anyset) CASCADE; +DROP CAST IF EXISTS (uint2 AS anyset) CASCADE; +DROP CAST IF EXISTS (uint4 AS anyset) CASCADE; +DROP CAST IF EXISTS (uint8 AS anyset) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.set (int1, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'i1toset'; +CREATE CAST (int1 AS anyset) WITH FUNCTION pg_catalog.set(int1, int4) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set (uint1, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'ui1toset'; +CREATE CAST (uint1 AS anyset) WITH FUNCTION pg_catalog.set(uint1, int4) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set (uint2, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'ui2toset'; +CREATE CAST (uint2 AS anyset) WITH FUNCTION pg_catalog.set(uint2, int4) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set (uint4, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'ui4toset'; +CREATE CAST (uint4 AS anyset) WITH FUNCTION pg_catalog.set(uint4, int4) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.set (uint8, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'ui8toset'; +CREATE CAST (uint8 AS anyset) WITH FUNCTION pg_catalog.set(uint8, int4) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.uint1_enum(uint1, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.uint2_enum(uint2, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.uint4_enum(uint4, int4, anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.uint8_enum(uint8, int4, anyelement) cascade; + +CREATE OR REPLACE FUNCTION pg_catalog.uint1_enum(uint1, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint1_enum'; +CREATE OR REPLACE FUNCTION pg_catalog.uint2_enum(uint2, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint2_enum'; +CREATE OR REPLACE FUNCTION pg_catalog.uint4_enum(uint4, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint4_enum'; +CREATE OR REPLACE FUNCTION pg_catalog.uint8_enum(uint8, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint8_enum'; + + +DROP FUNCTION IF EXISTS pg_catalog.enum_uint1(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_uint2(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_uint4(anyenum) cascade; +DROP FUNCTION IF EXISTS pg_catalog.enum_uint8(anyenum) cascade; + +CREATE OR REPLACE FUNCTION pg_catalog.enum_uint1(anyenum) RETURNS uint1 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as uint1)'; +CREATE OR REPLACE FUNCTION pg_catalog.enum_uint2(anyenum) RETURNS uint2 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as uint2)'; +CREATE OR REPLACE FUNCTION pg_catalog.enum_uint4(anyenum) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as uint4)'; +CREATE OR REPLACE FUNCTION pg_catalog.enum_uint8(anyenum) RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as uint8)'; + + +DROP FUNCTION IF EXISTS pg_catalog.date_int8_xor( + date, + uint8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_date_xor( + uint8, + date +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_int8_xor( + time, + uint8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_time_xor( + uint8, + time +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.datetime_int8_xor( + timestamp without time zone, + uint8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_datetime_xor( + uint8, + timestamp without time zone +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int8_xor( + timestampTz, + uint8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_timestamptz_xor( + uint8, + timestampTz +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint1_eq( + date, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint2_eq( + date, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint1_eq( + time, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint2_eq( + time, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint1_ne( + date, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint2_ne( + date, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint1_ne( + time, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint2_ne( + time, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint1_date_ne( + uint1, + date +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint2_date_ne( + uint2, + date +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint1_time_ne( + uint1, + time +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint2_time_ne( + uint2, + time +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint1_lt( + date, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint2_lt( + date, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint1_lt( + time, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint2_lt( + time, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint1_gt( + date, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint2_gt( + date, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint1_gt( + time, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint2_gt( + time, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint1_le( + date, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint2_le( + date, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint1_le( + time, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint2_le( + time, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint1_ge( + date, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.date_uint2_ge( + date, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint1_ge( + time, + uint1 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.time_uint2_ge( + time, + uint2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_year_mod( + int8, + year +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_or_nvarchar2( + int8, + nvarchar2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_or_year( + int8, + year +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_or_int8( + nvarchar2, + int8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.year_or_int8( + year, + int8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_xor_nvarchar2( + int8, + nvarchar2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_xor_year( + int8, + year +) CASCADE; + + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_xor_int8( + nvarchar2, + int8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.year_xor_int8( + year, + int8 +) CASCADE; + + +DROP FUNCTION IF EXISTS pg_catalog.int8_and_nvarchar2( + int8, + nvarchar2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.int8_and_year( + int8, + year +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_and_int8( + nvarchar2, + int8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.year_and_int8( + year, + int8 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint4_mod_year( + uint4, + year +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_or_uint4( + nvarchar2, + uint4 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint4_or_nvarchar2( + uint4, + nvarchar2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.year_or_uint4( + year, + uint4 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint4_or_year( + uint4, + year +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.year_xor_uint4( + year, + uint4 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint4_xor_year( + uint4, + year +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_and_uint4( + nvarchar2, + uint4 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint4_and_nvarchar2( + uint4, + nvarchar2 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.year_and_uint4( + year, + uint4 +) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.uint4_and_year( + uint4, + year +) CASCADE; + + +create function pg_catalog.date_int8_xor( + date, + uint8 +) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_int8_xor'; +create operator pg_catalog.^(leftarg = date, rightarg = uint8, procedure = pg_catalog.date_int8_xor); + +create function pg_catalog.int8_date_xor( + uint8, + date +) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_date_xor'; +create operator pg_catalog.^(leftarg = uint8, rightarg = date, procedure = pg_catalog.int8_date_xor); + +create function pg_catalog.time_int8_xor( + time, + uint8 +) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_int8_xor'; +create operator pg_catalog.^(leftarg = time, rightarg = uint8, procedure = pg_catalog.time_int8_xor); + +create function pg_catalog.int8_time_xor( + uint8, + time +) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_time_xor'; +create operator pg_catalog.^(leftarg = uint8, rightarg = time, procedure = pg_catalog.int8_time_xor); + +create function pg_catalog.datetime_int8_xor( + timestamp without time zone, + uint8 +) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamp_int8_xor'; +create operator pg_catalog.^(leftarg = timestamp without time zone, rightarg = uint8, procedure = pg_catalog.datetime_int8_xor); + +create function pg_catalog.int8_datetime_xor( + uint8, + timestamp without time zone +) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_timestamp_xor'; +create operator pg_catalog.^(leftarg = uint8, rightarg = timestamp without time zone, procedure = pg_catalog.int8_datetime_xor); + +create function pg_catalog.timestamptz_int8_xor( + timestampTz, + uint8 +) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptz_int8_xor'; +create operator pg_catalog.^(leftarg = timestampTz, rightarg = uint8, procedure = pg_catalog.timestamptz_int8_xor); + +create function pg_catalog.int8_timestamptz_xor( + uint8, + timestampTz +) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_timestamptz_xor'; +create operator pg_catalog.^(leftarg = uint8, rightarg = timestampTz, procedure = pg_catalog.int8_timestamptz_xor); + +create function pg_catalog.date_uint1_eq( + date, + uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.texteq($1::text, $2::text) $$; +create operator pg_catalog.=(leftarg = date, rightarg = uint1, procedure = pg_catalog.date_uint1_eq); + +create function pg_catalog.date_uint2_eq( + date, + uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.texteq($1::text, $2::text) $$; +create operator pg_catalog.=(leftarg = date, rightarg = uint2, procedure = pg_catalog.date_uint2_eq); + +create function pg_catalog.time_uint1_eq( + time, + uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8eq($1::float8, $2::float8) $$; +create operator pg_catalog.=(leftarg = time, rightarg = uint1, procedure = pg_catalog.time_uint1_eq); + +create function pg_catalog.time_uint2_eq( + time, + uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8eq($1::float8, $2::float8) $$; +create operator pg_catalog.=(leftarg = time, rightarg = uint2, procedure = pg_catalog.time_uint2_eq); + +create function pg_catalog.date_uint1_ne( + date, + uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textne($1::text, $2::text) $$; +create operator pg_catalog.<>(leftarg = date, rightarg = uint1, procedure = pg_catalog.date_uint1_ne); + +create function pg_catalog.date_uint2_ne( + date, + uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textne($1::text, $2::text) $$; +create operator pg_catalog.<>(leftarg = date, rightarg = uint2, procedure = pg_catalog.date_uint2_ne); + +create function pg_catalog.time_uint1_ne( + time, + uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ne($1::float8, $2::float8) $$; +create operator pg_catalog.<>(leftarg = time, rightarg = uint1, procedure = pg_catalog.time_uint1_ne); + +create function pg_catalog.time_uint2_ne( + time, + uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ne($1::float8, $2::float8) $$; +create operator pg_catalog.<>(leftarg = time, rightarg = uint2, procedure = pg_catalog.time_uint2_ne); + +create function pg_catalog.uint1_date_ne( + uint1, + date +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textne($1::text, $2::text) $$; +create operator pg_catalog.<>(leftarg = uint1, rightarg = date, procedure = pg_catalog.uint1_date_ne); + +create function pg_catalog.uint2_date_ne( + uint2, + date +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textne($1::text, $2::text) $$; +create operator pg_catalog.<>(leftarg = uint2, rightarg = date, procedure = pg_catalog.uint2_date_ne); + +create function pg_catalog.uint1_time_ne( + uint1, + time +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ne($1::text, $2::text) $$; +create operator pg_catalog.<>(leftarg = uint1, rightarg = time, procedure = pg_catalog.uint1_time_ne); + +create function pg_catalog.uint2_time_ne( + uint2, + time +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ne($1::text, $2::text) $$; +create operator pg_catalog.<>(leftarg = uint2, rightarg = time, procedure = pg_catalog.uint2_time_ne); + +create function pg_catalog.date_uint1_lt( + date, + uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_lt($1::text, $2::text) $$; +create operator pg_catalog.<(leftarg = date, rightarg = uint1, procedure = pg_catalog.date_uint1_lt); + +create function pg_catalog.date_uint2_lt( + date, + uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_lt($1::text, $2::text) $$; +create operator pg_catalog.<(leftarg = date, rightarg = uint2, procedure = pg_catalog.date_uint2_lt); + +create function pg_catalog.time_uint1_lt( + time, + uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +create operator pg_catalog.<(leftarg = time, rightarg = uint1, procedure = pg_catalog.time_uint1_lt); + +create function pg_catalog.time_uint2_lt( + time, + uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +create operator pg_catalog.<(leftarg = time, rightarg = uint2, procedure = pg_catalog.time_uint2_lt); + +create function pg_catalog.date_uint1_gt( + date, + uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_gt($1::text, $2::text) $$; +create operator pg_catalog.>(leftarg = date, rightarg = uint1, procedure = pg_catalog.date_uint1_gt); + +create function pg_catalog.date_uint2_gt( + date, + uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_gt($1::text, $2::text) $$; +create operator pg_catalog.>(leftarg = date, rightarg = uint2, procedure = pg_catalog.date_uint2_gt); + +create function pg_catalog.time_uint1_gt( + time, + uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +create operator pg_catalog.>(leftarg = time, rightarg = uint1, procedure = pg_catalog.time_uint1_gt); + +create function pg_catalog.time_uint2_gt( + time, + uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +create operator pg_catalog.>(leftarg = time, rightarg = uint2, procedure = pg_catalog.time_uint2_gt); + +create function pg_catalog.date_uint1_le( + date, + uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_le($1::text, $2::text) $$; +create operator pg_catalog.<=(leftarg = date, rightarg = uint1, procedure = pg_catalog.date_uint1_le); + +create function pg_catalog.date_uint2_le( + date, + uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_le($1::text, $2::text) $$; +create operator pg_catalog.<=(leftarg = date, rightarg = uint2, procedure = pg_catalog.date_uint2_le); + +create function pg_catalog.time_uint1_le( + time, + uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +create operator pg_catalog.<=(leftarg = time, rightarg = uint1, procedure = pg_catalog.time_uint1_le); + +create function pg_catalog.time_uint2_le( + time, + uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +create operator pg_catalog.<=(leftarg = time, rightarg = uint2, procedure = pg_catalog.time_uint2_le); + +create function pg_catalog.date_uint1_ge( + date, + uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_ge($1::text, $2::text) $$; +create operator pg_catalog.>=(leftarg = date, rightarg = uint1, procedure = pg_catalog.date_uint1_ge); + +create function pg_catalog.date_uint2_ge( + date, + uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_ge($1::text, $2::text) $$; +create operator pg_catalog.>=(leftarg = date, rightarg = uint2, procedure = pg_catalog.date_uint2_ge); + +create function pg_catalog.time_uint1_ge( + time, + uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +create operator pg_catalog.>=(leftarg = time, rightarg = uint1, procedure = pg_catalog.time_uint1_ge); + +create function pg_catalog.time_uint2_ge( + time, + uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +create operator pg_catalog.>=(leftarg = time, rightarg = uint2, procedure = pg_catalog.time_uint2_ge); + +create function pg_catalog.int8_year_mod( + int8, + year +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_int4_mod($1::uint4, $2::int4) $$; +create operator pg_catalog.%(leftarg = int8, rightarg = year, procedure = pg_catalog.int8_year_mod); + +create function pg_catalog.int8_or_nvarchar2( + int8, + nvarchar2 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_or_int4($1::uint4, $2::int4) $$; +create operator pg_catalog.|(leftarg = int8, rightarg = nvarchar2, procedure = pg_catalog.int8_or_nvarchar2); + +create function pg_catalog.int8_or_year( + int8, + year +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_or_int4($1::uint4, $2::int4) $$; +create operator pg_catalog.|(leftarg = int8, rightarg = year, procedure = pg_catalog.int8_or_year); + +create function pg_catalog.nvarchar2_or_int8( + nvarchar2, + int8 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_or_uint4($1::int4, $2::uint4) $$; +create operator pg_catalog.|(leftarg = nvarchar2, rightarg = int8, procedure = pg_catalog.nvarchar2_or_int8); + +create function pg_catalog.year_or_int8( + year, + int8 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_or_uint4($1::int4, $2::uint4) $$; +create operator pg_catalog.|(leftarg = year, rightarg = int8, procedure = pg_catalog.year_or_int8); + +create function pg_catalog.int8_xor_nvarchar2( + int8, + nvarchar2 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_or_int4($1::uint4, $2::int4) $$; +create operator pg_catalog.#(leftarg = int8, rightarg = nvarchar2, procedure = pg_catalog.int8_xor_nvarchar2); + +create function pg_catalog.int8_xor_year( + int8, + year +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_xor_int4($1::uint4, $2::int4) $$; +create operator pg_catalog.#(leftarg = int8, rightarg = year, procedure = pg_catalog.int8_xor_year); +create operator pg_catalog.^(leftarg = int8, rightarg = year, procedure = pg_catalog.int8_xor_year); + +create function pg_catalog.nvarchar2_xor_int8( + nvarchar2, + int8 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_xor_uint4($1::int4, $2::uint4) $$; +create operator pg_catalog.#(leftarg = nvarchar2, rightarg = int8, procedure = pg_catalog.nvarchar2_xor_int8); + +create function pg_catalog.year_xor_int8( + year, + int8 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_xor_uint4($1::int4, $2::uint4) $$; +create operator pg_catalog.#(leftarg = year, rightarg = int8, procedure = pg_catalog.year_xor_int8); +create operator pg_catalog.^(leftarg = year, rightarg = int8, procedure = pg_catalog.year_xor_int8); + +create function pg_catalog.int8_and_nvarchar2( + int8, + nvarchar2 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_and_int4($1::uint4, $2::int4) $$; +create operator pg_catalog.&(leftarg = int8, rightarg = nvarchar2, procedure = pg_catalog.int8_and_nvarchar2); + +create function pg_catalog.int8_and_year( + int8, + year +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_and_int4($1::uint4, $2::int4) $$; +create operator pg_catalog.&(leftarg = int8, rightarg = year, procedure = pg_catalog.int8_and_year); + +create function pg_catalog.nvarchar2_and_int8( + nvarchar2, + int8 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_and_uint4($1::int4, $2::uint4) $$; +create operator pg_catalog.&(leftarg = nvarchar2, rightarg = int8, procedure = pg_catalog.nvarchar2_and_int8); + +create function pg_catalog.year_and_int8( + year, + int8 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_and_uint4($1::int4, $2::uint4) $$; +create operator pg_catalog.&(leftarg = year, rightarg = int8, procedure = pg_catalog.year_and_int8); + +create function pg_catalog.uint4_mod_year( + uint4, + year +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_int4_mod($1::uint4, $2::int4) $$; +create operator pg_catalog.%(leftarg = uint4, rightarg = year, procedure = pg_catalog.uint4_mod_year); + +create function pg_catalog.nvarchar2_or_uint4( + nvarchar2, + uint4 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_or_uint4($1::int4, $2::uint4) $$; +create operator pg_catalog.|(leftarg = nvarchar2, rightarg = uint4, procedure = pg_catalog.nvarchar2_or_uint4); + +create function pg_catalog.uint4_or_nvarchar2( + uint4, + nvarchar2 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_or_int4($1::uint4, $2::int4) $$; +create operator pg_catalog.|(leftarg = uint4, rightarg = nvarchar2, procedure = pg_catalog.uint4_or_nvarchar2); + +create function pg_catalog.year_or_uint4( + year, + uint4 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_or_uint4($1::int4, $2::uint4) $$; +create operator pg_catalog.|(leftarg = year, rightarg = uint4, procedure = pg_catalog.year_or_uint4); + +create function pg_catalog.uint4_or_year( + uint4, + year +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_or_int4($1::uint4, $2::int4) $$; +create operator pg_catalog.|(leftarg = uint4, rightarg = year, procedure = pg_catalog.uint4_or_year); + +create function pg_catalog.year_xor_uint4( + year, + uint4 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_xor_uint4($1::int4, $2::uint4) $$; +create operator pg_catalog.^(leftarg = year, rightarg = uint4, procedure = pg_catalog.year_xor_uint4); + +create function pg_catalog.uint4_xor_year( + uint4, + year +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_xor_int4($1::uint4, $2::int4) $$; +create operator pg_catalog.^(leftarg = uint4, rightarg = year, procedure = pg_catalog.uint4_xor_year); + +create function pg_catalog.nvarchar2_and_uint4( + nvarchar2, + uint4 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_and_uint4($1::int4, $2::uint4) $$; +create operator pg_catalog.&(leftarg = nvarchar2, rightarg = uint4, procedure = pg_catalog.nvarchar2_and_uint4); + +create function pg_catalog.uint4_and_nvarchar2( + uint4, + nvarchar2 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_and_int4($1::uint4, $2::int4) $$; +create operator pg_catalog.&(leftarg = uint4, rightarg = nvarchar2, procedure = pg_catalog.uint4_and_nvarchar2); + +create function pg_catalog.year_and_uint4( + year, + uint4 +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_and_uint4($1::int4, $2::uint4) $$; +create operator pg_catalog.&(leftarg = year, rightarg = uint4, procedure = pg_catalog.year_and_uint4); + +create function pg_catalog.uint4_and_year( + uint4, + year +) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_and_int4($1::uint4, $2::int4) $$; +create operator pg_catalog.&(leftarg = uint4, rightarg = year, procedure = pg_catalog.uint4_and_year); + + +--dolphin_binary_functions.sql + +--DROP FUNCTION IF EXISTS pg_catalog.varbinary_in (cstring); +CREATE OR REPLACE FUNCTION pg_catalog.varbinary_in ( +cstring +) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_binaryin'; + +--DROP FUNCTION IF EXISTS pg_catalog.bit2float4(bit); +CREATE OR REPLACE FUNCTION pg_catalog.bit2float4 (bit) RETURNS float4 AS +$$ +BEGIN + RETURN (SELECT bittouint8($1)); +END; +$$ +LANGUAGE plpgsql; + +--DROP FUNCTION IF EXISTS pg_catalog.bit2float8(bit); +CREATE OR REPLACE FUNCTION pg_catalog.bit2float8 (bit) RETURNS float8 AS +$$ +BEGIN + RETURN (SELECT bittouint8($1)); +END; +$$ +LANGUAGE plpgsql; + +--DROP FUNCTION IF EXISTS pg_catalog.bit_longblob(uint8,longblob); +CREATE OR REPLACE FUNCTION pg_catalog.bit_longblob (t1 uint8, t2 longblob) RETURNS uint8 AS +$$ +DECLARE num NUMBER := to_number(cast(t2 as text)); +BEGIN + IF num > 9223372036854775807 then + num = 9223372036854775807; + ELSEIF num < -9223372036854775808 then + num = 9223372036854775808; + END IF; + RETURN (SELECT uint8_xor(t1, num)); +END; +$$ +LANGUAGE plpgsql; + +DROP CAST IF EXISTS (json AS float8) CASCADE; +CREATE CAST (json AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.varlena2int1(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2int2(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2int4(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2int8(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2float4(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2numeric(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Bpchar(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Varchar(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Text(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Date(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Timestamptz(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Datetime(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Time(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Year(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.Varlena2Bit(anyelement, int4) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlenatoset(anyelement, int4) cascade; + +DROP CAST IF EXISTS ("binary" AS int1) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS int1) CASCADE; +DROP CAST IF EXISTS (blob AS int1) CASCADE; +DROP CAST IF EXISTS (tinyblob AS int1) CASCADE; +DROP CAST IF EXISTS (mediumblob AS int1) CASCADE; +DROP CAST IF EXISTS (longblob AS int1) CASCADE; +DROP CAST IF EXISTS (json AS int1) CASCADE; +DROP CAST IF EXISTS ("binary" AS int2) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS int2) CASCADE; +DROP CAST IF EXISTS (blob AS int2) CASCADE; +DROP CAST IF EXISTS (tinyblob AS int2) CASCADE; +DROP CAST IF EXISTS (mediumblob AS int2) CASCADE; +DROP CAST IF EXISTS (longblob AS int2) CASCADE; +DROP CAST IF EXISTS (json AS int2) CASCADE; +DROP CAST IF EXISTS ("binary" AS int4) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS int4) CASCADE; +DROP CAST IF EXISTS (blob AS int4) CASCADE; +DROP CAST IF EXISTS (tinyblob AS int4) CASCADE; +DROP CAST IF EXISTS (mediumblob AS int4) CASCADE; +DROP CAST IF EXISTS (longblob AS int4) CASCADE; +DROP CAST IF EXISTS (json AS int4) CASCADE; +DROP CAST IF EXISTS ("binary" AS int8) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS int8) CASCADE; +DROP CAST IF EXISTS (blob AS int8) CASCADE; +DROP CAST IF EXISTS (tinyblob AS int8) CASCADE; +DROP CAST IF EXISTS (mediumblob AS int8) CASCADE; +DROP CAST IF EXISTS (longblob AS int8) CASCADE; +DROP CAST IF EXISTS (json AS int8) CASCADE; +DROP CAST IF EXISTS ("binary" AS float4) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS float4) CASCADE; +DROP CAST IF EXISTS (blob AS float4) CASCADE; +DROP CAST IF EXISTS (tinyblob AS float4) CASCADE; +DROP CAST IF EXISTS (mediumblob AS float4) CASCADE; +DROP CAST IF EXISTS (longblob AS float4) CASCADE; +DROP CAST IF EXISTS (json AS float4) CASCADE; +DROP CAST IF EXISTS ("binary" AS numeric) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS numeric) CASCADE; +DROP CAST IF EXISTS (blob AS numeric) CASCADE; +DROP CAST IF EXISTS (tinyblob AS numeric) CASCADE; +DROP CAST IF EXISTS (mediumblob AS numeric) CASCADE; +DROP CAST IF EXISTS (longblob AS numeric) CASCADE; +DROP CAST IF EXISTS (json AS numeric) CASCADE; +DROP CAST IF EXISTS ("binary" AS char) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS char) CASCADE; +DROP CAST IF EXISTS (blob AS char) CASCADE; +DROP CAST IF EXISTS (tinyblob AS char) CASCADE; +DROP CAST IF EXISTS (mediumblob AS char) CASCADE; +DROP CAST IF EXISTS (longblob AS char) CASCADE; +DROP CAST IF EXISTS (json AS char) CASCADE; +DROP CAST IF EXISTS ("binary" AS varchar) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS varchar) CASCADE; +DROP CAST IF EXISTS (blob AS varchar) CASCADE; +DROP CAST IF EXISTS (tinyblob AS varchar) CASCADE; +DROP CAST IF EXISTS (mediumblob AS varchar) CASCADE; +DROP CAST IF EXISTS (longblob AS varchar) CASCADE; +DROP CAST IF EXISTS (json AS varchar) CASCADE; +DROP CAST IF EXISTS ("binary" AS text) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS text) CASCADE; +DROP CAST IF EXISTS (blob AS text) CASCADE; +DROP CAST IF EXISTS (tinyblob AS text) CASCADE; +DROP CAST IF EXISTS (mediumblob AS text) CASCADE; +DROP CAST IF EXISTS (longblob AS text) CASCADE; +DROP CAST IF EXISTS (json AS text) CASCADE; +DROP CAST IF EXISTS ("binary" AS date) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS date) CASCADE; +DROP CAST IF EXISTS (blob AS date) CASCADE; +DROP CAST IF EXISTS (tinyblob AS date) CASCADE; +DROP CAST IF EXISTS (mediumblob AS date) CASCADE; +DROP CAST IF EXISTS (longblob AS date) CASCADE; +DROP CAST IF EXISTS (json AS date) CASCADE; +DROP CAST IF EXISTS ("binary" AS timestamptz) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS timestamptz) CASCADE; +DROP CAST IF EXISTS (blob AS timestamptz) CASCADE; +DROP CAST IF EXISTS (tinyblob AS timestamptz) CASCADE; +DROP CAST IF EXISTS (mediumblob AS timestamptz) CASCADE; +DROP CAST IF EXISTS (longblob AS timestamptz) CASCADE; +DROP CAST IF EXISTS (json AS timestamptz) CASCADE; +DROP CAST IF EXISTS ("binary" AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS (blob AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS (tinyblob AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS (mediumblob AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS (longblob AS timestamp without time zone) CASCADE; +DROP CAST IF EXISTS (json AS timestamp without time zone)CASCADE; +DROP CAST IF EXISTS ("binary" AS time) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS time) CASCADE; +DROP CAST IF EXISTS (blob AS time) CASCADE; +DROP CAST IF EXISTS (tinyblob AS time) CASCADE; +DROP CAST IF EXISTS (mediumblob AS time) CASCADE; +DROP CAST IF EXISTS (longblob AS time) CASCADE; +DROP CAST IF EXISTS (json AS time) CASCADE; +DROP CAST IF EXISTS ("binary" AS year) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS year) CASCADE; +DROP CAST IF EXISTS (blob AS year) CASCADE; +DROP CAST IF EXISTS (tinyblob AS year) CASCADE; +DROP CAST IF EXISTS (mediumblob AS year) CASCADE; +DROP CAST IF EXISTS (longblob AS year) CASCADE; +DROP CAST IF EXISTS (json AS year) CASCADE; +DROP CAST IF EXISTS ("binary" AS bit) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS bit) CASCADE; +DROP CAST IF EXISTS (blob AS bit) CASCADE; +DROP CAST IF EXISTS (tinyblob AS bit) CASCADE; +DROP CAST IF EXISTS (mediumblob AS bit) CASCADE; +DROP CAST IF EXISTS (longblob AS bit) CASCADE; +DROP CAST IF EXISTS (json AS bit) CASCADE; +DROP CAST IF EXISTS ("binary" AS anyset) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS anyset) CASCADE; +DROP CAST IF EXISTS (blob AS anyset) CASCADE; +DROP CAST IF EXISTS (tinyblob AS anyset) CASCADE; +DROP CAST IF EXISTS (mediumblob AS anyset) CASCADE; +DROP CAST IF EXISTS (longblob AS anyset) CASCADE; +DROP CAST IF EXISTS (json AS anyset) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.varlena2int1(anyelement) RETURNS int1 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int1)'; + +CREATE CAST ("binary" AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.varlena2int2(anyelement) RETURNS int2 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int2)'; + +CREATE CAST ("binary" AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.varlena2int4(anyelement) RETURNS int4 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int4)'; + +CREATE CAST ("binary" AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.varlena2int8(anyelement) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int8)'; + +CREATE CAST ("binary" AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.varlena2float4(anyelement) RETURNS float4 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as float4)'; + +CREATE CAST ("binary" AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.varlena2numeric(anyelement) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'Varlena2Numeric'; + +CREATE CAST ("binary" AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Bpchar(anyelement) RETURNS char LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'Varlena2Bpchar'; + +CREATE CAST ("binary" AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Varchar(anyelement) RETURNS varchar LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'Varlena2Varchar'; + +CREATE CAST ("binary" AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Text(anyelement) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'Varlena2Text'; + +DROP CAST IF EXISTS (raw AS text); +CREATE CAST ("binary" AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS IMPLICIT; +CREATE CAST ("varbinary" AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS IMPLICIT; +CREATE CAST (raw AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS IMPLICIT; +CREATE CAST (blob AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Date(anyelement) RETURNS date LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as date)'; + +CREATE CAST ("binary" AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as +'select cast(cast($1 as text) as timestamptz)'; + +CREATE CAST ("binary" AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Datetime(anyelement) RETURNS timestamp without time zone LANGUAGE SQL IMMUTABLE STRICT as +'select cast(cast($1 as text) as timestamp without time zone)'; + +CREATE CAST ("binary" AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement); + + +CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Time(anyelement) RETURNS time LANGUAGE SQL IMMUTABLE STRICT as +'select cast(cast($1 as text) as time)'; + +CREATE CAST ("binary" AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Year(anyelement) RETURNS year LANGUAGE SQL IMMUTABLE STRICT as +'select cast(cast($1 as text) as year)'; + +CREATE CAST ("binary" AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'Varlena2Bit'; + +CREATE CAST ("binary" AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT; +CREATE CAST (blob AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT; +CREATE CAST (tinyblob AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT; +CREATE CAST (mediumblob AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT; +CREATE CAST (longblob AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT; +CREATE CAST (json AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT; + + +CREATE OR REPLACE FUNCTION pg_catalog.varlenatoset(anyelement, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlenatoset'; + +CREATE CAST ("binary" AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT; +CREATE CAST (blob AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT; +CREATE CAST (tinyblob AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT; +CREATE CAST (mediumblob AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT; +CREATE CAST (longblob AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT; +CREATE CAST (json AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.varlena_json(anyelement) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.varlena_json(anyelement) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json'; + +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (tinyblob) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (blob) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (mediumblob) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.to_base64 (longblob) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (tinyblob) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode'; +CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (blob) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode'; +CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (mediumblob) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode'; +CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (longblob) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode'; + +DROP CAST IF EXISTS (binary as json) CASCADE; +DROP CAST IF EXISTS (varbinary as json) CASCADE; +DROP CAST IF EXISTS (tinyblob as json) CASCADE; +DROP CAST IF EXISTS (blob as json) CASCADE; +DROP CAST IF EXISTS (mediumblob as json) CASCADE; +DROP CAST IF EXISTS (longblob as json) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.binary_json(binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.varbinary_json(varbinary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.tinyblob_json(tinyblob) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.blob_json(blob) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.mediumblob_json(mediumblob) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.longblob_json(longblob) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.binary_json(binary) +RETURNS json +AS +$$ +BEGIN + RETURN (SELECT to_json(concat('base64:type254:', to_base64($1)))); +END; +$$ +LANGUAGE plpgsql; +CREATE CAST (binary as json) WITH FUNCTION pg_catalog.binary_json(binary); + +CREATE OR REPLACE FUNCTION pg_catalog.varbinary_json(varbinary) +RETURNS json +AS +$$ +BEGIN + RETURN (SELECT to_json(concat('base64:type15:', to_base64($1)))); +END; +$$ +LANGUAGE plpgsql; +CREATE CAST (varbinary as json) WITH FUNCTION pg_catalog.varbinary_json(varbinary); + +CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_json(tinyblob) +RETURNS json +AS +$$ +BEGIN + RETURN (SELECT to_json(concat('base64:type249:', to_base64($1)))); +END; +$$ +LANGUAGE plpgsql; +CREATE CAST (tinyblob as json) WITH FUNCTION pg_catalog.tinyblob_json(tinyblob); + +CREATE OR REPLACE FUNCTION pg_catalog.blob_json(blob) +RETURNS json +AS +$$ +BEGIN + RETURN (SELECT to_json(concat('base64:type252:', to_base64($1)))); +END; +$$ +LANGUAGE plpgsql; +CREATE CAST (blob as json) WITH FUNCTION pg_catalog.blob_json(blob); + +CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_json(mediumblob) +RETURNS json +AS +$$ +BEGIN + RETURN (SELECT to_json(concat('base64:type250:', to_base64($1)))); +END; +$$ +LANGUAGE plpgsql; +CREATE CAST (mediumblob as json) WITH FUNCTION pg_catalog.mediumblob_json(mediumblob); + +CREATE OR REPLACE FUNCTION pg_catalog.longblob_json(longblob) +RETURNS json +AS +$$ +BEGIN + RETURN (SELECT to_json(concat('base64:type251:', to_base64($1)))); +END; +$$ +LANGUAGE plpgsql; +CREATE CAST (longblob as json) WITH FUNCTION pg_catalog.longblob_json(longblob); + + +DROP FUNCTION IF EXISTS pg_catalog.bittobinary(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittovarbinary(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittotinyblob(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittomediumblob(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittoblob(bit) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bittolongblob(bit) CASCADE; + +DROP CAST IF EXISTS (bit AS binary) CASCADE; +DROP CAST IF EXISTS (bit AS varbinary) CASCADE; +DROP CAST IF EXISTS (bit AS tinyblob) CASCADE; +DROP CAST IF EXISTS (bit AS mediumblob) CASCADE; +DROP CAST IF EXISTS (bit AS blob) CASCADE; +DROP CAST IF EXISTS (bit AS longblob) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.bittobinary(bit) +RETURNS binary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittobinary'; +CREATE CAST (bit AS binary) WITH FUNCTION bittobinary(bit) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.bittovarbinary(bit) +RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittovarbinary'; +CREATE CAST (bit AS varbinary) WITH FUNCTION bittovarbinary(bit) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.bittotinyblob(bit) +RETURNS tinyblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittotinyblob'; +CREATE CAST (bit AS tinyblob) WITH FUNCTION bittotinyblob(bit) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.bittomediumblob(bit) +RETURNS mediumblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittomediumblob'; +CREATE CAST (bit AS mediumblob) WITH FUNCTION bittomediumblob(bit) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.bittoblob(bit) +RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittoblob'; +CREATE CAST (bit AS blob) WITH FUNCTION bittoblob(bit) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.bittolongblob(bit) +RETURNS longblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bittolongblob'; +CREATE CAST (bit AS longblob) WITH FUNCTION bittolongblob(bit) AS ASSIGNMENT; + + +DROP FUNCTION IF EXISTS pg_catalog.blob_date_xor( + blob, + date +) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.date_blob_xor( + date, + blob +) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.blob_timestamptz_xor( + blob, + timestamptz +) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_blob_xor( + timestamptz, + blob +) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.time_xor_bit( + time, + bit +) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bit_xor_time( + bit, + time +) CASCADE; + +create function pg_catalog.blob_date_xor( + blob, + date +) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8_date_xor($1::float8, $2) $$; +create operator pg_catalog.^(leftarg = blob, rightarg = date, procedure = pg_catalog.blob_date_xor); + +create function pg_catalog.date_blob_xor( + date, + blob +) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.date_float8_xor($1, $2::float8) $$; +create operator pg_catalog.^(leftarg = date, rightarg = blob, procedure = pg_catalog.date_blob_xor); + +create function pg_catalog.blob_timestamptz_xor( + blob, + timestamptz +) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8_timestamptz_xor($1::float8, $2) $$; +create operator pg_catalog.^(leftarg = blob, rightarg = timestamptz, procedure = pg_catalog.blob_timestamptz_xor); + +create function pg_catalog.timestamptz_blob_xor( + timestamptz, + blob +) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.timestamptz_float8_xor($1, $2::float8) $$; +create operator pg_catalog.^(leftarg = timestamptz, rightarg = blob, procedure = pg_catalog.timestamptz_blob_xor); + +create function pg_catalog.time_xor_bit( + time, + bit +) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.dpow($1::float8, $2::float8) $$; +create operator pg_catalog.^(leftarg = time, rightarg = bit, procedure = pg_catalog.time_xor_bit); + +create function pg_catalog.bit_xor_time( + bit, + time +) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.dpow($1::float8, $2::float8) $$; +create operator pg_catalog.^(leftarg = bit, rightarg = time, procedure = pg_catalog.bit_xor_time); + +--update_castcontext +DROP FUNCTION IF EXISTS pg_catalog.update_castcontext(varchar, varchar) CASCADE; +CREATE FUNCTION pg_catalog.update_castcontext(varchar, varchar) RETURNS varchar AS +$$ +DECLARE + s_type ALIAS FOR $1; + t_type ALIAS FOR $2; +BEGIN + update pg_cast set castcontext='i', castowner=10 where castsource=(select oid from pg_type where typname=s_type) and casttarget=(select oid from pg_type where typname=t_type); + RETURN 'SUCCESS'; +END; +$$ +LANGUAGE plpgsql; + +DO +$$ +BEGIN + PERFORM pg_catalog.update_castcontext('int8', 'int1'); + PERFORM pg_catalog.update_castcontext('int8', 'int2'); + PERFORM pg_catalog.update_castcontext('int8', 'int4'); + + PERFORM pg_catalog.update_castcontext('date', 'int4'); + PERFORM pg_catalog.update_castcontext('date', 'int8'); + PERFORM pg_catalog.update_castcontext('date', 'uint4'); + PERFORM pg_catalog.update_castcontext('date', 'uint8'); + PERFORM pg_catalog.update_castcontext('date', 'float4'); + PERFORM pg_catalog.update_castcontext('date', 'float8'); + PERFORM pg_catalog.update_castcontext('date', 'numeric'); + PERFORM pg_catalog.update_castcontext('timestamp', 'int8'); + PERFORM pg_catalog.update_castcontext('timestamp', 'uint8'); + PERFORM pg_catalog.update_castcontext('timestamp', 'float4'); + PERFORM pg_catalog.update_castcontext('timestamp', 'numeric'); + PERFORM pg_catalog.update_castcontext('timestamptz', 'int8'); + PERFORM pg_catalog.update_castcontext('timestamptz', 'uint8'); + PERFORM pg_catalog.update_castcontext('timestamptz', 'float4'); + PERFORM pg_catalog.update_castcontext('timestamptz', 'float8'); + PERFORM pg_catalog.update_castcontext('timestamptz', 'numeric'); + PERFORM pg_catalog.update_castcontext('time', 'int4'); + PERFORM pg_catalog.update_castcontext('time', 'int8'); + PERFORM pg_catalog.update_castcontext('time', 'uint4'); + PERFORM pg_catalog.update_castcontext('time', 'uint8'); + PERFORM pg_catalog.update_castcontext('time', 'float4'); + PERFORM pg_catalog.update_castcontext('time', 'numeric'); +END +$$ +LANGUAGE plpgsql; +DROP FUNCTION IF EXISTS pg_catalog.oct(bit); +CREATE OR REPLACE FUNCTION pg_catalog.oct(bit) RETURNS text AS +$$ +BEGIN + RETURN 0; +END; +$$ +LANGUAGE plpgsql; + +DROP FUNCTION IF EXISTS pg_catalog.update_castcontext(varchar, varchar) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.ord(varbit); +CREATE FUNCTION pg_catalog.ord (varbit) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'ord_bit'; + +DROP FUNCTION IF EXISTS pg_catalog.substring_index (text, text, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.substring_index (boolean, text, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.substring_index (text, boolean, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.substring_index (boolean, boolean, numeric) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.substring_index ("any", "any", text) CASCADE; +CREATE FUNCTION pg_catalog.substring_index ( +"any", +"any", +text +) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_text'; + +DROP FUNCTION IF EXISTS pg_catalog.substring_index ("any", "any", numeric) CASCADE; +CREATE FUNCTION pg_catalog.substring_index ( +"any", +"any", +numeric +) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_numeric'; +DROP FUNCTION IF EXISTS pg_catalog.export_set (numeric, text, text, text, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.export_set (numeric, text, text, text) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.export_set (numeric, text, text) CASCADE; + +DROP FUNCTION IF EXISTS pg_catalog.export_set (int16, "any", "any", "any", int8) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.export_set (int16, "any", "any", "any", int8) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_5args_any'; + +DROP FUNCTION IF EXISTS pg_catalog.export_set (int16, "any", "any", "any") CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.export_set (int16, "any", "any", "any") RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_4args_any'; + +DROP FUNCTION IF EXISTS pg_catalog.export_set (int16, "any", "any") CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.export_set (int16, "any", "any") RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_3args_any'; + +DROP FUNCTION IF EXISTS pg_catalog.export_set (bit, "any", "any", "any", bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.export_set (bit, "any", "any", "any", bit) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_5args_bits'; + +DROP FUNCTION IF EXISTS pg_catalog.export_set (bit, "any", "any", "any", int8) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.export_set (bit, "any", "any", "any", int8) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_5args_bit_1'; + +DROP FUNCTION IF EXISTS pg_catalog.export_set (int16, "any", "any", "any", bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.export_set (int16, "any", "any", "any", bit) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_5args_bit_5'; + +DROP FUNCTION IF EXISTS pg_catalog.export_set (bit, "any", "any", "any") CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.export_set (bit, "any", "any", "any") RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_4args_bit'; + +DROP FUNCTION IF EXISTS pg_catalog.export_set (bit, "any", "any") CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.export_set (bit, "any", "any") RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_3args_bit'; + +DROP FUNCTION IF EXISTS pg_catalog.sleep(d date) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.sleep(d date) +RETURNS int AS +$$ +BEGIN + RETURN (select sleep(date_int(d))); +END; +$$ +LANGUAGE plpgsql; + +DROP FUNCTION IF EXISTS pg_catalog.pg_open_tables() CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.pg_open_tables(TEXT) CASCADE; +CREATE FUNCTION pg_catalog.pg_open_tables() + RETURNS TABLE ("oid" Oid, "relname" TEXT, "relnamespace" TEXT, "refcnt" int4, "lockcnt" int4, "accessexclusive_lockcnt" int4) + LANGUAGE C VOLATILE STRICT as '$libdir/dolphin', 'pg_open_tables'; +CREATE FUNCTION pg_catalog.pg_open_tables(TEXT) + RETURNS TABLE ("oid" Oid, "relname" TEXT, "relnamespace" TEXT, "refcnt" int4, "lockcnt" int4, "accessexclusive_lockcnt" int4) + LANGUAGE C VOLATILE STRICT as '$libdir/dolphin', 'pg_open_tables'; + +DROP FUNCTION IF EXISTS pg_catalog.compress (text) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.compress (text) RETURNS bytea LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'compress_text'; + +DROP FUNCTION IF EXISTS pg_catalog.compress (bytea) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.compress (bytea) RETURNS bytea LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'compress_bytea'; + +DROP FUNCTION IF EXISTS pg_catalog.compress (boolean) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.compress (boolean) RETURNS bytea LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'compress_boolean'; + +DROP FUNCTION IF EXISTS pg_catalog.compress (bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.compress (bit) RETURNS bytea LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'compress_bit'; + +DROP FUNCTION IF EXISTS pg_catalog.uncompress (text) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.uncompress (text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompress_text'; + +DROP FUNCTION IF EXISTS pg_catalog.uncompress (bytea) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.uncompress (bytea) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompress_bytea'; + +DROP FUNCTION IF EXISTS pg_catalog.uncompress (boolean) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.uncompress (boolean) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompress_boolean'; + +DROP FUNCTION IF EXISTS pg_catalog.uncompress (bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.uncompress (bit) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompress_bit'; + +DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length (text) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.uncompressed_length (text) RETURNS uint4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompressed_length_text'; + +DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length (bytea) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.uncompressed_length (bytea) RETURNS uint4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompressed_length_bytea'; + +DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length (boolean) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.uncompressed_length (boolean) RETURNS uint4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompressed_length_boolean'; + +DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length (bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.uncompressed_length (bit) RETURNS uint4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompressed_length_bit'; + +DROP FUNCTION IF EXISTS pg_catalog.weight_string(TEXT, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(TEXT, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_single'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(bytea, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(bytea, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_bytea'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(boolean, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(boolean, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_boolean'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(numeric, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(numeric, uint4) RETURNS text AS +$$ +BEGIN + RETURN NULL; +END; +$$ +LANGUAGE plpgsql; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(date, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(date, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_date'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(time, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(time, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_time'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(timestamp without time zone, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(timestamp without time zone, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_timestamp'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(timestamptz, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(timestamptz, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_timestamptz'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(interval, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(interval, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_interval'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(bit, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(bit, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_bit'; + +DROP FUNCTION IF EXISTS pg_catalog.weight_string(TEXT, TEXT, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(TEXT, TEXT, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (bytea, text, uint4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(bytea, TEXT, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_bytea'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(boolean, TEXT, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(boolean, TEXT, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_boolean'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(numeric, TEXT, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(numeric, TEXT, uint4) RETURNS text AS +$$ +BEGIN + RETURN NULL; +END; +$$ +LANGUAGE plpgsql; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(date, TEXT, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(date, TEXT, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_date'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(time, TEXT, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(time, TEXT, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_time'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(timestamp without time zone, TEXT, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(timestamp without time zone, TEXT, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_timestamp'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(timestamptz, TEXT, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(timestamptz, TEXT, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_timestamptz'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(interval, TEXT, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(interval, TEXT, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_interval'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(bit, TEXT, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(bit, TEXT, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_bit'; + +DROP FUNCTION IF EXISTS pg_catalog.weight_string(TEXT, TEXT, uint4, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(TEXT, TEXT, uint4, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (bytea, text, uint4, uint4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(bytea, TEXT, uint4, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_bytea'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(boolean, TEXT, uint4, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(boolean, TEXT, uint4, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_boolean'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(numeric, TEXT, uint4, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(numeric, TEXT, TEXT, uint4) RETURNS text AS +$$ +BEGIN + RETURN NULL; +END; +$$ +LANGUAGE plpgsql; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(date, TEXT, uint4, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(date, TEXT, uint4, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_date'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(time, TEXT, uint4, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(time, TEXT, uint4, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_time'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(timestamp without time zone, TEXT, uint4, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(timestamp without time zone, TEXT, uint4, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_timestamp'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(timestamptz, TEXT, uint4, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(timestamptz, TEXT, uint4, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_timestamptz'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(interval, TEXT, uint4, uint4) cascade; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(interval, TEXT, uint4, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_interval'; +DROP FUNCTION IF EXISTS pg_catalog.weight_string (bit, text, uint4, uint4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(bit, TEXT, uint4, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_bit'; + +drop aggregate if exists pg_catalog.bit_xor(text); +DROP FUNCTION IF EXISTS pg_catalog.text_xor(uint8,text) CASCADE; + +CREATE FUNCTION pg_catalog.text_xor (t1 uint8,t2 text) RETURNS uint8 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'uint8_xor_text'; +create aggregate pg_catalog.bit_xor(text) (SFUNC=text_xor, STYPE= uint8); + +drop schema if exists performance_schema CASCADE; +create schema performance_schema; + +CREATE OR REPLACE FUNCTION pg_catalog.get_statement_history( +OUT schema_name name,OUT unique_query_id bigint,OUT debug_query_id bigint,OUT query text, +OUT start_time timestamp with time zone, OUT finish_time timestamp with time zone,OUT thread_id bigint, +OUT session_id bigint, OUT n_returned_rows bigint, OUT n_tuples_inserted bigint,OUT n_tuples_updated bigint, +OUT n_tuples_deleted bigint,OUT cpu_time bigint,OUT lock_time bigint) +RETURNS setof record +AS $$ +DECLARE + row_data record; + port text; + query_str text; + query_str_nodes text; + user_name text; + dblink_ext int; + BEGIN + --check privileges only sysadm or omsysadm can access the dbe_perf.statement table; + SELECT SESSION_USER INTO user_name; + IF pg_catalog.has_schema_privilege(user_name, 'dbe_perf', 'USAGE') = false + THEN + RAISE EXCEPTION 'user % has no privilege to use schema dbe_perf',user_name; + END IF; + + IF pg_catalog.has_table_privilege(user_name, 'dbe_perf.statement_history', 'SELECT') = false + THEN + RAISE EXCEPTION 'user % has no privilege to access dbe_perf.statement_history',user_name; + END IF; + + --check if dblink exists, lite mode does not have dblink + EXECUTE('SELECT count(*) from pg_extension where extname=''dblink''') into dblink_ext; + IF dblink_ext = 0 + THEN + RAISE EXCEPTION 'dblink is needed by this function, please load dblink extension first'; + END IF; + + --get the port number + EXECUTE('SELECT setting FROM pg_settings WHERE name = ''port''') into port; + + query_str := concat(concat('select * from public.dblink(''dbname=postgres port=',port),''',''select schema_name,unique_query_id,debug_query_id,query ,start_time,finish_time, thread_id ,session_id ,n_returned_rows ,n_tuples_inserted ,n_tuples_updated ,n_tuples_deleted ,cpu_time , lock_time from dbe_perf.statement_history'') as t(schema_name name,unique_query_id bigint,debug_query_id bigint,query text,start_time timestamp with time zone, finish_time timestamp with time zone,thread_id bigint,session_id bigint, n_returned_rows bigint, n_tuples_inserted bigint, n_tuples_updated bigint,n_tuples_deleted bigint,cpu_time bigint,lock_time bigint)'); + FOR row_data IN EXECUTE(query_str) LOOP + schema_name :=row_data.schema_name; + unique_query_id := row_data.unique_query_id; + debug_query_id := row_data.debug_query_id; + query := row_data.query; + start_time := row_data.start_time; + finish_time := row_data.finish_time; + thread_id := row_data.thread_id; + session_id := row_data.session_id; + n_returned_rows := row_data.n_returned_rows; + n_tuples_inserted := row_data.n_tuples_inserted; + n_tuples_updated := row_data.n_tuples_updated; + n_tuples_deleted := row_data.n_tuples_deleted; + cpu_time := row_data.cpu_time; + lock_time:= row_data.lock_time; + return next; + END LOOP; + return; + END; $$ +LANGUAGE 'plpgsql' +SECURITY DEFINER; + +CREATE VIEW performance_schema.statement_history AS +select * from pg_catalog.get_statement_history(); + +create view performance_schema.events_statements_current as +select + s.pid as THREAD_ID, + NULL as EVENT_ID, + NULL as END_EVENT_ID, + NULL AS EVENT_NAME, + s.application_name AS SOURCE, + s.query_start AS TIMER_START, + CASE + WHEN s.state = 'active' THEN CURRENT_TIMESTAMP + ELSE s.state_change + END AS TIMER_END, + CASE + WHEN s.state = 'active' THEN CURRENT_TIMESTAMP - s.query_start + ELSE s.state_change - s.query_start + END AS TIMER_WAIT, + NULL AS LOCK_TIME, + s.QUERY AS SQL_TEXT, + SHA2(t.QUERY,256) AS DIGEST, + t.QUERY AS DIGEST_TEXT, + h.schema_name AS SCHEMA_NAME, + NULL AS OBJECT_TYPE, + NULL AS OBJECT_SCHEMA, + NULL AS OBJECT_NAME, + NULL AS OBJECT_INSTANCE_BEGIN, + NULL AS MYSQL_ERRNO, + NULL AS RETURNED_SQLSTATE, + NULL AS MESSAGE_TEXT, + NULL AS ERRORS, + NULL AS WARNING_COUNT, + (h.n_tuples_deleted+h.n_tuples_inserted+h.n_tuples_inserted) AS ROW_AFFECTED, + h.n_returned_rows AS ROW_SENT, + NULL AS ROW_EXAMINED, + NULL AS CREATED_TMP_DISK_TABLES, + NULL AS CREATED_TMP_TABLES, + NULL AS SELECT_FULL_JOIN, + NULL AS SELECT_FULL_RANGE_JOIN, + NULL AS SELECT_RANGE, + NULL AS SELECT_RANGE_CHECK, + NULL AS SELECT_SCAN, + NULL AS SORT_MERGE_PASSES, + NULL AS SORT_RANGE, + NULL AS SORT_ROWS, + NULL AS SORT_SCAN, + NULL AS NO_INDEX_USED, + NULL AS NO_GOOD_INDEX_USED, + NULL AS NESTING_EVENT_ID, + NULL AS NESTING_EVENT_TYPE, + NULL AS NESTING_EVENT_LEVEL, + h.debug_query_id AS STATEMENT_ID, + h.CPU_TIME AS CPU_TIME, + NULL AS MAX_CONTROLLED_MEMORY, + NULL AS MAX_TOTAL_MEMORY, + NULL AS EXECUTION_ENGINE + FROM pg_catalog.pg_stat_activity s + left outer join performance_schema.statement_history h + on s.query_id = h.debug_query_id + and h.session_id = s.sessionid + left outer join dbe_perf.statement t + on s.unique_sql_id = t.unique_sql_id + where s.query_start IS NOT NULL +; +/* ---------------------- + * Create performance_schema.events_statements_history + * ---------------------- + */ +create view performance_schema.events_statements_history as +select + h.thread_id as THREAD_ID, + NULL as EVENT_ID, + NULL as END_EVENT_ID, + NULL AS EVENT_NAME, + s.application_name AS SOURCE, + h.start_time AS TIMER_START, + h.finish_time AS TIMER_END, + h.finish_time - h.start_time AS TIMER_WAIT, + h.lock_time AS LOCK_TIME, + h.QUERY AS SQL_TEXT, + SHA2(t.QUERY,256) AS DIGEST, + t.QUERY AS DIGEST_TEXT, + h.schema_name AS SCHEMA_NAME, + NULL AS OBJECT_TYPE, + NULL AS OBJECT_SCHEMA, + NULL AS OBJECT_NAME, + NULL AS OBJECT_INSTANCE_BEGIN, + NULL AS MYSQL_ERRNO, + NULL AS RETURNED_SQLSTATE, + NULL AS MESSAGE_TEXT, + 0 AS ERRORS, + NULL AS WARNING_COUNT, + (h.n_tuples_deleted+h.n_tuples_inserted+h.n_tuples_inserted) AS ROW_AFFECTED, + h.n_returned_rows AS ROW_SENT, + NULL AS ROW_EXAMINED, + NULL AS CREATED_TMP_DISK_TABLES, + NULL AS CREATED_TMP_TABLES, + NULL AS SELECT_FULL_JOIN, + NULL AS SELECT_FULL_RANGE_JOIN, + NULL AS SELECT_RANGE, + NULL AS SELECT_RANGE_CHECK, + NULL AS SELECT_SCAN, + NULL AS SORT_MERGE_PASSES, + NULL AS SORT_RANGE, + NULL AS SORT_ROWS, + NULL AS SORT_SCAN, + NULL AS NO_INDEX_USED, + NULL AS NO_GOOD_INDEX_USED, + NULL AS NESTING_EVENT_ID, + NULL AS NESTING_EVENT_TYPE, + NULL AS NESTING_EVENT_LEVEL, + h.debug_query_id AS STATEMENT_ID, + h.CPU_TIME AS CPU_TIME, + NULL AS MAX_CONTROLLED_MEMORY, + NULL AS MAX_TOTAL_MEMORY, + NULL AS EXECUTION_ENGINE + FROM performance_schema.statement_history h + left outer join dbe_perf.statement t + on h.unique_query_id = t.unique_sql_id + inner join pg_catalog.pg_stat_activity s + on h.session_id = s.sessionid +; +/* ---------------------- + * Create performance_schema.events_statements_summary_by_digest + * ---------------------- + */ +create view performance_schema.events_statements_summary_by_digest as +SELECT + h.schema_name AS SCHEMA_NAME, + SHA2(t.QUERY,256) AS DIGEST, + t.QUERY AS DIGEST_TEXT, + t.N_CALLS AS COUNT_STAR, + t.TOTAL_ELAPSE_TIME AS SUM_TIMER_WAIT, + t.MIN_ELAPSE_TIME AS MIN_TIMER_WAIT, + CASE + WHEN t.N_CALLS THEN round(t.TOTAL_ELAPSE_TIME/t.N_CALLS) + ELSE 0 + END AS AVG_TIMER_WAIT, + t.MAX_ELAPSE_TIME AS MAX_TIMER_WAIT, + NULL AS SUM_LOCK_TIME, + NULL AS SUM_ERRORS, + NULL AS SUM_WARNINGS, + (t.n_tuples_deleted+t.n_tuples_inserted+t.n_tuples_inserted) AS SUM_ROWS_AFFECTED, + t.N_RETURNED_ROWS AS SUM_ROWS_SENT, + NULL AS SUM_ROWS_EXAMINED, + NULL AS SUM_CREATED_TMP_DISK_TABLES, + NULL AS SUM_CREATED_TMP_TABLES, + NULL AS SUM_SELECT_FULL_JOIN, + NULL AS SUM_SELECT_FULL_RANGE_JOIN, + NULL AS SUM_SELECT_RANGE, + NULL AS SUM_SELECT_RANGE_CHECK, + NULL AS SUM_SELECT_SCAN, + NULL AS SUM_SORT_MERGE_PASSES, + NULL AS SUM_SORT_RANGE, + NULL AS SUM_SORT_ROWS, + t.sort_count AS SUM_SORT_SCAN, + NULL AS SUM_NO_INDEX_USED, + NULL AS SUM_NO_GOOD_INDEX_USED, + t.CPU_TIME AS SUM_CPU_TIME, + NULL AS MAX_CONTROLLED_MEMORY, + NULL AS MAX_TOTAL_MEMORY, + NULL AS COUNT_SECONDARY, + NULL AS FIRST_SEEN, + t.last_updated AS LAST_SEEN, + NULL AS QUANTILE_95, + NULL AS QUANTILE_99, + NULL AS QUANTILE_999, + NULL AS QUERY_SAMPLE_TEXT, + NULL AS QUERY_SAMPLE_SEEN, + NULL AS QUERY_SAMPLE_TIMER_WAIT +FROM dbe_perf.statement t +left outer join performance_schema.statement_history h +on h.unique_query_id = t.unique_sql_id +; + + +create view performance_schema.events_waits_current as +SELECT + t.tid AS THREAD_ID, + NULL AS EVENT_ID, + NULL AS END_EVENT_ID, + concat(concat(concat(concat(t.thread_name,'/'),t.WAIT_STATUS),'/'),t.WAIT_EVENT) AS EVENT_NAME, + s.application_name AS SOURCE, + s.query_start AS TIMER_START, + CASE + WHEN s.state = 'active' THEN CURRENT_TIMESTAMP + ELSE s.state_change + END AS TIMER_END, + CASE + WHEN s.state = 'active' THEN CURRENT_TIMESTAMP - s.query_start + ELSE s.state_change - s.query_start + END AS TIMER_WAIT, + NULL AS SPINS, + n.nspname AS OBJECT_SCHEMA, + CASE + WHEN c.reltype !=0 THEN c.relname + ELSE NULL + END AS OBJECT_NAME, + CASE + WHEN c.reltype = 0 THEN c.relname + ELSE NULL + END AS INDEX_NAME, + l.locktype AS OBJECT_TYPE, + NULL AS OBJECT_INSTANCE_BEGIN, + NULL AS NESTING_EVENT_ID, + NULL AS NESTING_EVENT_TYPE, + NULL AS OPERATION, + NULL AS NUMBER_OF_BYTES, + NULL AS FLAGS +FROM pg_catalog.pg_thread_wait_status t +inner join pg_catalog.pg_stat_activity s + on t.sessionid = s.sessionid + LEFT OUTER join pg_catalog.pg_locks l + on t.locktag = l.locktag and l.pid = s.pid + LEFT OUTER join pg_catalog.pg_class c + on l.relation = c.oid + LEFT OUTER join pg_catalog.pg_namespace n + on c.relnamespace = n.oid; + + + +CREATE VIEW performance_schema.events_waits_summary_global_by_event_name AS +SELECT + concat(concat(w.type,''),w.event) AS EVENT_NAME, + w.wait AS COUNT_STAR, + w.total_wait_time as SUM_TIMER_WAIT, + w.min_wait_time as MIN_TIMER_WAIT, + w.avg_wait_time as AVG_TIMER_WAIT, + w.max_wait_time as MAX_TIMER_WAIT +FROM dbe_perf.wait_events as w; + + +CREATE VIEW performance_schema.file_summary_by_instance AS +SELECT +f.filenum AS FILE_NAME, +NULL AS EVENT_NAME, +NULL AS OBJECT_INSTANCE_BEGIN, +NULL AS COUNT_STAR, +NULL AS SUM_TIMER_WAIT, +NULL AS MIN_TIMER_WAIT, +NULL AS AVG_TIMER_WAIT, +NULL AS MAX_TIMER_WAIT, +f.phyrds AS COUNT_READ, +f.readtim AS SUM_TIMER_READ, +f.miniotim AS MIN_TIMER_READ, +f.avgiotim AS AVG_TIMER_READ, +f.maxiowtm AS MAX_TIMER_READ, +f.phyblkrd*8192 AS SUM_NUMBER_OF_BYTES_READ, +f.phywrts AS COUNT_WRITE, +f.writetim AS SUM_TIMER_WRITE, +f.miniotim AS MIN_TIMER_WRITE, +f.avgiotim AVG_TIMER_WRITE, +f.maxiowtm AS MAX_TIMER_WRITE, +f.phyblkwrt*8192 AS SUM_NUMBER_OF_BYTES_WRITE, +NULL AS COUNT_MISC, +NULL AS SUM_TIMER_MISC, +NULL AS MIN_TIMER_MISC, +NULL AS AVG_TIMER_MISC, +NULL AS MAX_TIMER_MISC +FROM dbe_perf.file_iostat f; + +CREATE VIEW performance_schema.table_io_waits_summary_by_table AS +SELECT +'TABLE' AS OBJECT_TYPE, +n.nspname AS OBJECT_SCHEMA, +c.relname AS OBJECT_NAME, +NULL AS COUNT_STAR, +NULL AS SUM_TIMER_WAIT, +NULL AS MIN_TIMER_WAIT, +NULL AS AVG_TIMER_WAIT, +NULL AS MAX_TIMER_WAIT, +SUM(f.phyrds) AS COUNT_READ, +SUM(f.readtim) AS SUM_TIMER_READ, +MIN(f.miniotim) AS MIN_TIMER_READ, +AVG(f.avgiotim) AS AVG_TIMER_READ, +MAX(f.maxiowtm) AS MAX_TIMER_READ, +SUM(f.phywrts) AS COUNT_WRITE, +SUM(f.writetim) AS SUM_TIMER_WRITE, +MIN(f.miniotim) AS MIN_TIMER_WRITE, +AVG(f.avgiotim) AS AVG_TIMER_WRITE, +MAX(f.maxiowtm) AS MAX_TIMER_WRITE, +NULL AS COUNT_FETCH, +NULL AS SUM_TIMER_FETCH, +NULL AS MIN_TIMER_FETCH, +NULL AS AVG_TIMER_FETCH, +NULL AS MAX_TIMER_FETCH, +NULL AS COUNT_INSERT, +NULL AS SUM_TIMER_INSERT, +NULL AS MIN_TIMER_INSERT, +NULL AS AVG_TIMER_INSERT, +NULL AS MAX_TIMER_INSERT, +NULL AS COUNT_UPDATE, +NULL AS SUM_TIMER_UPDATE, +NULL AS MIN_TIMER_UPDATE, +NULL AS AVG_TIMER_UPDATE, +NULL AS MAX_TIMER_UPDATE, +NULL AS COUNT_DELETE, +NULL AS SUM_TIMER_DELETE, +NULL AS MIN_TIMER_DELETE, +NULL AS AVG_TIMER_DELETE, +NULL AS MAX_TIMER_DELETE +FROM dbe_perf.file_iostat f, pg_class c, pg_namespace n +WHERE f.filenum = c.relfilenode +and c.relnamespace = n.oid +and c.relkind = 'r' +GROUP BY OBJECT_SCHEMA,OBJECT_NAME; + +CREATE VIEW performance_schema.table_io_waits_summary_by_index_usage AS +SELECT +'TABLE' AS OBJECT_TYPE, +n.nspname AS OBJECT_SCHEMA, +t.relname AS OBJECT_NAME, +c.relname AS INDEX_NAME, +NULL AS COUNT_STAR, +NULL AS SUM_TIMER_WAIT, +NULL AS MIN_TIMER_WAIT, +NULL AS AVG_TIMER_WAIT, +NULL AS MAX_TIMER_WAIT, +SUM(f.phyrds) AS COUNT_READ, +SUM(f.readtim) AS SUM_TIMER_READ, +MIN(f.miniotim) AS MIN_TIMER_READ, +AVG(f.avgiotim) AS AVG_TIMER_READ, +MAX(f.maxiowtm) AS MAX_TIMER_READ, +SUM(f.phywrts) AS COUNT_WRITE, +SUM(f.writetim) AS SUM_TIMER_WRITE, +MIN(f.miniotim) AS MIN_TIMER_WRITE, +AVG(f.avgiotim) AS AVG_TIMER_WRITE, +MAX(f.maxiowtm) AS MAX_TIMER_WRITE, +NULL AS COUNT_FETCH, +NULL AS SUM_TIMER_FETCH, +NULL AS MIN_TIMER_FETCH, +NULL AS AVG_TIMER_FETCH, +NULL AS MAX_TIMER_FETCH, +NULL AS COUNT_INSERT, +NULL AS SUM_TIMER_INSERT, +NULL AS MIN_TIMER_INSERT, +NULL AS AVG_TIMER_INSERT, +NULL AS MAX_TIMER_INSERT, +NULL AS COUNT_UPDATE, +NULL AS SUM_TIMER_UPDATE, +NULL AS MIN_TIMER_UPDATE, +NULL AS AVG_TIMER_UPDATE, +NULL AS MAX_TIMER_UPDATE, +NULL AS COUNT_DELETE, +NULL AS SUM_TIMER_DELETE, +NULL AS MIN_TIMER_DELETE, +NULL AS AVG_TIMER_DELETE, +NULL AS MAX_TIMER_DELETE +FROM dbe_perf.file_iostat f, pg_class c, pg_namespace n,pg_index i, pg_class t +WHERE f.filenum = c.relfilenode +and c.relnamespace = n.oid +and c.relkind in ( 'i','I') +and c.oid = i.indexrelid +and t.oid = i.indrelid +GROUP BY OBJECT_SCHEMA,OBJECT_NAME,INDEX_NAME; + +GRANT USAGE ON schema performance_schema TO PUBLIC; + +GRANT SELECT,REFERENCES on all tables in schema performance_schema to public; + +-- bool cast bit/float/double +DROP FUNCTION IF EXISTS pg_catalog.booltobit(bool, int4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.booltofloat4(bool) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.booltofloat8(bool) CASCADE; + +DROP CAST IF EXISTS (bool AS bit) CASCADE; +DROP CAST IF EXISTS (bool AS float4) CASCADE; +DROP CAST IF EXISTS (bool AS float8) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.booltobit(bool, int4) RETURNS bit LANGUAGE C STRICT AS '$libdir/dolphin', 'bool_bit'; +CREATE CAST (bool AS bit) WITH FUNCTION pg_catalog.booltobit(bool, int4) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.booltofloat4(bool) RETURNS float4 LANGUAGE C STRICT AS '$libdir/dolphin', 'bool_float4'; +CREATE CAST (bool AS float4) WITH FUNCTION pg_catalog.booltofloat4(bool) AS ASSIGNMENT; + +CREATE OR REPLACE FUNCTION pg_catalog.booltofloat8(bool) RETURNS float8 LANGUAGE C STRICT AS '$libdir/dolphin', 'bool_float8'; +CREATE CAST (bool AS float8) WITH FUNCTION pg_catalog.booltofloat8(bool) AS ASSIGNMENT; + +-- binary/varbinary -> text implicit +DROP FUNCTION IF EXISTS pg_catalog.hex(binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.hex(varbinary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uncompress(binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uncompress(varbinary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length(binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length(varbinary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(binary, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(varbinary, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(binary, text, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(varbinary, text, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(binary, text, uint4, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.weight_string(varbinary, text, uint4, uint4) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.hex(binary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.hex($1::bytea) $$; +CREATE OR REPLACE FUNCTION pg_catalog.hex(varbinary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.hex($1::bytea) $$; + +CREATE OR REPLACE FUNCTION pg_catalog.uncompress(binary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uncompress($1::bytea) $$; +CREATE OR REPLACE FUNCTION pg_catalog.uncompress(varbinary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uncompress($1::bytea) $$; + +CREATE OR REPLACE FUNCTION pg_catalog.uncompressed_length(binary) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uncompressed_length($1::bytea) $$; +CREATE OR REPLACE FUNCTION pg_catalog.uncompressed_length(varbinary) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uncompressed_length($1::bytea) $$; + +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(binary, uint4) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.weight_string($1::bytea, $2) $$; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(varbinary, uint4) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.weight_string($1::bytea, $2) $$; + +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(binary, text, uint4) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.weight_string($1::bytea, $2, $3) $$; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(varbinary, text, uint4) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.weight_string($1::bytea, $2, $3) $$; + +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(binary, text, uint4, uint4) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.weight_string($1::bytea, $2, $3, $4) $$; +CREATE OR REPLACE FUNCTION pg_catalog.weight_string(varbinary, text, uint4, uint4) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.weight_string($1::bytea, $2, $3, $4) $$; + +DROP FUNCTION IF EXISTS pg_catalog.bpcharbinarylike(char, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.bpcharbinarynlike(char, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.namebinarylike(name, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.namebinarynlike(name, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binarylike(binary, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binarynlike(binary, binary) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.bpcharbinarylike( +char, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textbinarylike($1::text, $2) $$; + +CREATE OPERATOR pg_catalog.~~(leftarg = char, rightarg = binary, procedure = pg_catalog.bpcharbinarylike); +CREATE OPERATOR pg_catalog.~~*(leftarg = char, rightarg = binary, procedure = pg_catalog.bpcharbinarylike); + +CREATE OR REPLACE FUNCTION pg_catalog.bpcharbinarynlike( +char, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textbinarynlike($1::text, $2) $$; + +CREATE OPERATOR pg_catalog.!~~(leftarg = char, rightarg = binary, procedure = pg_catalog.bpcharbinarynlike); +CREATE OPERATOR pg_catalog.!~~*(leftarg = char, rightarg = binary, procedure = pg_catalog.bpcharbinarynlike); + +CREATE OR REPLACE FUNCTION pg_catalog.namebinarylike( +name, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textbinarylike($1::text, $2) $$; + +CREATE OPERATOR pg_catalog.~~(leftarg = name, rightarg = binary, procedure = pg_catalog.namebinarylike); +CREATE OPERATOR pg_catalog.~~*(leftarg = name, rightarg = binary, procedure = pg_catalog.namebinarylike); + +CREATE OR REPLACE FUNCTION pg_catalog.namebinarynlike( +name, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textbinarynlike($1::text, $2) $$; + +CREATE OPERATOR pg_catalog.!~~(leftarg = name, rightarg = binary, procedure = pg_catalog.namebinarynlike); +CREATE OPERATOR pg_catalog.!~~*(leftarg = name, rightarg = binary, procedure = pg_catalog.namebinarynlike); + +CREATE OR REPLACE FUNCTION pg_catalog.binarylike( +binary, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.bytealike($1::bytea, $2::bytea) $$; + +CREATE OPERATOR pg_catalog.~~(leftarg = binary, rightarg = binary, procedure = pg_catalog.binarylike); +CREATE OPERATOR pg_catalog.~~*(leftarg = binary, rightarg = binary, procedure = pg_catalog.binarylike); + +CREATE OR REPLACE FUNCTION pg_catalog.binarynlike( +binary, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.byteanlike($1::bytea, $2::bytea) $$; + +CREATE OPERATOR pg_catalog.!~~(leftarg = binary, rightarg = binary, procedure = pg_catalog.binarynlike); +CREATE OPERATOR pg_catalog.!~~*(leftarg = binary, rightarg = binary, procedure = pg_catalog.binarynlike); + +-- lt +DROP FUNCTION IF EXISTS pg_catalog.time_binary_lt(time, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_binary_lt(numeric, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint1_binary_lt(uint1, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint2_binary_lt(uint2, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint4_binary_lt(uint4, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint8_binary_lt(uint8, binary) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.time_binary_lt( +time, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<(leftarg = time, rightarg = binary, procedure = pg_catalog.time_binary_lt); + +CREATE OR REPLACE FUNCTION pg_catalog.numeric_binary_lt( +numeric, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<(leftarg = numeric, rightarg = binary, procedure = pg_catalog.numeric_binary_lt); + +CREATE OR REPLACE FUNCTION pg_catalog.uint1_binary_lt( +uint1, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<(leftarg = uint1, rightarg = binary, procedure = pg_catalog.uint1_binary_lt); + +CREATE OR REPLACE FUNCTION pg_catalog.uint2_binary_lt( +uint2, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<(leftarg = uint2, rightarg = binary, procedure = pg_catalog.uint2_binary_lt); + +CREATE OR REPLACE FUNCTION pg_catalog.uint4_binary_lt( +uint4, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<(leftarg = uint4, rightarg = binary, procedure = pg_catalog.uint4_binary_lt); + +CREATE OR REPLACE FUNCTION pg_catalog.uint8_binary_lt( +uint8, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<(leftarg = uint8, rightarg = binary, procedure = pg_catalog.uint8_binary_lt); + +DROP FUNCTION IF EXISTS pg_catalog.binary_time_lt(binary, time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_numeric_lt(binary, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint1_lt(binary, uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint2_lt(binary, uint2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint4_lt(binary, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint8_lt(binary, uint8) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.binary_time_lt( +binary, +time +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = time, procedure = pg_catalog.binary_time_lt); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_numeric_lt( +binary, +numeric +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = numeric, procedure = pg_catalog.binary_numeric_lt); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint1_lt( +binary, +uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = uint1, procedure = pg_catalog.binary_uint1_lt); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint2_lt( +binary, +uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = uint2, procedure = pg_catalog.binary_uint2_lt); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint4_lt( +binary, +uint4 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = uint4, procedure = pg_catalog.binary_uint4_lt); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint8_lt( +binary, +uint8 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = uint8, procedure = pg_catalog.binary_uint8_lt); + +-- gt +DROP FUNCTION IF EXISTS pg_catalog.time_binary_gt(time, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_binary_gt(numeric, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint1_binary_gt(uint1, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint2_binary_gt(uint2, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint4_binary_gt(uint4, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint8_binary_gt(uint8, binary) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.time_binary_gt( +time, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>(leftarg = time, rightarg = binary, procedure = pg_catalog.time_binary_gt); + +CREATE OR REPLACE FUNCTION pg_catalog.numeric_binary_gt( +numeric, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>(leftarg = numeric, rightarg = binary, procedure = pg_catalog.numeric_binary_gt); + +CREATE OR REPLACE FUNCTION pg_catalog.uint1_binary_gt( +uint1, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>(leftarg = uint1, rightarg = binary, procedure = pg_catalog.uint1_binary_gt); + +CREATE OR REPLACE FUNCTION pg_catalog.uint2_binary_gt( +uint2, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>(leftarg = uint2, rightarg = binary, procedure = pg_catalog.uint2_binary_gt); + +CREATE OR REPLACE FUNCTION pg_catalog.uint4_binary_gt( +uint4, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>(leftarg = uint4, rightarg = binary, procedure = pg_catalog.uint4_binary_gt); + +CREATE OR REPLACE FUNCTION pg_catalog.uint8_binary_gt( +uint8, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>(leftarg = uint8, rightarg = binary, procedure = pg_catalog.uint8_binary_gt); + +DROP FUNCTION IF EXISTS pg_catalog.binary_time_gt(binary, time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_numeric_gt(binary, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint1_gt(binary, uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint2_gt(binary, uint2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint4_gt(binary, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint8_gt(binary, uint8) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.binary_time_gt( +binary, +time +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = time, procedure = pg_catalog.binary_time_gt); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_numeric_gt( +binary, +numeric +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = numeric, procedure = pg_catalog.binary_numeric_gt); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint1_gt( +binary, +uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = uint1, procedure = pg_catalog.binary_uint1_gt); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint2_gt( +binary, +uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = uint2, procedure = pg_catalog.binary_uint2_gt); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint4_gt( +binary, +uint4 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = uint4, procedure = pg_catalog.binary_uint4_gt); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint8_gt( +binary, +uint8 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = uint8, procedure = pg_catalog.binary_uint8_gt); + +-- le +DROP FUNCTION IF EXISTS pg_catalog.time_binary_le(time, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_binary_le(numeric, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint1_binary_le(uint1, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint2_binary_le(uint2, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint4_binary_le(uint4, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint8_binary_le(uint8, binary) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.time_binary_le( +time, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<=(leftarg = time, rightarg = binary, procedure = pg_catalog.time_binary_le); + +CREATE OR REPLACE FUNCTION pg_catalog.numeric_binary_le( +numeric, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<=(leftarg = numeric, rightarg = binary, procedure = pg_catalog.numeric_binary_le); + +CREATE OR REPLACE FUNCTION pg_catalog.uint1_binary_le( +uint1, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<=(leftarg = uint1, rightarg = binary, procedure = pg_catalog.uint1_binary_le); + +CREATE OR REPLACE FUNCTION pg_catalog.uint2_binary_le( +uint2, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<=(leftarg = uint2, rightarg = binary, procedure = pg_catalog.uint2_binary_le); + +CREATE OR REPLACE FUNCTION pg_catalog.uint4_binary_le( +uint4, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<=(leftarg = uint4, rightarg = binary, procedure = pg_catalog.uint4_binary_le); + +CREATE OR REPLACE FUNCTION pg_catalog.uint8_binary_le( +uint8, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<=(leftarg = uint8, rightarg = binary, procedure = pg_catalog.uint8_binary_le); + +DROP FUNCTION IF EXISTS pg_catalog.binary_time_le(binary, time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_numeric_le(binary, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint1_le(binary, uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint2_le(binary, uint2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint4_le(binary, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint8_le(binary, uint8) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.binary_time_le( +binary, +time +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = time, procedure = pg_catalog.binary_time_le); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_numeric_le( +binary, +numeric +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = numeric, procedure = pg_catalog.binary_numeric_le); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint1_le( +binary, +uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = uint1, procedure = pg_catalog.binary_uint1_le); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint2_le( +binary, +uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = uint2, procedure = pg_catalog.binary_uint2_le); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint4_le( +binary, +uint4 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = uint4, procedure = pg_catalog.binary_uint4_le); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint8_le( +binary, +uint8 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = uint8, procedure = pg_catalog.binary_uint8_le); + +-- ge +DROP FUNCTION IF EXISTS pg_catalog.time_binary_ge(time, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.numeric_binary_ge(numeric, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint1_binary_ge(uint1, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint2_binary_ge(uint2, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint4_binary_ge(uint4, binary) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.uint8_binary_ge(uint8, binary) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.time_binary_ge( +time, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>=(leftarg = time, rightarg = binary, procedure = pg_catalog.time_binary_ge); + +CREATE OR REPLACE FUNCTION pg_catalog.numeric_binary_ge( +numeric, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>=(leftarg = numeric, rightarg = binary, procedure = pg_catalog.numeric_binary_ge); + +CREATE OR REPLACE FUNCTION pg_catalog.uint1_binary_ge( +uint1, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>=(leftarg = uint1, rightarg = binary, procedure = pg_catalog.uint1_binary_ge); + +CREATE OR REPLACE FUNCTION pg_catalog.uint2_binary_ge( +uint2, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>=(leftarg = uint2, rightarg = binary, procedure = pg_catalog.uint2_binary_ge); + +CREATE OR REPLACE FUNCTION pg_catalog.uint4_binary_ge( +uint4, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>=(leftarg = uint4, rightarg = binary, procedure = pg_catalog.uint4_binary_ge); + +CREATE OR REPLACE FUNCTION pg_catalog.uint8_binary_ge( +uint8, +binary +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>=(leftarg = uint8, rightarg = binary, procedure = pg_catalog.uint8_binary_ge); + +DROP FUNCTION IF EXISTS pg_catalog.binary_time_ge(binary, time) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_numeric_ge(binary, numeric) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint1_ge(binary, uint1) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint2_ge(binary, uint2) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint4_ge(binary, uint4) CASCADE; +DROP FUNCTION IF EXISTS pg_catalog.binary_uint8_ge(binary, uint8) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.binary_time_ge( +binary, +time +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = time, procedure = pg_catalog.binary_time_ge); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_numeric_ge( +binary, +numeric +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = numeric, procedure = pg_catalog.binary_numeric_ge); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint1_ge( +binary, +uint1 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = uint1, procedure = pg_catalog.binary_uint1_ge); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint2_ge( +binary, +uint2 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = uint2, procedure = pg_catalog.binary_uint2_ge); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint4_ge( +binary, +uint4 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = uint4, procedure = pg_catalog.binary_uint4_ge); + +CREATE OR REPLACE FUNCTION pg_catalog.binary_uint8_ge( +binary, +uint8 +) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$; +CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = uint8, procedure = pg_catalog.binary_uint8_ge); +-- uint explicit cast +-- time +DROP FUNCTION IF EXISTS pg_catalog.time_cast_ui1(time) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.time_cast_ui1 ( +time +) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_cast_ui1'; + +DROP FUNCTION IF EXISTS pg_catalog.time_cast_ui2(time) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.time_cast_ui2 ( +time +) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_cast_ui2'; + +DROP FUNCTION IF EXISTS pg_catalog.time_cast_ui4(time) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.time_cast_ui4 ( +time +) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_cast_ui4'; + +DROP FUNCTION IF EXISTS pg_catalog.time_cast_ui8(time) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.time_cast_ui8 ( +time +) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_cast_ui8'; +-- char +DROP FUNCTION IF EXISTS pg_catalog.char_cast_ui1(char) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.char_cast_ui1 ( +char +) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'char_cast_ui1'; + +DROP FUNCTION IF EXISTS pg_catalog.char_cast_ui2(char) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.char_cast_ui2 ( +char +) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'char_cast_ui2'; + +DROP FUNCTION IF EXISTS pg_catalog.char_cast_ui4(char) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.char_cast_ui4 ( +char +) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'char_cast_ui4'; + +DROP FUNCTION IF EXISTS pg_catalog.char_cast_ui8(char) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.char_cast_ui8 ( +char +) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'char_cast_ui8'; +-- varchar +DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_ui1(char) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.varchar_cast_ui1 ( +char +) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varchar_cast_ui1'; + +DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_ui2(char) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.varchar_cast_ui2 ( +char +) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varchar_cast_ui2'; + +DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_ui4(char) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.varchar_cast_ui4 ( +char +) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varchar_cast_ui4'; + +DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_ui8(char) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.varchar_cast_ui8 ( +char +) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varchar_cast_ui8'; +--varlena +DROP FUNCTION IF EXISTS pg_catalog.varlena2ui1(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2ui2(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2ui4(anyelement) cascade; +DROP FUNCTION IF EXISTS pg_catalog.varlena2ui8(anyelement) cascade; + +DROP CAST IF EXISTS ("binary" AS uint1) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS uint1) CASCADE; +DROP CAST IF EXISTS (blob AS uint1) CASCADE; +DROP CAST IF EXISTS (tinyblob AS uint1) CASCADE; +DROP CAST IF EXISTS (mediumblob AS uint1) CASCADE; +DROP CAST IF EXISTS (longblob AS uint1) CASCADE; +DROP CAST IF EXISTS (json AS uint1) CASCADE; +DROP CAST IF EXISTS ("binary" AS uint2) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS uint2) CASCADE; +DROP CAST IF EXISTS (blob AS uint2) CASCADE; +DROP CAST IF EXISTS (tinyblob AS uint2) CASCADE; +DROP CAST IF EXISTS (mediumblob AS uint2) CASCADE; +DROP CAST IF EXISTS (longblob AS uint2) CASCADE; +DROP CAST IF EXISTS (json AS uint2) CASCADE; +DROP CAST IF EXISTS ("binary" AS uint4) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS uint4) CASCADE; +DROP CAST IF EXISTS (blob AS uint4) CASCADE; +DROP CAST IF EXISTS (tinyblob AS uint4) CASCADE; +DROP CAST IF EXISTS (mediumblob AS uint4) CASCADE; +DROP CAST IF EXISTS (longblob AS uint4) CASCADE; +DROP CAST IF EXISTS (json AS uint4) CASCADE; +DROP CAST IF EXISTS ("binary" AS uint8) CASCADE; +DROP CAST IF EXISTS ("varbinary" AS uint8) CASCADE; +DROP CAST IF EXISTS (blob AS uint8) CASCADE; +DROP CAST IF EXISTS (tinyblob AS uint8) CASCADE; +DROP CAST IF EXISTS (mediumblob AS uint8) CASCADE; +DROP CAST IF EXISTS (longblob AS uint8) CASCADE; +DROP CAST IF EXISTS (json AS uint8) CASCADE; + +CREATE OR REPLACE FUNCTION pg_catalog.varlena2ui1 ( +anyelement +) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena2ui1'; + +CREATE OR REPLACE FUNCTION pg_catalog.varlena2ui2 ( +anyelement +) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena2ui2'; + +CREATE OR REPLACE FUNCTION pg_catalog.varlena2ui4 ( +anyelement +) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena2ui4'; + +CREATE OR REPLACE FUNCTION pg_catalog.varlena2ui8 ( +anyelement +) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena2ui8'; + +CREATE CAST ("binary" AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT; + +CREATE CAST ("binary" AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT; + +CREATE CAST ("binary" AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT; + +CREATE CAST ("binary" AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT; +CREATE CAST ("varbinary" AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT; +CREATE CAST (blob AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT; +CREATE CAST (tinyblob AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT; +CREATE CAST (mediumblob AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT; +CREATE CAST (longblob AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT; +CREATE CAST (json AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_ui1(anyelement) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_ui1 ( +anyelement +) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena_cast_ui1'; + +DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_ui2(anyelement) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_ui2 ( +anyelement +) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena_cast_ui2'; + +DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_ui4(anyelement) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_ui4 ( +anyelement +) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena_cast_ui4'; + +DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_ui8(anyelement) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_ui8 ( +anyelement +) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena_cast_ui8'; + + +DROP FUNCTION IF EXISTS pg_catalog.time_format(timestamp without time zone, text) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.time_format (timestamp without time zone, text) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.time_format($1::text, $2) $$; + +DROP FUNCTION IF EXISTS pg_catalog.timestamp_add (text, timestamptz, "any") CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.timestamp_add (text, timestamptz, "any") RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_add_timestamptz'; + +create function pg_catalog.timestamp_pl_int4( + timestamptz, + int4 +) RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.timestamptz_pl_interval($1, $2::interval) $$; +create operator pg_catalog.+(leftarg = timestamptz, rightarg = int4, procedure = pg_catalog.timestamp_pl_int4); + +create function pg_catalog.timestamp_mi_int4( + timestamptz, + int4 +) RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.timestamptz_mi_interval($1, $2::interval) $$; +create operator pg_catalog.-(leftarg = timestamptz, rightarg = int4, procedure = pg_catalog.timestamp_mi_int4); + +create function pg_catalog.datetime_pl_int4( + timestamp without time zone, + int4 +) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.datetime_pl_float($1, $2::float8) $$; +create operator pg_catalog.+(leftarg = timestamp without time zone, rightarg = int4, procedure = pg_catalog.datetime_pl_int4); + +create function pg_catalog.datetime_mi_int4( + timestamp without time zone, + int4 +) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.datetime_mi_float($1, $2::float8) $$; +create operator pg_catalog.-(leftarg = timestamp without time zone, rightarg = int4, procedure = pg_catalog.datetime_mi_int4); + +DROP FUNCTION IF EXISTS pg_catalog.bit_cast_int8(bit) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bit_cast_int8 ( +bit +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bit_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.float4_cast_int8(float4) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.float4_cast_int8 ( +float4 +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float4_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.float8_cast_int8(float8) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.float8_cast_int8 ( +float8 +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float8_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.numeric_cast_int8(numeric) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.numeric_cast_int8 ( +numeric +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'numeric_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.date_cast_int8(date) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.date_cast_int8 ( +date +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.timestamp_cast_int8(timestamp without time zone) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.timestamp_cast_int8 ( +timestamp without time zone +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamp_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.timestamptz_cast_int8(timestamptz) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_cast_int8 ( +timestamptz +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptz_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.time_cast_int8(time) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.time_cast_int8 ( +time +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.timetz_cast_int8(timetz) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.timetz_cast_int8 ( +timetz +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timetz_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.set_cast_int8(anyset) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.set_cast_int8 ( +anyset +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'set_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.uint8_cast_int8(uint8) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.uint8_cast_int8 ( +uint8 +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint8_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.year_cast_int8(year) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.year_cast_int8 ( +year +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.bpchar_cast_int8(char) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.bpchar_cast_int8 ( +char +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bpchar_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_int8(varchar) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.varchar_cast_int8 ( +varchar +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varchar_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.text_cast_int8(text) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.text_cast_int8 ( +text +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_cast_int8'; + +DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_int8(anyelement) CASCADE; +CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_int8 ( +anyelement +) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena_cast_int8'; + +-- left operator +DROP FUNCTION IF EXISTS pg_catalog.json_uplus(json); +CREATE OR REPLACE FUNCTION pg_catalog.json_uplus(json) RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_uplus'; +CREATE OPERATOR pg_catalog.+(rightarg = json, procedure = pg_catalog.json_uplus); + +-- binary cmp operator +DROP FUNCTION IF EXISTS pg_catalog.json_eq(json, "any"); +CREATE OR REPLACE FUNCTION pg_catalog.json_eq(json, "any") RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_eq'; +CREATE OPERATOR pg_catalog.=(leftarg = json, rightarg = "any", procedure = pg_catalog.json_eq); +DROP FUNCTION IF EXISTS pg_catalog.json_eq(text, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_eq(text, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_eq'; +CREATE OPERATOR pg_catalog.=(leftarg = text, rightarg = json, procedure = pg_catalog.json_eq); +DROP FUNCTION IF EXISTS pg_catalog.json_eq(bit, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_eq(bit, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_eq'; +CREATE OPERATOR pg_catalog.=(leftarg = bit, rightarg = json, procedure = pg_catalog.json_eq); +DROP FUNCTION IF EXISTS pg_catalog.json_eq(boolean, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_eq(boolean, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_eq'; +CREATE OPERATOR pg_catalog.=(leftarg = boolean, rightarg = json, procedure = pg_catalog.json_eq); +DROP FUNCTION IF EXISTS pg_catalog.json_eq(year, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_eq(year, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_eq'; +CREATE OPERATOR pg_catalog.=(leftarg = year, rightarg = json, procedure = pg_catalog.json_eq); + +DROP FUNCTION IF EXISTS pg_catalog.json_ne(json, "any"); +CREATE OR REPLACE FUNCTION pg_catalog.json_ne(json, "any") RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ne'; +CREATE OPERATOR pg_catalog.!=(leftarg = json, rightarg = "any", procedure = pg_catalog.json_ne); +DROP FUNCTION IF EXISTS pg_catalog.json_ne(text, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_ne(text, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ne'; +CREATE OPERATOR pg_catalog.!=(leftarg = text, rightarg = json, procedure = pg_catalog.json_ne); +DROP FUNCTION IF EXISTS pg_catalog.json_ne(bit, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_ne(bit, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ne'; +CREATE OPERATOR pg_catalog.!=(leftarg = bit, rightarg = json, procedure = pg_catalog.json_ne); +DROP FUNCTION IF EXISTS pg_catalog.json_ne(boolean, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_ne(boolean, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ne'; +CREATE OPERATOR pg_catalog.!=(leftarg = boolean, rightarg = json, procedure = pg_catalog.json_ne); +DROP FUNCTION IF EXISTS pg_catalog.json_ne(year, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_ne(year, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ne'; +CREATE OPERATOR pg_catalog.!=(leftarg = year, rightarg = json, procedure = pg_catalog.json_ne); + +DROP FUNCTION IF EXISTS pg_catalog.json_gt(json, "any"); +CREATE OR REPLACE FUNCTION pg_catalog.json_gt(json, "any") RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_gt'; +CREATE OPERATOR pg_catalog.>(leftarg = json, rightarg = "any", procedure = pg_catalog.json_gt); +DROP FUNCTION IF EXISTS pg_catalog.json_gt(text, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_gt(text, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_gt'; +CREATE OPERATOR pg_catalog.>(leftarg = text, rightarg = json, procedure = pg_catalog.json_gt); +DROP FUNCTION IF EXISTS pg_catalog.json_gt(bit, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_gt(bit, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_gt'; +CREATE OPERATOR pg_catalog.>(leftarg = bit, rightarg = json, procedure = pg_catalog.json_gt); +DROP FUNCTION IF EXISTS pg_catalog.json_gt(boolean, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_gt(boolean, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_gt'; +CREATE OPERATOR pg_catalog.>(leftarg = boolean, rightarg = json, procedure = pg_catalog.json_gt); +DROP FUNCTION IF EXISTS pg_catalog.json_gt(year, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_gt(year, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_gt'; +CREATE OPERATOR pg_catalog.>(leftarg = year, rightarg = json, procedure = pg_catalog.json_gt); + +DROP FUNCTION IF EXISTS pg_catalog.json_ge(json, "any"); +CREATE OR REPLACE FUNCTION pg_catalog.json_ge(json, "any") RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ge'; +CREATE OPERATOR pg_catalog.>=(leftarg = json, rightarg = "any", procedure = pg_catalog.json_ge); +DROP FUNCTION IF EXISTS pg_catalog.json_ge(text, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_ge(text, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ge'; +CREATE OPERATOR pg_catalog.>=(leftarg = text, rightarg = json, procedure = pg_catalog.json_ge); +DROP FUNCTION IF EXISTS pg_catalog.json_ge(bit, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_ge(bit, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ge'; +CREATE OPERATOR pg_catalog.>=(leftarg = bit, rightarg = json, procedure = pg_catalog.json_ge); +DROP FUNCTION IF EXISTS pg_catalog.json_ge(boolean, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_ge(boolean, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ge'; +CREATE OPERATOR pg_catalog.>=(leftarg = boolean, rightarg = json, procedure = pg_catalog.json_ge); +DROP FUNCTION IF EXISTS pg_catalog.json_ge(year, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_ge(year, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ge'; +CREATE OPERATOR pg_catalog.>=(leftarg = year, rightarg = json, procedure = pg_catalog.json_ge); + +DROP FUNCTION IF EXISTS pg_catalog.json_lt(json, "any"); +CREATE OR REPLACE FUNCTION pg_catalog.json_lt(json, "any") RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_lt'; +CREATE OPERATOR pg_catalog.<(leftarg = json, rightarg = "any", procedure = pg_catalog.json_lt); +DROP FUNCTION IF EXISTS pg_catalog.json_lt(text, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_lt(text, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_lt'; +CREATE OPERATOR pg_catalog.<(leftarg = text, rightarg = json, procedure = pg_catalog.json_lt); +DROP FUNCTION IF EXISTS pg_catalog.json_lt(bit, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_lt(bit, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_lt'; +CREATE OPERATOR pg_catalog.<(leftarg = bit, rightarg = json, procedure = pg_catalog.json_lt); +DROP FUNCTION IF EXISTS pg_catalog.json_lt(boolean, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_lt(boolean, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_lt'; +CREATE OPERATOR pg_catalog.<(leftarg = boolean, rightarg = json, procedure = pg_catalog.json_lt); +DROP FUNCTION IF EXISTS pg_catalog.json_lt(year, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_lt(year, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_lt'; +CREATE OPERATOR pg_catalog.<(leftarg = year, rightarg = json, procedure = pg_catalog.json_lt); + +DROP FUNCTION IF EXISTS pg_catalog.json_le(json, "any"); +CREATE OR REPLACE FUNCTION pg_catalog.json_le(json, "any") RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_le'; +CREATE OPERATOR pg_catalog.<=(leftarg = json, rightarg = "any", procedure = pg_catalog.json_le); +DROP FUNCTION IF EXISTS pg_catalog.json_le(text, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_le(text, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_le'; +CREATE OPERATOR pg_catalog.<=(leftarg = text, rightarg = json, procedure = pg_catalog.json_le); +DROP FUNCTION IF EXISTS pg_catalog.json_le(bit, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_le(bit, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_le'; +CREATE OPERATOR pg_catalog.<=(leftarg = bit, rightarg = json, procedure = pg_catalog.json_le); +DROP FUNCTION IF EXISTS pg_catalog.json_le(boolean, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_le(boolean, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_le'; +CREATE OPERATOR pg_catalog.<=(leftarg = boolean, rightarg = json, procedure = pg_catalog.json_le); +DROP FUNCTION IF EXISTS pg_catalog.json_le(year, json); +CREATE OR REPLACE FUNCTION pg_catalog.json_le(year, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_le'; +CREATE OPERATOR pg_catalog.<=(leftarg = year, rightarg = json, procedure = pg_catalog.json_le); + +DROP FUNCTION IF EXISTS pg_catalog.b_mod(json, anyelement); +CREATE OR REPLACE FUNCTION pg_catalog.b_mod(json, anyelement) +returns numeric +as +$$ +begin + return $1::double % $2::double; +end; +$$ +language plpgsql; + +DROP FUNCTION IF EXISTS pg_catalog.b_mod(anyelement, json); +CREATE OR REPLACE FUNCTION pg_catalog.b_mod(anyelement, json) +returns numeric +as +$$ +begin + return $1::double % $2::double; +end; +$$ +language plpgsql; + +DROP FUNCTION IF EXISTS pg_catalog.b_mod(json, json); +CREATE OR REPLACE FUNCTION pg_catalog.b_mod(json, json) +returns numeric +as +$$ +begin + return $1::double % $2::double; +end; +$$ +language plpgsql; + +DROP FUNCTION IF EXISTS pg_catalog.div(json, anyelement); +CREATE OR REPLACE FUNCTION pg_catalog.div(json, anyelement) +returns numeric +as +$$ +begin + return $1::double / $2::double; +end; +$$ +language plpgsql; + +DROP FUNCTION IF EXISTS pg_catalog.div(anyelement, json); +CREATE OR REPLACE FUNCTION pg_catalog.div(anyelement, json) +returns numeric +as +$$ +begin + return $1::double / $2::double; +end; +$$ +language plpgsql; + +DROP FUNCTION IF EXISTS pg_catalog.div(json, json); +CREATE OR REPLACE FUNCTION pg_catalog.div(json, json) +returns numeric +as +$$ +begin + return $1::double / $2::double; +end; +$$ +language plpgsql; + +DROP FUNCTION IF EXISTS pg_catalog.xor(a json, b anyelement); +CREATE OR REPLACE FUNCTION pg_catalog.xor(a json, b anyelement) +returns integer +as +$$ +begin + return (select a ^ b); +end; +$$ +language plpgsql; + +DROP FUNCTION IF EXISTS pg_catalog.xor(a anyelement, b json); +CREATE OR REPLACE FUNCTION pg_catalog.xor(a anyelement, b json) +returns integer +as +$$ +begin + return (select a ^ b); +end; +$$ +language plpgsql; + +DROP FUNCTION IF EXISTS pg_catalog.xor(a json, b json); +CREATE OR REPLACE FUNCTION pg_catalog.xor(a json, b json) +returns integer +as +$$ +begin + return (select a ^ b); +end; +$$ +language plpgsql; + +DROP FUNCTION IF EXISTS pg_catalog.a_sysdate(); +CREATE OR REPLACE FUNCTION pg_catalog.a_sysdate() +returns timestamp without time zone LANGUAGE SQL +VOLATILE as $$ SELECT CURRENT_TIMESTAMP::timestamp(0) without time zone$$; + +DROP CAST IF EXISTS (json AS boolean); +DROP FUNCTION IF EXISTS pg_catalog.json_to_bool(json); +CREATE OR REPLACE FUNCTION pg_catalog.json_to_bool(json) +RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT as +'select cast(cast($1 as text) as boolean)'; +CREATE CAST (json AS boolean) WITH FUNCTION json_to_bool(json) AS ASSIGNMENT; + +DROP FUNCTION IF EXISTS pg_catalog.hex(int8); +DROP FUNCTION IF EXISTS pg_catalog.hex(int16); +CREATE OR REPLACE FUNCTION pg_catalog.hex(int16) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int_to_hex'; + +DROP FUNCTION IF EXISTS pg_catalog.bit_bin_in(cstring, oid, integer); +CREATE OR REPLACE FUNCTION pg_catalog.bit_bin_in(cstring, oid, integer) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','bit_bin_in'; + +DROP FUNCTION IF EXISTS pg_catalog.b_mod(a numeric, b numeric); +CREATE OR REPLACE FUNCTION pg_catalog.b_mod(a numeric, b numeric) returns numeric LANGUAGE SQL IMMUTABLE STRICT as 'select a % b'; + -- Gitee