DROP OPERATOR CLASS IF EXISTS pg_catalog.enumtext_ops USING hash; DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_cast_int8(nvarchar2); DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_enum(nvarchar2, int4, anyelement); DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_cast_ui8(nvarchar2); DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_cast_ui4(nvarchar2); DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_cast_ui2(nvarchar2); DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_cast_ui1(nvarchar2); DROP CAST IF EXISTS (boolean as time without time zone); DROP CAST IF EXISTS (boolean as date); DROP CAST IF EXISTS (boolean as timestamp without time zone); DROP CAST IF EXISTS (boolean as timestamptz); DROP FUNCTION IF EXISTS pg_catalog.boolean_time(boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_date(boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_datetime(boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_timestamptz(boolean); DROP FUNCTION IF EXISTS pg_catalog.bool_cast_time(boolean); DROP FUNCTION IF EXISTS pg_catalog.bool_cast_date(boolean); DROP FUNCTION IF EXISTS pg_catalog.bool_cast_datetime(boolean); DROP FUNCTION IF EXISTS pg_catalog.bool_cast_timestamptz(boolean); DROP FUNCTION IF EXISTS pg_catalog.int8_cast_time(int1); DROP FUNCTION IF EXISTS pg_catalog.int16_cast_time(int2); DROP FUNCTION IF EXISTS pg_catalog.int32_cast_time(int4); DROP FUNCTION IF EXISTS pg_catalog.int64_cast_time(int8); DROP FUNCTION IF EXISTS pg_catalog.uint8_cast_time(uint1); DROP FUNCTION IF EXISTS pg_catalog.uint16_cast_time(uint2); DROP FUNCTION IF EXISTS pg_catalog.uint32_cast_time(uint4); DROP FUNCTION IF EXISTS pg_catalog.uint64_cast_time(uint8); DROP FUNCTION IF EXISTS pg_catalog.float4_cast_time(float4); DROP FUNCTION IF EXISTS pg_catalog.float8_cast_time(float8); DROP FUNCTION IF EXISTS pg_catalog.numeric_cast_time(numeric); DROP FUNCTION IF EXISTS pg_catalog.bit_cast_time(bit); DROP FUNCTION IF EXISTS pg_catalog.bit_cast_timestamp(bit); DROP FUNCTION IF EXISTS pg_catalog.bit_cast_datetime(bit); DROP FUNCTION IF EXISTS pg_catalog.bit_cast_date(bit); 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.date_cast(cstring, boolean); DROP FUNCTION IF EXISTS pg_catalog.timestamp_cast(cstring, oid, integer, boolean); DROP FUNCTION IF EXISTS pg_catalog.timestamptz_cast(cstring, oid, integer, boolean); DROP FUNCTION IF EXISTS pg_catalog.time_cast(cstring, boolean); DROP CAST IF EXISTS (TEXT AS time); DROP FUNCTION IF EXISTS pg_catalog.time_cast_implicit(TEXT); DROP FUNCTION IF EXISTS pg_catalog.text_time_explicit(TEXT); DROP FUNCTION IF EXISTS pg_catalog.day(time without time zone); DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(json); DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(anyenum); DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(anyset); DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(bit); DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(longblob); DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(year); DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(date); DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(timestamp with time zone); DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(numeric); DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(int8); DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(text); CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(text) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'time_to_sec'; CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(date) RETURNS int4 AS $$ SELECT pg_catalog.time_to_sec(cast('00:00:00' as text)) $$ LANGUAGE SQL; CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(numeric) RETURNS int4 AS $$ SELECT pg_catalog.time_to_sec(cast($1 as text)) $$ LANGUAGE SQL; DROP FUNCTION IF EXISTS pg_catalog.date_cast_timestamptz(date); DROP FUNCTION IF EXISTS pg_catalog.date_cast_datetime(date); DROP OPERATOR IF EXISTS pg_catalog.=(time, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<>(time, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<=(time, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<(time, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.>=(time, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.>(time, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.time_eq_timestamp (time, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.time_ne_timestamp (time, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.time_le_timestamp (time, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.time_lt_timestamp (time, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.time_ge_timestamp (time, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.time_gt_timestamp (time, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.=(timestamp without time zone, time); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamp without time zone, time); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamp without time zone, time); DROP OPERATOR IF EXISTS pg_catalog.<(timestamp without time zone, time); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamp without time zone, time); DROP OPERATOR IF EXISTS pg_catalog.>(timestamp without time zone, time); DROP FUNCTION IF EXISTS pg_catalog.timestamp_eq_time (timestamp without time zone, time); DROP FUNCTION IF EXISTS pg_catalog.timestamp_ne_time (timestamp without time zone, time); DROP FUNCTION IF EXISTS pg_catalog.timestamp_le_time (timestamp without time zone, time); DROP FUNCTION IF EXISTS pg_catalog.timestamp_lt_time (timestamp without time zone, time); DROP FUNCTION IF EXISTS pg_catalog.timestamp_ge_time (timestamp without time zone, time); DROP FUNCTION IF EXISTS pg_catalog.timestamp_gt_time (timestamp without time zone, time); DROP OPERATOR IF EXISTS pg_catalog.=(time, timestamp with time zone); DROP OPERATOR IF EXISTS pg_catalog.<>(time, timestamp with time zone); DROP OPERATOR IF EXISTS pg_catalog.<=(time, timestamp with time zone); DROP OPERATOR IF EXISTS pg_catalog.<(time, timestamp with time zone); DROP OPERATOR IF EXISTS pg_catalog.>=(time, timestamp with time zone); DROP OPERATOR IF EXISTS pg_catalog.>(time, timestamp with time zone); DROP FUNCTION IF EXISTS pg_catalog.time_eq_timestamptz (time, timestamp with time zone); DROP FUNCTION IF EXISTS pg_catalog.time_ne_timestamptz (time, timestamp with time zone); DROP FUNCTION IF EXISTS pg_catalog.time_le_timestamptz (time, timestamp with time zone); DROP FUNCTION IF EXISTS pg_catalog.time_lt_timestamptz (time, timestamp with time zone); DROP FUNCTION IF EXISTS pg_catalog.time_ge_timestamptz (time, timestamp with time zone); DROP FUNCTION IF EXISTS pg_catalog.time_gt_timestamptz (time, timestamp with time zone); DROP OPERATOR IF EXISTS pg_catalog.=(timestamp with time zone, time); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamp with time zone, time); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamp with time zone, time); DROP OPERATOR IF EXISTS pg_catalog.<(timestamp with time zone, time); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamp with time zone, time); DROP OPERATOR IF EXISTS pg_catalog.>(timestamp with time zone, time); DROP FUNCTION IF EXISTS pg_catalog.timestamptz_eq_time (timestamp with time zone, time); DROP FUNCTION IF EXISTS pg_catalog.timestamptz_ne_time (timestamp with time zone, time); DROP FUNCTION IF EXISTS pg_catalog.timestamptz_le_time (timestamp with time zone, time); DROP FUNCTION IF EXISTS pg_catalog.timestamptz_lt_time (timestamp with time zone, time); DROP FUNCTION IF EXISTS pg_catalog.timestamptz_ge_time (timestamp with time zone, time); DROP FUNCTION IF EXISTS pg_catalog.timestamptz_gt_time (timestamp with time zone, time); do $$ begin update pg_cast set castcontext='e', castowner=10 where castsource=1560 and casttarget=20 and castcontext='a'; update pg_cast set castcontext='e', castowner=10 where castsource=1560 and casttarget=23 and castcontext='a'; update pg_cast set castcontext='e', castowner=10 where castsource=20 and casttarget=1560 and castcontext='a'; update pg_cast set castcontext='e', castowner=10 where castsource=23 and casttarget=1560 and castcontext='a'; end $$; drop CAST IF EXISTS (uint4 AS bit); drop CAST IF EXISTS (uint8 AS bit); CREATE CAST (uint4 AS bit) WITH FUNCTION bitfromuint4(uint4, int4); CREATE CAST (uint8 AS bit) WITH FUNCTION bitfromuint8(uint8, int4); DROP FUNCTION IF EXISTS pg_catalog.rand(int16); DROP FUNCTION IF EXISTS pg_catalog.rand(uint4); DROP FUNCTION IF EXISTS pg_catalog.rand(timestamp with time zone); DROP FUNCTION IF EXISTS pg_catalog.rand(date); DROP FUNCTION IF EXISTS pg_catalog.rand(year); DROP FUNCTION IF EXISTS pg_catalog.rand(binary); DROP FUNCTION IF EXISTS pg_catalog.rand(blob); DROP FUNCTION IF EXISTS pg_catalog.rand(anyenum); DROP FUNCTION IF EXISTS pg_catalog.rand(anyset); DROP FUNCTION IF EXISTS pg_catalog.rand(json); DROP FUNCTION IF EXISTS pg_catalog.random_bytes(int4); DROP FUNCTION IF EXISTS pg_catalog.random_bytes(bit); DROP FUNCTION IF EXISTS pg_catalog.random_bytes(timestamp with time zone); DROP FUNCTION IF EXISTS pg_catalog.random_bytes(date); DROP FUNCTION IF EXISTS pg_catalog.random_bytes(year); DROP FUNCTION IF EXISTS pg_catalog.random_bytes(binary); DROP FUNCTION IF EXISTS pg_catalog.random_bytes(blob); DROP FUNCTION IF EXISTS pg_catalog.random_bytes(anyenum); DROP FUNCTION IF EXISTS pg_catalog.random_bytes(anyset); DROP FUNCTION IF EXISTS pg_catalog.random_bytes(json); CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_rawout ( tinyblob ) RETURNS cstring LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteaout'; CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_rawout ( mediumblob ) RETURNS cstring LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteaout'; CREATE OR REPLACE FUNCTION pg_catalog.longblob_rawout ( longblob ) RETURNS cstring LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteaout'; -- Make the result of oct(bit) and conv(bit) identical to Mysql DROP FUNCTION IF EXISTS pg_catalog.conv(bit, int4, int4) CASCADE; 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.dayofmonth(text); DROP FUNCTION IF EXISTS pg_catalog.dayofmonth(numeric); drop function if EXISTS pg_catalog.length(binary); drop function if EXISTS pg_catalog.length(varbinary); drop CAST IF EXISTS (timestamptz as boolean); drop CAST IF EXISTS (timestamp(0) without time zone as boolean); DROP FUNCTION IF EXISTS pg_catalog.timestamptz_bool(timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_bool(timestamp(0) without time zone); DROP FUNCTION IF EXISTS pg_catalog.date_format (time without time zone, text); DROP FUNCTION IF EXISTS pg_catalog.to_char(time without time zone, text); drop function IF EXISTS pg_catalog."user"(); DROP OPERATOR IF EXISTS pg_catalog.>(timestamp without time zone, double precision); drop function if exists pg_catalog.datetime_double_gt(timestamp without time zone, double precision); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamp without time zone, double precision); drop function if exists pg_catalog.datetime_double_ge(timestamp without time zone, double precision); DROP OPERATOR IF EXISTS pg_catalog.<(timestamp without time zone, double precision); drop function if exists pg_catalog.datetime_double_lt(timestamp without time zone, double precision); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamp without time zone, double precision); drop function if exists pg_catalog.datetime_double_le(timestamp without time zone, double precision); DROP OPERATOR IF EXISTS pg_catalog.=(timestamp without time zone, double precision); drop function if exists pg_catalog.datetime_double_eq(timestamp without time zone, double precision); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamp without time zone, double precision); drop function if exists pg_catalog.datetime_double_ne(timestamp without time zone, double precision); DROP OPERATOR IF EXISTS pg_catalog.>(timestamptz, double precision); drop function if exists pg_catalog.timestamp_double_gt(timestamptz, double precision); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamp, double); drop function if exists pg_catalog.timestamp_double_ge(timestamptz, double precision); DROP OPERATOR IF EXISTS pg_catalog.<(timestamp, double); drop function if exists pg_catalog.timestamp_double_lt(timestamptz, double precision); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamp, double); drop function if exists pg_catalog.timestamp_double_le(timestamptz, double precision); DROP OPERATOR IF EXISTS pg_catalog.=(timestamp, double); drop function if exists pg_catalog.timestamp_double_eq(timestamptz, double precision); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamp, double); drop function if exists pg_catalog.timestamp_double_ne(timestamptz, double precision); DROP OPERATOR IF EXISTS pg_catalog.>(timestamp without time zone, uint8); drop function if exists pg_catalog.datetime_uint8_gt(timestamp without time zone, uint8); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamp without time zone, uint8); drop function if exists pg_catalog.datetime_uint8_ge(timestamp without time zone, uint8); DROP OPERATOR IF EXISTS pg_catalog.<(timestamp without time zone, uint8); drop function if exists pg_catalog.datetime_uint8_lt(timestamp without time zone, uint8); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamp without time zone, uint8); drop function if exists pg_catalog.datetime_uint8_le(timestamp without time zone, uint8); DROP OPERATOR IF EXISTS pg_catalog.=(timestamp without time zone, uint8); drop function if exists pg_catalog.datetime_uint8_eq(timestamp without time zone, uint8); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamp without time zone, uint8); drop function if exists pg_catalog.datetime_uint8_ne(timestamp without time zone, uint8); DROP OPERATOR IF EXISTS pg_catalog.>(timestamptz, uint8); drop function if exists pg_catalog.timestamp_uint8_gt(timestamptz, uint8); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamptz, uint8); drop function if exists pg_catalog.timestamp_uint8_ge(timestamptz, uint8); DROP OPERATOR IF EXISTS pg_catalog.<(timestamptz, uint8); drop function if exists pg_catalog.timestamp_uint8_lt(timestamptz, uint8); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamptz, uint8); drop function if exists pg_catalog.timestamp_uint8_le(timestamptz, uint8); DROP OPERATOR IF EXISTS pg_catalog.=(timestamptz, uint8); drop function if exists pg_catalog.timestamp_uint8_eq(timestamptz, uint8); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamptz, uint8); drop function if exists pg_catalog.timestamp_uint8_ne(timestamptz, uint8); drop function if exists pg_catalog.convert_datetime_double(double precision); drop function if exists pg_catalog.convert_timestamptz_double(double precision); drop function if exists pg_catalog.convert_datetime_uint8(uint8); drop function if exists pg_catalog.convert_timestamptz_uint8(uint8); DROP FUNCTION IF EXISTS pg_catalog.hex(tinyblob); DROP FUNCTION IF EXISTS pg_catalog.hex(blob); DROP FUNCTION IF EXISTS pg_catalog.hex(mediumblob); DROP FUNCTION IF EXISTS pg_catalog.hex(longblob); CREATE OR REPLACE FUNCTION pg_catalog.binary_out (binary) RETURNS cstring LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteaout'; CREATE OR REPLACE FUNCTION pg_catalog.varbinary_out (varbinary) RETURNS cstring LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteaout'; DROP OPERATOR IF EXISTS pg_catalog.|(double precision, binary) CASCADE; DROP OPERATOR IF EXISTS pg_catalog.|(binary, double precision) CASCADE; DROP OPERATOR IF EXISTS pg_catalog.|(uint8, binary) CASCADE; DROP OPERATOR IF EXISTS pg_catalog.|(binary, uint8) CASCADE; DROP OPERATOR IF EXISTS pg_catalog.|(binary, binary) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.double_or_binary(double precision, binary) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.binary_or_double(binary, double precision) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.uint8_or_binary(uint8, binary) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.binary_or_uint8(binary, uint8) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.binary_or_binary(binary, binary) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.div(binary, double precision); DROP FUNCTION IF EXISTS pg_catalog.div(double precision, binary); DROP FUNCTION IF EXISTS pg_catalog.div(binary, binary); DROP CAST IF EXISTS (year AS boolean); DROP FUNCTION IF EXISTS pg_catalog.year_to_bool(year); -- not operator DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, int1); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_int1not(int1); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, int2); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_int2not(int2); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, int4); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_int4not(int4); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, int8); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_int8not(int8); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, uint1); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_uint1not(uint1); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, uint2); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_uint2not(uint2); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, uint4); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_uint4not(uint4); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, uint8); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_uint8not(uint8); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, float4); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_float4not(float4); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, float8); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_float8not(float8); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, numeric); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_numericnot(numeric); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, bit); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_bitnot(bit); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, boolean); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_boolnot(boolean); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, date); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_datenot(date); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, time); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_timenot(time); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, timestamp without time zone); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_timestampnot(timestamp without time zone); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, timestamp with time zone); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_timestamptznot(timestamp with time zone); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, year); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_yearnot(year); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, char); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_charnot(char); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, varchar); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_varcharnot(varchar); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, text); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_textnot(text); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, anyelement); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_varlenanot(anyelement); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, anyenum); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_enumnot(anyenum); DROP OPERATOR IF EXISTS dolphin_catalog.~(NONE, anyset); DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_setnot(anyset); DROP FUNCTION IF EXISTS pg_catalog.convert(boolean, name); DROP FUNCTION IF EXISTS pg_catalog.convert(longblob, name); DROP FUNCTION IF EXISTS pg_catalog.convert(anyenum, name); DROP FUNCTION IF EXISTS pg_catalog.convert(json, name); DROP OPERATOR CLASS IF EXISTS pg_catalog.varbinary_ops USING BTREE; DROP OPERATOR CLASS IF EXISTS pg_catalog.varbinary_ops USING HASH; DROP OPERATOR CLASS IF EXISTS pg_catalog.binary_ops USING BTREE; DROP OPERATOR CLASS IF EXISTS pg_catalog.binary_ops USING HASH; DROP OPERATOR FAMILY IF EXISTS pg_catalog.varbinary_ops USING BTREE; DROP OPERATOR FAMILY IF EXISTS pg_catalog.varbinary_ops USING HASH; DROP OPERATOR FAMILY IF EXISTS pg_catalog.binary_ops USING BTREE; DROP OPERATOR FAMILY IF EXISTS pg_catalog.binary_ops USING HASH; DROP FUNCTION IF EXISTS pg_catalog.varbinary_cmp(varbinary, varbinary); DROP FUNCTION IF EXISTS pg_catalog.binary_cmp(binary, binary); DROP FUNCTION IF EXISTS pg_catalog.degrees(boolean); DROP FUNCTION IF EXISTS pg_catalog.degrees(year); DROP FUNCTION IF EXISTS pg_catalog.degrees(json); DROP FUNCTION IF EXISTS pg_catalog.acos(boolean); DROP FUNCTION IF EXISTS pg_catalog.acos(year); DROP FUNCTION IF EXISTS pg_catalog.acos(json); DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(bit); DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(binary); DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(tinyblob); DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(nvarchar2); DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(year); DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(json); DROP FUNCTION IF EXISTS pg_catalog.exp(year); DROP FUNCTION IF EXISTS pg_catalog.exp(json); DROP FUNCTION IF EXISTS pg_catalog.int8_cast_date(int1); DROP FUNCTION IF EXISTS pg_catalog.int16_cast_date(int2); DROP FUNCTION IF EXISTS pg_catalog.int32_cast_date(int4); DROP FUNCTION IF EXISTS pg_catalog.int64_cast_date(int8); DROP FUNCTION IF EXISTS pg_catalog.uint8_cast_date(uint1); DROP FUNCTION IF EXISTS pg_catalog.uint16_cast_date(uint2); DROP FUNCTION IF EXISTS pg_catalog.uint32_cast_date(uint4); DROP FUNCTION IF EXISTS pg_catalog.uint64_cast_date(uint8); DROP FUNCTION IF EXISTS pg_catalog.float4_cast_date(float4); DROP FUNCTION IF EXISTS pg_catalog.float8_cast_date(float8); DROP FUNCTION IF EXISTS pg_catalog.numeric_cast_date(numeric); DROP FUNCTION IF EXISTS pg_catalog.text_date_explicit(TEXT); DROP FUNCTION IF EXISTS pg_catalog.int8_cast_datetime(int1); DROP FUNCTION IF EXISTS pg_catalog.int16_cast_datetime(int2); DROP FUNCTION IF EXISTS pg_catalog.int32_cast_datetime(int4); DROP FUNCTION IF EXISTS pg_catalog.int64_cast_datetime(int8); DROP FUNCTION IF EXISTS pg_catalog.uint8_cast_datetime(uint1); DROP FUNCTION IF EXISTS pg_catalog.uint16_cast_datetime(uint2); DROP FUNCTION IF EXISTS pg_catalog.uint32_cast_datetime(uint4); DROP FUNCTION IF EXISTS pg_catalog.uint64_cast_datetime(uint8); DROP FUNCTION IF EXISTS pg_catalog.float4_cast_datetime(float4); DROP FUNCTION IF EXISTS pg_catalog.float8_cast_datetime(float8); DROP FUNCTION IF EXISTS pg_catalog.numeric_cast_datetime(numeric); DROP FUNCTION IF EXISTS pg_catalog.timestamp_explicit(TEXT); DROP FUNCTION IF EXISTS pg_catalog.int8_cast_timestamptz(int1); DROP FUNCTION IF EXISTS pg_catalog.int16_cast_timestamptz(int2); DROP FUNCTION IF EXISTS pg_catalog.int32_cast_timestamptz(int4); DROP FUNCTION IF EXISTS pg_catalog.int64_cast_timestamptz(int8); DROP FUNCTION IF EXISTS pg_catalog.uint8_cast_timestamptz(uint1); DROP FUNCTION IF EXISTS pg_catalog.uint16_cast_timestamptz(uint2); DROP FUNCTION IF EXISTS pg_catalog.uint32_cast_timestamptz(uint4); DROP FUNCTION IF EXISTS pg_catalog.uint64_cast_timestamptz(uint8); DROP FUNCTION IF EXISTS pg_catalog.float4_cast_timestamptz(float4); DROP FUNCTION IF EXISTS pg_catalog.float8_cast_timestamptz(float8); DROP FUNCTION IF EXISTS pg_catalog.numeric_cast_timestamptz(numeric); DROP CAST IF EXISTS (TEXT AS timestamp with time zone); DROP FUNCTION IF EXISTS pg_catalog.timestamptz_explicit(TEXT); DROP FUNCTION IF EXISTS pg_catalog.ln(year); DROP FUNCTION IF EXISTS pg_catalog.ln(json); DROP FUNCTION IF EXISTS pg_catalog.log(anyelement,anyelement); DROP FUNCTION IF EXISTS pg_catalog.log(year); DROP FUNCTION IF EXISTS pg_catalog.log(json); DROP FUNCTION IF EXISTS pg_catalog.log(uint1); DROP FUNCTION IF EXISTS pg_catalog.log(uint2); DROP FUNCTION IF EXISTS pg_catalog.log(uint4); DROP FUNCTION IF EXISTS pg_catalog.log(uint8); DROP FUNCTION IF EXISTS pg_catalog.log(bit); DROP FUNCTION IF EXISTS pg_catalog.log(boolean); DROP FUNCTION IF EXISTS pg_catalog.log(text); DROP FUNCTION IF EXISTS pg_catalog.log(char); DROP FUNCTION IF EXISTS pg_catalog.log(varchar); DROP FUNCTION IF EXISTS pg_catalog.log2(uint1); DROP FUNCTION IF EXISTS pg_catalog.log2(uint2); DROP FUNCTION IF EXISTS pg_catalog.log2(uint4); DROP FUNCTION IF EXISTS pg_catalog.log2(uint8); DROP FUNCTION IF EXISTS pg_catalog.log2(numeric); CREATE OR REPLACE FUNCTION pg_catalog.log2(numeric) RETURNS numeric AS $$ BEGIN IF $1 <= 0 THEN RETURN NULL; end if; RETURN (SELECT log(2, $1)); END; $$ LANGUAGE plpgsql; DROP FUNCTION IF EXISTS pg_catalog.log2(bit); DROP FUNCTION IF EXISTS pg_catalog.log2(boolean); DROP FUNCTION IF EXISTS pg_catalog.log2(text); DROP FUNCTION IF EXISTS pg_catalog.log2(char); DROP FUNCTION IF EXISTS pg_catalog.log2(varchar); DROP FUNCTION IF EXISTS pg_catalog.log10(uint1); DROP FUNCTION IF EXISTS pg_catalog.log10(uint2); DROP FUNCTION IF EXISTS pg_catalog.log10(uint4); DROP FUNCTION IF EXISTS pg_catalog.log10(uint8); DROP FUNCTION IF EXISTS pg_catalog.log10(numeric); CREATE OR REPLACE FUNCTION pg_catalog.log10(numeric) RETURNS numeric AS $$ BEGIN IF $1 <= 0 THEN RETURN NULL; end if; RETURN (SELECT log(10, $1)); END; $$ LANGUAGE plpgsql; DROP FUNCTION IF EXISTS pg_catalog.log10(bit); DROP FUNCTION IF EXISTS pg_catalog.log10(boolean); DROP FUNCTION IF EXISTS pg_catalog.log10(text); DROP FUNCTION IF EXISTS pg_catalog.log10(char); DROP FUNCTION IF EXISTS pg_catalog.log10(varchar); DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_int1(anyelement) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_int2(anyelement) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_int4(anyelement) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.str_to_date(boolean, TEXT); DROP FUNCTION IF EXISTS pg_catalog.str_to_date(longblob, TEXT); DROP FUNCTION IF EXISTS pg_catalog.str_to_date(anyenum, TEXT); DROP FUNCTION IF EXISTS pg_catalog.str_to_date(json, TEXT); DROP OPERATOR CLASS IF EXISTS pg_catalog.tinyblob_ops USING BTREE; DROP OPERATOR CLASS IF EXISTS pg_catalog.tinyblob_ops USING HASH; DROP OPERATOR CLASS IF EXISTS pg_catalog.blob_ops USING BTREE; DROP OPERATOR CLASS IF EXISTS pg_catalog.blob_ops USING HASH; DROP OPERATOR CLASS IF EXISTS pg_catalog.mediumblob_ops USING BTREE; DROP OPERATOR CLASS IF EXISTS pg_catalog.mediumblob_ops USING HASH; DROP OPERATOR CLASS IF EXISTS pg_catalog.longblob_ops USING BTREE; DROP OPERATOR CLASS IF EXISTS pg_catalog.longblob_ops USING HASH; DROP OPERATOR FAMILY IF EXISTS pg_catalog.tinyblob_ops USING BTREE; DROP OPERATOR FAMILY IF EXISTS pg_catalog.tinyblob_ops USING HASH; DROP OPERATOR FAMILY IF EXISTS pg_catalog.blob_ops USING BTREE; DROP OPERATOR FAMILY IF EXISTS pg_catalog.blob_ops USING HASH; DROP OPERATOR FAMILY IF EXISTS pg_catalog.mediumblob_ops USING BTREE; DROP OPERATOR FAMILY IF EXISTS pg_catalog.mediumblob_ops USING HASH; DROP OPERATOR FAMILY IF EXISTS pg_catalog.longblob_ops USING BTREE; DROP OPERATOR FAMILY IF EXISTS pg_catalog.longblob_ops USING HASH; DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, blob); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, blob); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, blob); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, blob); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, blob); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, blob); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, text); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, text); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, text); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, text); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, text); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, text); DROP OPERATOR IF EXISTS pg_catalog.=(text, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(text, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(text, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(text, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(text, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(text, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(blob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(blob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(blob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(blob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(blob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(blob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(blob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(blob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(blob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(blob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(blob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(blob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(blob, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(blob, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(blob, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(blob, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(blob, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(blob, longblob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, blob); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, blob); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, blob); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, blob); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, blob); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, blob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, text); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, text); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, text); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, text); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, text); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, text); DROP OPERATOR IF EXISTS pg_catalog.=(text, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(text, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(text, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(text, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(text, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(text, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, blob); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, blob); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, blob); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, blob); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, blob); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, blob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, longblob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, text); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, text); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, text); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, text); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, text); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, text); DROP OPERATOR IF EXISTS pg_catalog.=(text, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(text, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(text, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(text, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(text, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(text, longblob); DROP FUNCTION IF EXISTS pg_catalog.blob_cmp(blob, blob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_eq(arg1 tinyblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_ne(arg1 tinyblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_lt(arg1 tinyblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_le(arg1 tinyblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_gt(arg1 tinyblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_ge(arg1 tinyblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_cmp(tinyblob, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_eq_text(arg1 tinyblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_ne_text(arg1 tinyblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_lt_text(arg1 tinyblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_le_text(arg1 tinyblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_gt_text(arg1 tinyblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_ge_text(arg1 tinyblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.text_eq_tinyblob(arg1 text, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.text_ne_tinyblob(arg1 text, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.text_lt_tinyblob(arg1 text, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.text_le_tinyblob(arg1 text, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.test_gt_tinyblob(arg1 text, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.test_ge_tinyblob(arg1 text, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_eq(arg1 mediumblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_ne(arg1 mediumblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_lt(arg1 mediumblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_le(arg1 mediumblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_gt(arg1 mediumblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_ge(arg1 mediumblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_cmp(mediumblob, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_eq_text(arg1 tinyblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_ne_text(arg1 tinyblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_lt_text(arg1 tinyblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_le_text(arg1 tinyblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_gt_text(arg1 tinyblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_ge_text(arg1 tinyblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.text_eq_tinyblob(arg1 text, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.text_ne_tinyblob(arg1 text, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.text_lt_tinyblob(arg1 text, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.text_le_tinyblob(arg1 text, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.test_gt_tinyblob(arg1 text, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.test_ge_tinyblob(arg1 text, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_eq(arg1 mediumblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_ne(arg1 mediumblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_lt(arg1 mediumblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_le(arg1 mediumblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_gt(arg1 mediumblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_ge(arg1 mediumblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_cmp(mediumblob, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_eq_text(arg1 mediumblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_ne_text(arg1 mediumblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_lt_text(arg1 mediumblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_le_text(arg1 mediumblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_gt_text(arg1 mediumblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_ge_text(arg1 mediumblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.text_eq_mediumblob(arg1 text, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.text_ne_mediumblob(arg1 text, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.text_lt_mediumblob(arg1 text, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.text_le_mediumblob(arg1 text, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.test_gt_mediumblob(arg1 text, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.test_ge_mediumblob(arg1 text, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_eq(arg1 longblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_ne(arg1 longblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_lt(arg1 longblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_le(arg1 longblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_gt(arg1 longblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_ge(arg1 longblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_cmp(longblob, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_eq_text(arg1 longblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.longblob_ne_text(arg1 longblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.longblob_lt_text(arg1 longblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.longblob_le_text(arg1 longblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.longblob_gt_text(arg1 longblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.longblob_ge_text(arg1 longblob, arg2 text); DROP FUNCTION IF EXISTS pg_catalog.text_eq_longblob(arg1 text, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.text_ne_longblob(arg1 text, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.text_lt_longblob(arg1 text, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.text_le_longblob(arg1 text, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.test_gt_longblob(arg1 text, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.test_ge_longblob(arg1 text, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_blob_eq(arg1 tinyblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_blob_ne(arg1 tinyblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_blob_lt(arg1 tinyblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_blob_le(arg1 tinyblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_blob_gt(arg1 tinyblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_blob_ge(arg1 tinyblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_blob_cmp(tinyblob, blob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_mediumblob_eq(arg1 tinyblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_mediumblob_ne(arg1 tinyblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_mediumblob_lt(arg1 tinyblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_mediumblob_le(arg1 tinyblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_mediumblob_gt(arg1 tinyblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_mediumblob_ge(arg1 tinyblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_mediumblob_cmp(tinyblob, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_longblob_eq(arg1 tinyblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_longblob_ne(arg1 tinyblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_longblob_lt(arg1 tinyblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_longblob_le(arg1 tinyblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_longblob_gt(arg1 tinyblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_longblob_ge(arg1 tinyblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_longblob_cmp(tinyblob, longblob); DROP FUNCTION IF EXISTS pg_catalog.blob_tinyblob_eq(arg1 blob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.blob_tinyblob_ne(arg1 blob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.blob_tinyblob_lt(arg1 blob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.blob_tinyblob_le(arg1 blob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.blob_tinyblob_gt(arg1 blob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.blob_tinyblob_ge(arg1 blob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.blob_tinyblob_cmp(blob, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.blob_mediumblob_eq(arg1 blob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.blob_mediumblob_ne(arg1 blob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.blob_mediumblob_lt(arg1 blob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.blob_mediumblob_le(arg1 blob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.blob_mediumblob_gt(arg1 blob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.blob_mediumblob_ge(arg1 blob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.blob_mediumblob_cmp(blob, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.blob_longblob_eq(arg1 blob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.blob_longblob_ne(arg1 blob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.blob_longblob_lt(arg1 blob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.blob_longblob_le(arg1 blob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.blob_longblob_gt(arg1 blob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.blob_longblob_ge(arg1 blob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.blob_longblob_cmp(longblob, longblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_tinyblob_eq(arg1 mediumblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_tinyblob_ne(arg1 mediumblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_tinyblob_lt(arg1 mediumblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_tinyblob_le(arg1 mediumblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_tinyblob_gt(arg1 mediumblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_tinyblob_ge(arg1 mediumblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_tinyblob_cmp(mediumblob, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_blob_eq(arg1 mediumblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_blob_ne(arg1 mediumblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_blob_lt(arg1 mediumblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_blob_le(arg1 mediumblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_blob_gt(arg1 mediumblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_blob_ge(arg1 mediumblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_blob_cmp(mediumblob, blob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_longblob_eq(arg1 mediumblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_longblob_ne(arg1 mediumblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_longblob_lt(arg1 mediumblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_longblob_le(arg1 mediumblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_longblob_gt(arg1 mediumblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_longblob_ge(arg1 mediumblob, arg2 longblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_longblob_cmp(longblob, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_tinyblob_eq(arg1 longblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_tinyblob_ne(arg1 longblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_tinyblob_lt(arg1 longblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_tinyblob_le(arg1 longblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_tinyblob_gt(arg1 longblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_tinyblob_ge(arg1 longblob, arg2 tinyblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_tinyblob_cmp(longblob, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_blob_eq(arg1 longblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.longblob_blob_ne(arg1 longblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.longblob_blob_lt(arg1 longblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.longblob_blob_le(arg1 longblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.longblob_blob_gt(arg1 longblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.longblob_blob_ge(arg1 longblob, arg2 blob); DROP FUNCTION IF EXISTS pg_catalog.longblob_blob_cmp(longblob, blob); DROP FUNCTION IF EXISTS pg_catalog.longblob_mediumblob_eq(arg1 longblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_mediumblob_ne(arg1 longblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_mediumblob_lt(arg1 longblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_mediumblob_le(arg1 longblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_mediumblob_gt(arg1 longblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_mediumblob_ge(arg1 longblob, arg2 mediumblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_mediumblob_cmp(longblob, longblob); DROP FUNCTION IF EXISTS pg_catalog.floor(year); DROP FUNCTION IF EXISTS pg_catalog.floor(json); DROP FUNCTION IF EXISTS pg_catalog.substr(longblob, int, int); DROP FUNCTION IF EXISTS pg_catalog.substr(longblob, int); DROP FUNCTION IF EXISTS pg_catalog.repeat(longblob, int); DROP CAST IF EXISTS (tinyblob AS binary) ; DROP CAST IF EXISTS (tinyblob AS varbinary) ; DROP CAST IF EXISTS (blob AS binary) ; DROP CAST IF EXISTS (blob AS varbinary) ; DROP CAST IF EXISTS (mediumblob AS binary) ; DROP CAST IF EXISTS (mediumblob AS varbinary) ; DROP CAST IF EXISTS (longblob AS binary) ; DROP CAST IF EXISTS (longblob AS varbinary) ; DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(blob) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(mediumblob) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(longblob) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.unhex (text); DROP FUNCTION IF EXISTS pg_catalog.unhex (boolean); DROP FUNCTION IF EXISTS pg_catalog.unhex (bytea); DROP FUNCTION IF EXISTS pg_catalog.unhex (bit); 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'; DROP FUNCTION IF EXISTS pg_catalog.hour(YEAR); DROP FUNCTION IF EXISTS pg_catalog.hour(date); DROP FUNCTION IF EXISTS pg_catalog.hour(timetz); DROP FUNCTION IF EXISTS pg_catalog.hour(timestamptz); DROP FUNCTION IF EXISTS pg_catalog.hour (text); CREATE OR REPLACE FUNCTION pg_catalog.hour (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetHour'; DROP FUNCTION IF EXISTS pg_catalog.minute(YEAR); DROP FUNCTION IF EXISTS pg_catalog.minute(date); DROP FUNCTION IF EXISTS pg_catalog.minute(timetz); DROP FUNCTION IF EXISTS pg_catalog.minute(timestamptz); DROP FUNCTION IF EXISTS pg_catalog.minute (text); CREATE OR REPLACE FUNCTION pg_catalog.minute (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMinute'; DROP FUNCTION IF EXISTS pg_catalog.second(YEAR); DROP FUNCTION IF EXISTS pg_catalog.second(date); DROP FUNCTION IF EXISTS pg_catalog.second(timetz); DROP FUNCTION IF EXISTS pg_catalog.second(timestamptz); DROP FUNCTION IF EXISTS pg_catalog.second (text); CREATE OR REPLACE FUNCTION pg_catalog.second (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetSecond'; DROP FUNCTION IF EXISTS pg_catalog.microsecond(date); DROP FUNCTION IF EXISTS pg_catalog.microsecond(timetz); DROP FUNCTION IF EXISTS pg_catalog.microsecond(timestamptz); DROP FUNCTION IF EXISTS pg_catalog.microsecond (text); CREATE OR REPLACE FUNCTION pg_catalog.microsecond (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMicrosecond'; DROP FUNCTION IF EXISTS pg_catalog.year(YEAR); DROP FUNCTION IF EXISTS pg_catalog.year(timestamp(0) without time zone); DROP FUNCTION IF EXISTS pg_catalog.year(text); DROP FUNCTION IF EXISTS pg_catalog.year(bit); DROP FUNCTION IF EXISTS pg_catalog.year(boolean); DROP FUNCTION IF EXISTS pg_catalog.year(int4); DROP FUNCTION IF EXISTS pg_catalog.year(longblob); DROP FUNCTION IF EXISTS pg_catalog.year(anyenum); DROP FUNCTION IF EXISTS pg_catalog.year(json); DROP FUNCTION IF EXISTS pg_catalog.year(time); CREATE FUNCTION pg_catalog.year (timestamp(0) without time zone) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'datetime_year_part'; CREATE FUNCTION pg_catalog.year (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'text_year_part'; -- repeat function support DROP FUNCTION IF EXISTS pg_catalog.repeat(anyenum, integer); DROP FUNCTION IF EXISTS pg_catalog.repeat(boolean, integer); DROP FUNCTION IF EXISTS pg_catalog.repeat(tinyblob, integer); DROP FUNCTION IF EXISTS pg_catalog.repeat(json, integer); DROP FUNCTION IF EXISTS pg_catalog.repeat(year, integer); DROP FUNCTION IF EXISTS pg_catalog.repeat(binary, integer); DROP FUNCTION IF EXISTS pg_catalog.repeat(bit, integer); do $$ begin update pg_catalog.pg_cast set castfunc = (select oid from pg_proc where proname = 'bpchar_text'), castowner = 10 where castsource = 1042 and casttarget = 25; update pg_catalog.pg_cast set castfunc = (select oid from pg_proc where proname = 'bpchar_text'), castowner = 10 where castsource = 1042 and casttarget = 1043; update pg_catalog.pg_cast set castfunc = (select oid from pg_proc where proname = 'bpchar_text'), castowner = 10 where castsource = 1042 and casttarget = 3969; end $$; drop function pg_catalog.year_recv(internal); CREATE OR REPLACE FUNCTION pg_catalog.year_recv (bytea) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_recv'; do $$ begin update pg_catalog.pg_type set typreceive = '-', typsend = '-' where oid = 'year'::regtype; end $$; DROP CAST IF EXISTS ("binary" AS boolean); DROP CAST IF EXISTS ("varbinary" AS boolean); DROP CAST IF EXISTS (blob AS boolean); DROP CAST IF EXISTS (tinyblob AS boolean); DROP CAST IF EXISTS (mediumblob AS boolean); DROP CAST IF EXISTS (longblob AS boolean); DROP CAST IF EXISTS (anyset AS boolean); DROP FUNCTION IF EXISTS pg_catalog.any2boolean(anyelement) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.enum_boolean(anyenum) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.set_boolean(anyset) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.binary2boolean(binary) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.varbinary2boolean(varbinary) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.ascii(blob); DROP FUNCTION IF EXISTS pg_catalog.ascii(year); DROP FUNCTION IF EXISTS pg_catalog.ascii(json); DROP FUNCTION IF EXISTS pg_catalog.ascii(boolean); DROP FUNCTION IF EXISTS pg_catalog.ascii(anyenum); DROP FUNCTION IF EXISTS pg_catalog.ascii(bit); DROP FUNCTION IF EXISTS pg_catalog.bit_length(boolean); DROP FUNCTION IF EXISTS pg_catalog.bit_length(year); DROP FUNCTION IF EXISTS pg_catalog.bit_length(blob); DROP FUNCTION IF EXISTS pg_catalog.bit_length(anyenum); DROP FUNCTION IF EXISTS pg_catalog.bit_length(json); DROP FUNCTION IF EXISTS pg_catalog.bit_length(binary); DROP CAST IF EXISTS (uint4 AS year) CASCADE; DROP CAST IF EXISTS (boolean AS year) CASCADE; DROP CAST IF EXISTS (char AS year) CASCADE; DROP CAST IF EXISTS (varchar AS year) CASCADE; DROP CAST IF EXISTS (text AS year) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.uint4_year(uint4) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.boolean_year(boolean) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.char_year(char) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.varchar_year(varchar) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.text_year(text) CASCADE; DROP OPERATOR IF EXISTS pg_catalog.~~(varbinary, varbinary); DROP OPERATOR IF EXISTS pg_catalog.~~(varbinary, text); DROP OPERATOR IF EXISTS pg_catalog.~~*(varbinary, text); DROP OPERATOR IF EXISTS pg_catalog.~~(text, varbinary); DROP OPERATOR IF EXISTS pg_catalog.~~*(text, varbinary); DROP FUNCTION IF EXISTS pg_catalog.varbinarylike(varbinary, varbinary); DROP FUNCTION IF EXISTS pg_catalog.textvarbinarylike(text, varbinary); DROP FUNCTION IF EXISTS pg_catalog.varbinarytextlike(varbinary, text); DROP OPERATOR IF EXISTS pg_catalog.~~(blob, blob); DROP OPERATOR IF EXISTS pg_catalog.~~*(blob, blob); DROP FUNCTION IF EXISTS pg_catalog.bloblike(blob, blob); DROP OPERATOR IF EXISTS pg_catalog.=(boolean, binary); DROP OPERATOR IF EXISTS pg_catalog.=(binary, boolean); DROP OPERATOR IF EXISTS pg_catalog.<>(boolean, binary); DROP OPERATOR IF EXISTS pg_catalog.<>(binary, boolean); DROP OPERATOR IF EXISTS pg_catalog.>(boolean, binary); DROP OPERATOR IF EXISTS pg_catalog.>(binary, boolean); DROP OPERATOR IF EXISTS pg_catalog.<(boolean, binary); DROP OPERATOR IF EXISTS pg_catalog.<(binary, boolean); DROP OPERATOR IF EXISTS pg_catalog.>=(boolean, binary); DROP OPERATOR IF EXISTS pg_catalog.>=(binary, boolean); DROP OPERATOR IF EXISTS pg_catalog.<=(boolean, binary); DROP OPERATOR IF EXISTS pg_catalog.<=(binary, boolean); DROP function IF EXISTS pg_catalog.boolean_binary_eq(boolean, binary); DROP function IF EXISTS pg_catalog.binary_boolean_eq(binary, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_binary_ne(boolean, binary); DROP FUNCTION IF EXISTS pg_catalog.binary_boolean_ne(binary, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_binary_gt(boolean, binary); DROP FUNCTION IF EXISTS pg_catalog.binary_boolean_gt(binary, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_binary_lt(boolean, binary); DROP FUNCTION IF EXISTS pg_catalog.binary_boolean_lt(binary, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_binary_ge(boolean, binary); DROP FUNCTION IF EXISTS pg_catalog.binary_boolean_ge(binary, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_binary_le(boolean, binary); DROP FUNCTION IF EXISTS pg_catalog.binary_boolean_le(binary, boolean); DROP OPERATOR IF EXISTS pg_catalog.=(boolean, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.<>(boolean, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.>(boolean, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.<(boolean, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.>=(boolean, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.<=(boolean, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, boolean); DROP function IF EXISTS pg_catalog.boolean_tinyblob_eq(boolean, tinyblob); DROP function IF EXISTS pg_catalog.tinyblob_boolean_eq(tinyblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_tinyblob_ne(boolean, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_boolean_ne(tinyblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_tinyblob_gt(boolean, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_boolean_gt(tinyblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_tinyblob_lt(boolean, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_boolean_lt(tinyblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_tinyblob_ge(boolean, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_boolean_ge(tinyblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_tinyblob_le(boolean, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_boolean_le(tinyblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.=(boolean, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.<>(boolean, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.>(boolean, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.<(boolean, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.>=(boolean, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.<=(boolean, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, boolean); DROP function IF EXISTS pg_catalog.boolean_mediumblob_eq(boolean, mediumblob); DROP function IF EXISTS pg_catalog.mediumblob_boolean_eq(mediumblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_mediumblob_ne(boolean, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_boolean_ne(mediumblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_mediumblob_gt(boolean, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_boolean_gt(mediumblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_mediumblob_lt(boolean, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_boolean_lt(mediumblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_mediumblob_ge(boolean, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_boolean_ge(mediumblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_mediumblob_le(boolean, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_boolean_le(mediumblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.=(boolean, blob); DROP OPERATOR IF EXISTS pg_catalog.=(blob, boolean); DROP OPERATOR IF EXISTS pg_catalog.<>(boolean, blob); DROP OPERATOR IF EXISTS pg_catalog.<>(blob, boolean); DROP OPERATOR IF EXISTS pg_catalog.>(boolean, blob); DROP OPERATOR IF EXISTS pg_catalog.>(blob, boolean); DROP OPERATOR IF EXISTS pg_catalog.<(boolean, blob); DROP OPERATOR IF EXISTS pg_catalog.<(blob, boolean); DROP OPERATOR IF EXISTS pg_catalog.>=(boolean, blob); DROP OPERATOR IF EXISTS pg_catalog.>=(blob, boolean); DROP OPERATOR IF EXISTS pg_catalog.<=(boolean, blob); DROP OPERATOR IF EXISTS pg_catalog.<=(blob, boolean); DROP function IF EXISTS pg_catalog.boolean_blob_eq(boolean, blob); DROP function IF EXISTS pg_catalog.blob_boolean_eq(blob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_blob_ne(boolean, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_boolean_ne(blob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_blob_gt(boolean, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_boolean_gt(blob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_blob_lt(boolean, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_boolean_lt(blob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_blob_ge(boolean, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_boolean_ge(blob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_blob_le(boolean, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_boolean_le(blob, boolean); DROP OPERATOR IF EXISTS pg_catalog.=(boolean, longblob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.<>(boolean, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.>(boolean, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.<(boolean, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.>=(boolean, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.<=(boolean, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, boolean); DROP function IF EXISTS pg_catalog.boolean_longblob_eq(boolean, longblob); DROP function IF EXISTS pg_catalog.longblob_boolean_eq(longblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_longblob_ne(boolean, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_boolean_ne(longblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_longblob_gt(boolean, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_boolean_gt(longblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_longblob_lt(boolean, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_boolean_lt(longblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_longblob_ge(boolean, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_boolean_ge(longblob, boolean); DROP FUNCTION IF EXISTS pg_catalog.boolean_longblob_le(boolean, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_boolean_le(longblob, boolean); DROP OPERATOR IF EXISTS pg_catalog.=(year, binary); DROP OPERATOR IF EXISTS pg_catalog.=(binary, year); DROP OPERATOR IF EXISTS pg_catalog.<>(year, binary); DROP OPERATOR IF EXISTS pg_catalog.<>(binary, year); DROP OPERATOR IF EXISTS pg_catalog.>(year, binary); DROP OPERATOR IF EXISTS pg_catalog.>(binary, year); DROP OPERATOR IF EXISTS pg_catalog.<(year, binary); DROP OPERATOR IF EXISTS pg_catalog.<(binary, year); DROP OPERATOR IF EXISTS pg_catalog.>=(year, binary); DROP OPERATOR IF EXISTS pg_catalog.>=(binary, year); DROP OPERATOR IF EXISTS pg_catalog.<=(year, binary); DROP OPERATOR IF EXISTS pg_catalog.<=(binary, year); DROP FUNCTION IF EXISTS pg_catalog.year_binary_eq(year, binary); DROP FUNCTION IF EXISTS pg_catalog.binary_year_eq(binary, year); DROP FUNCTION IF EXISTS pg_catalog.year_binary_ne(year, binary); DROP FUNCTION IF EXISTS pg_catalog.binary_year_ne(binary, year); DROP FUNCTION IF EXISTS pg_catalog.year_binary_gt(year, binary); DROP FUNCTION IF EXISTS pg_catalog.binary_year_gt(binary, year); DROP FUNCTION IF EXISTS pg_catalog.year_binary_lt(year, binary); DROP FUNCTION IF EXISTS pg_catalog.binary_year_lt(binary, year); DROP FUNCTION IF EXISTS pg_catalog.year_binary_ge(year, binary); DROP FUNCTION IF EXISTS pg_catalog.binary_year_ge(binary, year); DROP FUNCTION IF EXISTS pg_catalog.year_binary_le(year, binary); DROP FUNCTION IF EXISTS pg_catalog.binary_year_le(binary, year); DROP OPERATOR IF EXISTS pg_catalog.=(year, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, year); DROP OPERATOR IF EXISTS pg_catalog.<>(year, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, year); DROP OPERATOR IF EXISTS pg_catalog.>(year, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, year); DROP OPERATOR IF EXISTS pg_catalog.<(year, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, year); DROP OPERATOR IF EXISTS pg_catalog.>=(year, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, year); DROP OPERATOR IF EXISTS pg_catalog.<=(year, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_tinyblob_eq(year, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_year_eq(tinyblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_tinyblob_ne(year, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_year_ne(tinyblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_tinyblob_gt(year, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_year_gt(tinyblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_tinyblob_lt(year, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_year_lt(tinyblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_tinyblob_ge(year, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_year_ge(tinyblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_tinyblob_le(year, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_year_le(tinyblob, year); DROP OPERATOR IF EXISTS pg_catalog.=(year, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, year); DROP OPERATOR IF EXISTS pg_catalog.<>(year, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, year); DROP OPERATOR IF EXISTS pg_catalog.>(year, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, year); DROP OPERATOR IF EXISTS pg_catalog.<(year, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, year); DROP OPERATOR IF EXISTS pg_catalog.>=(year, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, year); DROP OPERATOR IF EXISTS pg_catalog.<=(year, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_mediumblob_eq(year, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_year_eq(mediumblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_mediumblob_ne(year, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_year_ne(mediumblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_mediumblob_gt(year, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_year_gt(mediumblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_mediumblob_lt(year, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_year_lt(mediumblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_mediumblob_ge(year, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_year_ge(mediumblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_mediumblob_le(year, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_year_le(mediumblob, year); DROP OPERATOR IF EXISTS pg_catalog.=(year, blob); DROP OPERATOR IF EXISTS pg_catalog.=(blob, year); DROP OPERATOR IF EXISTS pg_catalog.<>(year, blob); DROP OPERATOR IF EXISTS pg_catalog.<>(blob, year); DROP OPERATOR IF EXISTS pg_catalog.>(year, blob); DROP OPERATOR IF EXISTS pg_catalog.>(blob, year); DROP OPERATOR IF EXISTS pg_catalog.<(year, blob); DROP OPERATOR IF EXISTS pg_catalog.<(blob, year); DROP OPERATOR IF EXISTS pg_catalog.>=(year, blob); DROP OPERATOR IF EXISTS pg_catalog.>=(blob, year); DROP OPERATOR IF EXISTS pg_catalog.<=(year, blob); DROP OPERATOR IF EXISTS pg_catalog.<=(blob, year); DROP FUNCTION IF EXISTS pg_catalog.year_blob_eq(year, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_year_eq(blob, year); DROP FUNCTION IF EXISTS pg_catalog.year_blob_ne(year, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_year_ne(blob, year); DROP FUNCTION IF EXISTS pg_catalog.year_blob_gt(year, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_year_gt(blob, year); DROP FUNCTION IF EXISTS pg_catalog.year_blob_lt(year, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_year_lt(blob, year); DROP FUNCTION IF EXISTS pg_catalog.year_blob_ge(year, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_year_ge(blob, year); DROP FUNCTION IF EXISTS pg_catalog.year_blob_le(year, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_year_le(blob, year); DROP OPERATOR IF EXISTS pg_catalog.=(year, longblob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, year); DROP OPERATOR IF EXISTS pg_catalog.<>(year, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, year); DROP OPERATOR IF EXISTS pg_catalog.>(year, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, year); DROP OPERATOR IF EXISTS pg_catalog.<(year, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, year); DROP OPERATOR IF EXISTS pg_catalog.>=(year, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, year); DROP OPERATOR IF EXISTS pg_catalog.<=(year, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_longblob_eq(year, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_year_eq(longblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_longblob_ne(year, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_year_ne(longblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_longblob_gt(year, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_year_gt(longblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_longblob_lt(year, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_year_lt(longblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_longblob_ge(year, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_year_ge(longblob, year); DROP FUNCTION IF EXISTS pg_catalog.year_longblob_le(year, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_year_le(longblob, year); DROP OPERATOR IF EXISTS pg_catalog.=(int1, binary); DROP FUNCTION IF EXISTS pg_catalog.int1_binary_eq(int1, binary); DROP OPERATOR IF EXISTS pg_catalog.=(binary, int1); DROP FUNCTION IF EXISTS pg_catalog.binary_int1_eq(binary, int1); DROP OPERATOR IF EXISTS pg_catalog.<>(int1, binary); DROP FUNCTION IF EXISTS pg_catalog.int1_binary_ne(int1, binary); DROP OPERATOR IF EXISTS pg_catalog.<>(binary, int1); DROP FUNCTION IF EXISTS pg_catalog.binary_int1_ne(binary, int1); DROP OPERATOR IF EXISTS pg_catalog.=(text, binary); DROP FUNCTION IF EXISTS pg_catalog.text_binary_eq(text, binary); DROP OPERATOR IF EXISTS pg_catalog.=(binary, text); DROP FUNCTION IF EXISTS pg_catalog.binary_text_eq(binary, text); DROP CAST (timestamptz AS year); DROP CAST (timestamp(0) without time zone AS year); DROP CAST (date AS year); DROP FUNCTION IF EXISTS pg_catalog.timestamp_year(timestamptz) cascade; DROP FUNCTION IF EXISTS pg_catalog.datetime_year(timestamp(0) without time zone) cascade; DROP FUNCTION IF EXISTS pg_catalog.date_year(date) cascade; 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 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 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 (timestamptz AS year) with function pg_catalog.timestamp_year(timestamptz) AS ASSIGNMENT; CREATE CAST (timestamp(0) without time zone AS year) with function pg_catalog.datetime_year(timestamp(0) without time zone) AS ASSIGNMENT; CREATE CAST (date as year) with function pg_catalog.date_year(date) AS ASSIGNMENT; DROP CAST IF EXISTS (FLOAT8 AS NVARCHAR2); DROP CAST IF EXISTS (FLOAT4 AS NVARCHAR2); DROP FUNCTION IF EXISTS pg_catalog.float8_nvarchar2(FLOAT8); DROP FUNCTION IF EXISTS pg_catalog.float4_nvarchar2(FLOAT4); CREATE CAST (FLOAT4 AS NVARCHAR2) WITH FUNCTION pg_catalog.TO_NVARCHAR2(FLOAT4) AS IMPLICIT; CREATE CAST (FLOAT8 AS NVARCHAR2) WITH FUNCTION pg_catalog.TO_NVARCHAR2(FLOAT8) AS IMPLICIT; DROP FUNCTION IF EXISTS pg_catalog.json_contains("any", "any", text); DROP FUNCTION IF EXISTS pg_catalog.json_contains("any", "any"); DROP FUNCTION IF EXISTS pg_catalog.json_valid("any"); CREATE OR REPLACE FUNCTION pg_catalog.json_contains("any", "any", text) RETURNS boolean LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_contains'; CREATE OR REPLACE FUNCTION pg_catalog.json_contains("any", "any") RETURNS boolean LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_contains'; CREATE OR REPLACE FUNCTION pg_catalog.json_valid("any") RETURNS boolean LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_valid'; DROP FUNCTION pg_catalog.json_length("any"); DROP FUNCTION pg_catalog.json_length("any",text); DROP FUNCTION pg_catalog.json_depth("any"); DROP FUNCTION pg_catalog.json_storage_size("any"); CREATE OR REPLACE FUNCTION pg_catalog.json_length("any") RETURNS int LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_length'; CREATE OR REPLACE FUNCTION pg_catalog.json_length("any",text) RETURNS int LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_length'; CREATE OR REPLACE FUNCTION pg_catalog.json_depth("any") RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_depth'; CREATE OR REPLACE FUNCTION pg_catalog.json_storage_size("any") RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_storage_size'; DROP FUNCTION IF EXISTS pg_catalog.b_extract (text, year); DROP FUNCTION IF EXISTS pg_catalog.yearweek (year); DROP FUNCTION IF EXISTS pg_catalog.makedate (year, int8); DROP FUNCTION IF EXISTS pg_catalog.b_timestampdiff(text,year,year); DROP FUNCTION IF EXISTS pg_catalog.b_timestampdiff(text,text,year); DROP FUNCTION IF EXISTS pg_catalog.b_timestampdiff(text,year,text); DROP FUNCTION IF EXISTS pg_catalog.date_add (year, interval); DROP FUNCTION IF EXISTS pg_catalog.date_sub (year, interval); DROP FUNCTION IF EXISTS pg_catalog.is_ipv4(bit) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.is_ipv4(boolean) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.is_ipv4(year) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.is_ipv4(blob) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.is_ipv4(anyenum) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.is_ipv4(json) CASCADE; DROP OPERATOR IF EXISTS pg_catalog.&(binary, binary); DROP OPERATOR IF EXISTS pg_catalog.&(blob, blob); DROP AGGREGATE IF EXISTS pg_catalog.bit_and(char); DROP AGGREGATE IF EXISTS pg_catalog.bit_and(varchar); DROP AGGREGATE IF EXISTS pg_catalog.bit_and(binary); DROP AGGREGATE IF EXISTS pg_catalog.bit_and(varbinary); DROP AGGREGATE IF EXISTS pg_catalog.bit_and(tinyblob); DROP AGGREGATE IF EXISTS pg_catalog.bit_and(blob); DROP AGGREGATE IF EXISTS pg_catalog.bit_and(mediumblob); DROP AGGREGATE IF EXISTS pg_catalog.bit_and(longblob); DROP AGGREGATE IF EXISTS pg_catalog.bit_and(text); DROP AGGREGATE IF EXISTS pg_catalog.bit_and(json); DROP FUNCTION IF EXISTS pg_catalog.binaryand(binary, binary) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.varbinary_and_binary(varbinary, binary) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.varbinaryand(varbinary, varbinary) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.bloband(blob, blob) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.varbinary_and_tinyblob(varbinary, tinyblob) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.varbinary_and_blob(varbinary, blob) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.varbinary_and_mediumblob(varbinary, mediumblob) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.varbinary_and_longblob(varbinary, longblob) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.text_and_uint8(uint8, text) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.uint8and(uint8, char) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.uint8and(uint8, varchar) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.uint8and(uint8, json) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.inet6_ntoa(bit) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.inet6_ntoa(boolean) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.inet6_ntoa(year) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.inet6_ntoa(blob) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.inet6_ntoa(anyenum) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.inet6_ntoa(json) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.md5(bit) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.md5(boolean) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.md5(year) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.md5(blob) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.md5(anyenum) CASCADE; DROP FUNCTION IF EXISTS pg_catalog.md5(json) CASCADE; DROP OPERATOR CLASS IF EXISTS uint2_ops USING hash; DROP OPERATOR CLASS IF EXISTS uint4_ops USING hash; DROP OPERATOR CLASS IF EXISTS uint2_ops USING btree; DROP OPERATOR CLASS IF EXISTS uint4_ops USING btree; DROP OPERATOR IF EXISTS pg_catalog.=(int8, uint4); DROP OPERATOR IF EXISTS pg_catalog.=(int8, uint2); DROP FUNCTION IF EXISTS pg_catalog.int8_uint4_eq(int8, uint4); DROP FUNCTION IF EXISTS pg_catalog.int8_uint2_eq(int8, uint2); drop operator IF EXISTS pg_catalog.=(uint2, int8); CREATE OPERATOR pg_catalog.=( leftarg = uint2, rightarg = int8, procedure = uint2_int8_eq, restrict = eqsel, join = eqjoinsel, HASHES, MERGES ); drop operator IF EXISTS pg_catalog.=(uint4, int8); CREATE OPERATOR pg_catalog.=( leftarg = uint4, rightarg = int8, procedure = uint4_int8_eq, restrict = eqsel, join = eqjoinsel, HASHES, MERGES ); CREATE OPERATOR CLASS uint2_ops DEFAULT FOR TYPE uint2 USING hash family integer_ops AS OPERATOR 1 = , OPERATOR 1 =(uint2, uint4), OPERATOR 1 =(uint2, uint8), OPERATOR 1 =(uint2, int2), OPERATOR 1 =(uint2, int4), OPERATOR 1 =(uint2, int8), OPERATOR 1 =(int2, uint2), FUNCTION 1 hashuint2(uint2); CREATE OPERATOR CLASS uint4_ops DEFAULT FOR TYPE uint4 USING hash family integer_ops AS OPERATOR 1 = , OPERATOR 1 =(uint4, uint8), OPERATOR 1 =(uint4, int4), OPERATOR 1 =(uint4, int8), OPERATOR 1 =(int4, uint4), FUNCTION 1 hashuint4(uint4); CREATE OPERATOR CLASS uint2_ops DEFAULT FOR TYPE uint2 USING btree family integer_ops AS OPERATOR 1 < , OPERATOR 1 <(uint2, uint4), OPERATOR 1 <(uint2, uint8), OPERATOR 1 <(uint2, int2), OPERATOR 1 <(uint2, int4), OPERATOR 1 <(uint2, int8), OPERATOR 2 <= , OPERATOR 2 <=(uint2, uint4), OPERATOR 2 <=(uint2, uint8), OPERATOR 2 <=(uint2, int2), OPERATOR 2 <=(uint2, int4), OPERATOR 2 <=(uint2, int8), OPERATOR 3 = , OPERATOR 3 =(uint2, uint4), OPERATOR 3 =(uint2, uint8), OPERATOR 3 =(uint2, int2), OPERATOR 3 =(uint2, int4), OPERATOR 3 =(uint2, int8), OPERATOR 4 >= , OPERATOR 4 >=(uint2, uint4), OPERATOR 4 >=(uint2, uint8), OPERATOR 4 >=(uint2, int2), OPERATOR 4 >=(uint2, int4), OPERATOR 4 >=(uint2, int8), OPERATOR 5 > , OPERATOR 5 >(uint2, uint4), OPERATOR 5 >(uint2, uint8), OPERATOR 5 >(uint2, int2), OPERATOR 5 >(uint2, int4), OPERATOR 5 >(uint2, int8), FUNCTION 1 uint2cmp(uint2, uint2), FUNCTION 1 uint24cmp(uint2, uint4), FUNCTION 1 uint28cmp(uint2, uint8), FUNCTION 1 uint2_int2cmp(uint2, int2), FUNCTION 1 uint2_int4cmp(uint2, int4), FUNCTION 1 uint2_int8cmp(uint2, int8), FUNCTION 2 uint2_sortsupport(internal); CREATE OPERATOR CLASS uint4_ops DEFAULT FOR TYPE uint4 USING btree family integer_ops AS OPERATOR 1 < , OPERATOR 1 <(uint4, uint8), OPERATOR 1 <(uint4, int4), OPERATOR 1 <(uint4, int8), OPERATOR 2 <= , OPERATOR 2 <=(uint4, uint8), OPERATOR 2 <=(uint4, int4), OPERATOR 2 <=(uint4, int8), OPERATOR 3 = , OPERATOR 3 =(uint4, uint8), OPERATOR 3 =(uint4, int4), OPERATOR 3 =(uint4, int8), OPERATOR 4 >= , OPERATOR 4 >=(uint4, uint8), OPERATOR 4 >=(uint4, int4), OPERATOR 4 >=(uint4, int8), OPERATOR 5 > , OPERATOR 5 >(uint4, uint8), OPERATOR 5 >(uint4, int4), OPERATOR 5 >(uint4, int8), FUNCTION 1 uint4cmp(uint4, uint4), FUNCTION 1 uint48cmp(uint4, uint8), FUNCTION 1 uint4_int4cmp(uint4, int4), FUNCTION 1 uint4_int8cmp(uint4, int8), FUNCTION 2 uint4_sortsupport(internal); DROP FUNCTION pg_catalog.xor(int8, int8); DROP FUNCTION pg_catalog.xor(int8, bit); DROP FUNCTION pg_catalog.xor(bit, int8); DROP FUNCTION pg_catalog.xor(bit, bit); DROP FUNCTION pg_catalog.xor(int8, text); DROP FUNCTION pg_catalog.xor(text, int8); DROP FUNCTION pg_catalog.xor(text, text); DROP FUNCTION pg_catalog.xor(text, bit); DROP FUNCTION pg_catalog.xor(bit, text); DROP FUNCTION pg_catalog.xor(varbinary, int8); DROP FUNCTION pg_catalog.xor(int8, varbinary); DROP FUNCTION pg_catalog.xor(varbinary, varbinary); DROP FUNCTION pg_catalog.xor(varbinary, bit); DROP FUNCTION pg_catalog.xor(bit, varbinary); DROP FUNCTION pg_catalog.xor(varbinary, text); DROP FUNCTION pg_catalog.xor(text, varbinary); DROP FUNCTION pg_catalog.xor(binary, int8); DROP FUNCTION pg_catalog.xor(int8, binary); DROP FUNCTION pg_catalog.xor(binary, binary); DROP FUNCTION pg_catalog.xor(binary, bit); DROP FUNCTION pg_catalog.xor(bit, binary); DROP FUNCTION pg_catalog.xor(varbinary, binary); DROP FUNCTION pg_catalog.xor(binary, varbinary); DROP FUNCTION pg_catalog.xor(binary, text); DROP FUNCTION pg_catalog.xor(text, binary); DROP FUNCTION pg_catalog.xor(varchar, int8); DROP FUNCTION pg_catalog.xor(int8, varchar); DROP FUNCTION pg_catalog.xor(varchar, varchar); DROP FUNCTION pg_catalog.xor(varchar, bit); DROP FUNCTION pg_catalog.xor(bit, varchar); DROP FUNCTION pg_catalog.xor(varbinary, varchar); DROP FUNCTION pg_catalog.xor(varchar, varbinary); DROP FUNCTION pg_catalog.xor(varchar, text); DROP FUNCTION pg_catalog.xor(text, varchar); DROP FUNCTION pg_catalog.xor(binary, varchar); DROP FUNCTION pg_catalog.xor(varchar, binary); DROP FUNCTION pg_catalog.xor(char, int8); DROP FUNCTION pg_catalog.xor(int8, char); DROP FUNCTION pg_catalog.xor(char, char); DROP FUNCTION pg_catalog.xor(char, bit); DROP FUNCTION pg_catalog.xor(bit, char); DROP FUNCTION pg_catalog.xor(varbinary, char); DROP FUNCTION pg_catalog.xor(char, varbinary); DROP FUNCTION pg_catalog.xor(char, text); DROP FUNCTION pg_catalog.xor(text, char) ; DROP FUNCTION pg_catalog.xor(binary, char); DROP FUNCTION pg_catalog.xor(char, binary); DROP FUNCTION pg_catalog.xor(varchar, char); DROP FUNCTION pg_catalog.xor(char, varchar); DROP FUNCTION pg_catalog.xor(unknown,unknown); DROP FUNCTION pg_catalog.xor(unknown, int8); DROP FUNCTION pg_catalog.xor(int8, unknown); DROP FUNCTION pg_catalog.xor(unknown, integer); DROP FUNCTION pg_catalog.xor(integer, unknown); DROP FUNCTION pg_catalog.xor(unknown, float8); DROP FUNCTION pg_catalog.xor(float8, unknown); DROP FUNCTION pg_catalog.xor(unknown, boolean); DROP FUNCTION pg_catalog.xor(boolean, unknown); DROP FUNCTION pg_catalog.xor(unknown, bit); DROP FUNCTION pg_catalog.xor(bit, unknown); DROP FUNCTION pg_catalog.xor(unknown, text); DROP FUNCTION pg_catalog.xor(text, unknown); DROP FUNCTION pg_catalog.xor(unknown, binary); DROP FUNCTION pg_catalog.xor(binary, unknown); DROP FUNCTION pg_catalog.xor(varbinary, unknown); DROP FUNCTION pg_catalog.xor(unknown, varbinary); DROP FUNCTION pg_catalog.xor(varchar, unknown); DROP FUNCTION pg_catalog.xor(unknown, varchar); CREATE OR REPLACE FUNCTION pg_catalog.xor(a integer, b integer) returns integer as $$ begin return (select int4xor(a::bool::integer, b::bool::integer)); end; $$ language plpgsql; DROP FUNCTION IF EXISTS pg_catalog.to_days(bit); DROP FUNCTION IF EXISTS pg_catalog.to_days(boolean); DROP FUNCTION IF EXISTS pg_catalog.to_days(time); DROP FUNCTION IF EXISTS pg_catalog.to_days(year); DROP FUNCTION IF EXISTS pg_catalog.to_days(binary); DROP FUNCTION IF EXISTS pg_catalog.to_days(blob); DROP FUNCTION IF EXISTS pg_catalog.to_days(text); DROP FUNCTION IF EXISTS pg_catalog.to_days(anyenum); DROP FUNCTION IF EXISTS pg_catalog.to_days(anyset); DROP FUNCTION IF EXISTS pg_catalog.to_days(json); CREATE OR REPLACE FUNCTION pg_catalog.to_days(time) RETURNS int8 AS $$ SELECT pg_catalog.to_days(text_date('now') + $1) $$ LANGUAGE SQL; DROP FUNCTION pg_catalog.round(int1); DROP FUNCTION pg_catalog.round(uint1); DROP FUNCTION pg_catalog.round(int2); DROP FUNCTION pg_catalog.round(uint2); DROP FUNCTION pg_catalog.round(int4); DROP FUNCTION pg_catalog.round(uint4); DROP FUNCTION pg_catalog.round(int8); DROP FUNCTION pg_catalog.round(uint8); DROP FUNCTION pg_catalog.round(boolean); DROP FUNCTION pg_catalog.round(year); DROP FUNCTION pg_catalog.round(int1, int4); DROP FUNCTION pg_catalog.round(uint1, int4); DROP FUNCTION pg_catalog.round(int2, int4); DROP FUNCTION pg_catalog.round(uint2, int4); DROP FUNCTION pg_catalog.round(int4, int4); DROP FUNCTION pg_catalog.round(uint4, int4); DROP FUNCTION pg_catalog.round(int8, int4); DROP FUNCTION pg_catalog.round(uint8, int4); DROP FUNCTION pg_catalog.round(boolean, int4); DROP FUNCTION pg_catalog.round(year, int4); DROP FUNCTION pg_catalog.round(binary, int4); DROP FUNCTION pg_catalog.round(json, int4); DROP FUNCTION pg_catalog.round(int1, uint4); DROP FUNCTION pg_catalog.round(uint1, uint4); DROP FUNCTION pg_catalog.round(int2, uint4); DROP FUNCTION pg_catalog.round(uint2, uint4); DROP FUNCTION pg_catalog.round(int4, uint4); DROP FUNCTION pg_catalog.round(uint4, uint4); DROP FUNCTION pg_catalog.round(int8, uint4); DROP FUNCTION pg_catalog.round(uint8, uint4); DROP FUNCTION pg_catalog.round(boolean, uint4); DROP FUNCTION pg_catalog.round(year, uint4); DROP FUNCTION pg_catalog.round(binary, uint4); DROP FUNCTION pg_catalog.round(json, uint4); DROP FUNCTION pg_catalog.truncate(int1, int4); DROP FUNCTION pg_catalog.truncate(uint1, int4); DROP FUNCTION pg_catalog.truncate(int2, int4); DROP FUNCTION pg_catalog.truncate(uint2, int4); DROP FUNCTION pg_catalog.truncate(int4, int4); DROP FUNCTION pg_catalog.truncate(uint4, int4); DROP FUNCTION pg_catalog.truncate(int8, int4); DROP FUNCTION pg_catalog.truncate(uint8, int4); DROP FUNCTION pg_catalog.truncate(boolean, int4); DROP FUNCTION pg_catalog.truncate(year, int4); DROP FUNCTION pg_catalog.truncate(binary, int4); DROP FUNCTION pg_catalog.truncate(json, int4); DROP FUNCTION pg_catalog.truncate(int1, uint4); DROP FUNCTION pg_catalog.truncate(uint1, uint4); DROP FUNCTION pg_catalog.truncate(int2, uint4); DROP FUNCTION pg_catalog.truncate(uint2, uint4); DROP FUNCTION pg_catalog.truncate(int4, uint4); DROP FUNCTION pg_catalog.truncate(uint4, uint4); DROP FUNCTION pg_catalog.truncate(int8, uint4); DROP FUNCTION pg_catalog.truncate(uint8, uint4); DROP FUNCTION pg_catalog.truncate(boolean, uint4); DROP FUNCTION pg_catalog.truncate(year, uint4); DROP FUNCTION pg_catalog.truncate(binary, uint4); DROP FUNCTION pg_catalog.truncate(json, uint4); DROP OPERATOR IF EXISTS pg_catalog.||(bit, bit); DROP OPERATOR IF EXISTS pg_catalog.||(bit, boolean); DROP OPERATOR IF EXISTS pg_catalog.||(boolean, bit); DROP OPERATOR IF EXISTS pg_catalog.||(boolean, boolean); DROP OPERATOR IF EXISTS pg_catalog.||(text, boolean); DROP OPERATOR IF EXISTS pg_catalog.||(boolean, text); DROP OPERATOR IF EXISTS pg_catalog.||(bit, text); DROP OPERATOR IF EXISTS pg_catalog.||(text, bit); DROP OPERATOR IF EXISTS pg_catalog.||(bit, binary); DROP OPERATOR IF EXISTS pg_catalog.||(binary, bit); DROP OPERATOR IF EXISTS pg_catalog.||(uint8, binary); DROP OPERATOR IF EXISTS pg_catalog.||(binary, uint8); DROP OPERATOR IF EXISTS pg_catalog.||(int8, binary); DROP OPERATOR IF EXISTS pg_catalog.||(binary, int8); DROP OPERATOR IF EXISTS pg_catalog.||(numeric, binary); DROP OPERATOR IF EXISTS pg_catalog.||(binary, numeric); DROP OPERATOR IF EXISTS pg_catalog.||(float4, binary); DROP OPERATOR IF EXISTS pg_catalog.||(binary, float4); DROP OPERATOR IF EXISTS pg_catalog.||(float8, binary); DROP OPERATOR IF EXISTS pg_catalog.||(binary, float8); DROP OPERATOR IF EXISTS pg_catalog.||(text, binary); DROP OPERATOR IF EXISTS pg_catalog.||(binary, text); DROP OPERATOR IF EXISTS pg_catalog.||(boolean, binary); DROP OPERATOR IF EXISTS pg_catalog.||(binary, boolean); DROP OPERATOR IF EXISTS pg_catalog.||(binary, binary); DROP OPERATOR IF EXISTS pg_catalog.||(bit, varbinary); DROP OPERATOR IF EXISTS pg_catalog.||(varbinary, bit); DROP OPERATOR IF EXISTS pg_catalog.||(uint8, varbinary); DROP OPERATOR IF EXISTS pg_catalog.||(varbinary, uint8); DROP OPERATOR IF EXISTS pg_catalog.||(int8, varbinary); DROP OPERATOR IF EXISTS pg_catalog.||(varbinary, int8); DROP OPERATOR IF EXISTS pg_catalog.||(numeric, varbinary); DROP OPERATOR IF EXISTS pg_catalog.||(varbinary, numeric); DROP OPERATOR IF EXISTS pg_catalog.||(float4, varbinary); DROP OPERATOR IF EXISTS pg_catalog.||(varbinary, float4); DROP OPERATOR IF EXISTS pg_catalog.||(float8, varbinary); DROP OPERATOR IF EXISTS pg_catalog.||(varbinary, float8); DROP OPERATOR IF EXISTS pg_catalog.||(text, varbinary); DROP OPERATOR IF EXISTS pg_catalog.||(varbinary, text); DROP OPERATOR IF EXISTS pg_catalog.||(boolean, varbinary); DROP OPERATOR IF EXISTS pg_catalog.||(varbinary, boolean); DROP OPERATOR IF EXISTS pg_catalog.||(binary, varbinary); DROP OPERATOR IF EXISTS pg_catalog.||(varbinary, binary); DROP OPERATOR IF EXISTS pg_catalog.||(varbinary, varbinary); DROP OPERATOR IF EXISTS pg_catalog.||(unknown, unknown); DROP OPERATOR IF EXISTS pg_catalog.||(unknown, integer); DROP OPERATOR IF EXISTS pg_catalog.||(integer, unknown); DROP FUNCTION pg_catalog.bit_concat(bit, bit); DROP FUNCTION pg_catalog.bit_bool_concat(bit, boolean); DROP FUNCTION pg_catalog.bool_bit_concat(boolean, bit); DROP FUNCTION pg_catalog.bool_concat(boolean, boolean); DROP FUNCTION pg_catalog.text_bool_concat(text, boolean); DROP FUNCTION pg_catalog.bool_text_concat(boolean, text); DROP FUNCTION pg_catalog.text_bit_concat(text, bit); DROP FUNCTION pg_catalog.bit_text_concat(bit, text); DROP FUNCTION pg_catalog.bin_concat(binary,binary); DROP FUNCTION pg_catalog.bin_int_concat(binary,uint8); DROP FUNCTION pg_catalog.bin_int8_concat(binary,int8); DROP FUNCTION pg_catalog.bin_float4_concat(binary,float4); DROP FUNCTION pg_catalog.bin_float8_concat(binary,float8); DROP FUNCTION pg_catalog.bin_num_concat(binary,numeric); DROP FUNCTION pg_catalog.bin_bit_concat(binary,bit); DROP FUNCTION pg_catalog.bin_text_concat(binary,text); DROP FUNCTION pg_catalog.bin_bool_concat(binary,boolean); DROP FUNCTION pg_catalog.int_bin_concat(uint8,binary); DROP FUNCTION pg_catalog.int8_bin_concat(int8,binary); DROP FUNCTION pg_catalog.float4_bin_concat(float4,binary); DROP FUNCTION pg_catalog.float8_bin_concat(float8,binary); DROP FUNCTION pg_catalog.num_bin_concat(numeric,binary); DROP FUNCTION pg_catalog.bit_bin_concat(bit,binary); DROP FUNCTION pg_catalog.text_bin_concat(text,binary); DROP FUNCTION pg_catalog.bool_bin_concat(boolean,binary); DROP FUNCTION pg_catalog.varbin_concat(varbinary,varbinary); DROP FUNCTION pg_catalog.varbin_int_concat(varbinary,uint8); DROP FUNCTION pg_catalog.varbin_int8_concat(varbinary,int8); DROP FUNCTION pg_catalog.varbin_float4_concat(varbinary,float4); DROP FUNCTION pg_catalog.varbin_float8_concat(varbinary,float8); DROP FUNCTION pg_catalog.varbin_num_concat(varbinary,numeric); DROP FUNCTION pg_catalog.varbin_bit_concat(varbinary,bit); DROP FUNCTION pg_catalog.varbin_text_concat(varbinary,text); DROP FUNCTION pg_catalog.varbin_bool_concat(varbinary,boolean); DROP FUNCTION pg_catalog.varbin_bin_concat(varbinary,binary); DROP FUNCTION pg_catalog.int_varbin_concat(uint8,varbinary); DROP FUNCTION pg_catalog.int8_varbin_concat(int8,varbinary); DROP FUNCTION pg_catalog.float4_varbin_concat(float4,varbinary); DROP FUNCTION pg_catalog.float8_varbin_concat(float8,varbinary); DROP FUNCTION pg_catalog.num_varbin_concat(numeric,varbinary); DROP FUNCTION pg_catalog.bit_varbin_concat(bit,varbinary); DROP FUNCTION pg_catalog.text_varbin_concat(text,varbinary); DROP FUNCTION pg_catalog.bool_varbin_concat(boolean,varbinary); DROP FUNCTION pg_catalog.bin_varbin_concat(binary,varbinary); DROP FUNCTION IF EXISTS pg_catalog.unknown_concat(unknown, unknown); DROP FUNCTION IF EXISTS pg_catalog.unknown_int_concat(unknown, integer); DROP FUNCTION IF EXISTS pg_catalog.int_unknown_concat(integer, unknown); DROP FUNCTION IF EXISTS pg_catalog.left(bit, integer); DROP FUNCTION IF EXISTS pg_catalog.left(blob, integer); DROP FUNCTION IF EXISTS pg_catalog.left(boolean, integer); DROP FUNCTION IF EXISTS pg_catalog.lower(boolean); DROP FUNCTION IF EXISTS pg_catalog.lower(bit); DROP FUNCTION IF EXISTS pg_catalog.lower(tinyblob); DROP FUNCTION IF EXISTS pg_catalog.lower(blob); DROP FUNCTION IF EXISTS pg_catalog.lower(mediumblob); DROP FUNCTION IF EXISTS pg_catalog.lower(longblob); DROP FUNCTION IF EXISTS pg_catalog.lower(binary); DROP FUNCTION IF EXISTS pg_catalog.lower(varbinary); DROP FUNCTION IF EXISTS pg_catalog.lower(integer); DROP FUNCTION IF EXISTS pg_catalog.lower(float); DROP FUNCTION IF EXISTS pg_catalog.lower(char); DROP FUNCTION IF EXISTS pg_catalog.lower(varchar); DROP FUNCTION IF EXISTS pg_catalog.lcase(boolean); DROP FUNCTION IF EXISTS pg_catalog.lcase(tinyblob); DROP FUNCTION IF EXISTS pg_catalog.lcase(blob); DROP FUNCTION IF EXISTS pg_catalog.lcase(mediumblob); DROP FUNCTION IF EXISTS pg_catalog.lcase(longblob); DROP FUNCTION IF EXISTS pg_catalog.lcase(bit); DROP FUNCTION IF EXISTS pg_catalog.lcase(binary); DROP FUNCTION IF EXISTS pg_catalog.lcase(varbinary); DROP FUNCTION IF EXISTS pg_catalog.lcase(integer); DROP FUNCTION IF EXISTS pg_catalog.lcase(float); DROP FUNCTION IF EXISTS pg_catalog.lcase(char); DROP FUNCTION IF EXISTS pg_catalog.lcase(varchar); DROP OPERATOR IF EXISTS pg_catalog.=(int, uint2); DROP FUNCTION IF EXISTS pg_catalog.int_uint2_eq(int, uint2); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, json); DROP FUNCTION IF EXISTS pg_catalog.json_eq(tinyblob, json); DROP OPERATOR IF EXISTS pg_catalog.=(blob, json); DROP FUNCTION IF EXISTS pg_catalog.json_eq(blob, json); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, json); DROP FUNCTION IF EXISTS pg_catalog.json_eq(mediumblob, json); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, json); DROP FUNCTION IF EXISTS pg_catalog.json_eq(longblob, json); DROP OPERATOR IF EXISTS pg_catalog.=(anyenum, json); DROP FUNCTION IF EXISTS pg_catalog.json_eq(anyenum, json); DROP FUNCTION IF EXISTS pg_catalog.hex(anyenum); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.=(numeric, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.<>(numeric, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.<(numeric, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.<=(numeric, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.>(numeric, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.>=(numeric, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_numeric_eq(tinyblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_tinyblob_eq(numeric, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_numeric_ne(tinyblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_tinyblob_ne(numeric, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_numeric_lt(tinyblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_tinyblob_lt(numeric, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_numeric_le(tinyblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_tinyblob_le(numeric, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_numeric_gt(tinyblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_tinyblob_gt(numeric, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_numeric_ge(tinyblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_tinyblob_ge(numeric, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_numeric_cmp(tinyblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_tinyblob_cmp(numeric, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(blob, numeric); DROP OPERATOR IF EXISTS pg_catalog.=(numeric, blob); DROP OPERATOR IF EXISTS pg_catalog.<>(blob, numeric); DROP OPERATOR IF EXISTS pg_catalog.<>(numeric, blob); DROP OPERATOR IF EXISTS pg_catalog.<(blob, numeric); DROP OPERATOR IF EXISTS pg_catalog.<(numeric, blob); DROP OPERATOR IF EXISTS pg_catalog.<=(blob, numeric); DROP OPERATOR IF EXISTS pg_catalog.<=(numeric, blob); DROP OPERATOR IF EXISTS pg_catalog.>(blob, numeric); DROP OPERATOR IF EXISTS pg_catalog.>(numeric, blob); DROP OPERATOR IF EXISTS pg_catalog.>=(blob, numeric); DROP OPERATOR IF EXISTS pg_catalog.>=(numeric, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_numeric_eq(blob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_blob_eq(numeric, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_numeric_ne(blob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_blob_ne(numeric, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_numeric_lt(blob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_blob_lt(numeric, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_numeric_le(blob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_blob_le(numeric, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_numeric_gt(blob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_blob_gt(numeric, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_numeric_ge(blob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_blob_ge(numeric, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_numeric_cmp(blob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_blob_cmp(numeric, blob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.=(numeric, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.<>(numeric, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.<(numeric, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.<=(numeric, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.>(numeric, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.>=(numeric, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_numeric_eq(mediumblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_mediumblob_eq(numeric, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_numeric_ne(mediumblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_mediumblob_ne(numeric, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_numeric_lt(mediumblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_mediumblob_lt(numeric, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_numeric_le(mediumblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_mediumblob_le(numeric, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_numeric_gt(mediumblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_mediumblob_gt(numeric, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_numeric_ge(mediumblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_mediumblob_ge(numeric, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_numeric_cmp(mediumblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_mediumblob_cmp(numeric, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.=(numeric, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.<>(numeric, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.<(numeric, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.<=(numeric, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.>(numeric, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, numeric); DROP OPERATOR IF EXISTS pg_catalog.>=(numeric, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_numeric_eq(longblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_longblob_eq(numeric, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_numeric_ne(longblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_longblob_ne(numeric, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_numeric_lt(longblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_longblob_lt(numeric, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_numeric_le(longblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_longblob_le(numeric, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_numeric_gt(longblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_longblob_gt(numeric, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_numeric_ge(longblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_longblob_ge(numeric, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_numeric_cmp(longblob, numeric); DROP FUNCTION IF EXISTS pg_catalog.numeric_longblob_cmp(numeric, longblob); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, int8); DROP OPERATOR IF EXISTS pg_catalog.=(int8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, int8); DROP OPERATOR IF EXISTS pg_catalog.<>(int8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, int8); DROP OPERATOR IF EXISTS pg_catalog.<(int8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, int8); DROP OPERATOR IF EXISTS pg_catalog.<=(int8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, int8); DROP OPERATOR IF EXISTS pg_catalog.>(int8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, int8); DROP OPERATOR IF EXISTS pg_catalog.>=(int8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_int8_eq(tinyblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_tinyblob_eq(int8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_int8_ne(tinyblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_tinyblob_ne(int8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_int8_lt(tinyblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_tinyblob_lt(int8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_int8_le(tinyblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_tinyblob_le(int8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_int8_gt(tinyblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_tinyblob_gt(int8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_int8_ge(tinyblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_tinyblob_ge(int8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_int8_cmp(tinyblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_tinyblob_cmp(int8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(blob, int8); DROP OPERATOR IF EXISTS pg_catalog.=(int8, blob); DROP OPERATOR IF EXISTS pg_catalog.<>(blob, int8); DROP OPERATOR IF EXISTS pg_catalog.<>(int8, blob); DROP OPERATOR IF EXISTS pg_catalog.<(blob, int8); DROP OPERATOR IF EXISTS pg_catalog.<(int8, blob); DROP OPERATOR IF EXISTS pg_catalog.<=(blob, int8); DROP OPERATOR IF EXISTS pg_catalog.<=(int8, blob); DROP OPERATOR IF EXISTS pg_catalog.>(blob, int8); DROP OPERATOR IF EXISTS pg_catalog.>(int8, blob); DROP OPERATOR IF EXISTS pg_catalog.>=(blob, int8); DROP OPERATOR IF EXISTS pg_catalog.>=(int8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_int8_eq(blob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_blob_eq(int8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_int8_ne(blob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_blob_ne(int8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_int8_lt(blob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_blob_lt(int8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_int8_le(blob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_blob_le(int8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_int8_gt(blob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_blob_gt(int8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_int8_ge(blob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_blob_ge(int8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_int8_cmp(blob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_blob_cmp(int8, blob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, int8); DROP OPERATOR IF EXISTS pg_catalog.=(int8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, int8); DROP OPERATOR IF EXISTS pg_catalog.<>(int8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, int8); DROP OPERATOR IF EXISTS pg_catalog.<(int8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, int8); DROP OPERATOR IF EXISTS pg_catalog.<=(int8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, int8); DROP OPERATOR IF EXISTS pg_catalog.>(int8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, int8); DROP OPERATOR IF EXISTS pg_catalog.>=(int8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_int8_eq(mediumblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_mediumblob_eq(int8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_int8_ne(mediumblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_mediumblob_ne(int8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_int8_lt(mediumblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_mediumblob_lt(int8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_int8_le(mediumblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_mediumblob_le(int8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_int8_gt(mediumblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_mediumblob_gt(int8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_int8_ge(mediumblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_mediumblob_ge(int8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_int8_cmp(mediumblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_mediumblob_cmp(int8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, int8); DROP OPERATOR IF EXISTS pg_catalog.=(int8, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, int8); DROP OPERATOR IF EXISTS pg_catalog.<>(int8, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, int8); DROP OPERATOR IF EXISTS pg_catalog.<(int8, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, int8); DROP OPERATOR IF EXISTS pg_catalog.<=(int8, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, int8); DROP OPERATOR IF EXISTS pg_catalog.>(int8, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, int8); DROP OPERATOR IF EXISTS pg_catalog.>=(int8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_int8_eq(longblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_longblob_eq(int8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_int8_ne(longblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_longblob_ne(int8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_int8_lt(longblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_longblob_lt(int8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_int8_le(longblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_longblob_le(int8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_int8_gt(longblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_longblob_gt(int8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_int8_ge(longblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_longblob_ge(int8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_int8_cmp(longblob, int8); DROP FUNCTION IF EXISTS pg_catalog.int8_longblob_cmp(int8, longblob); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.=(uint8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.<>(uint8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.<(uint8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.<=(uint8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.>(uint8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.>=(uint8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_uint8_eq(tinyblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_tinyblob_eq(uint8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_uint8_ne(tinyblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_tinyblob_ne(uint8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_uint8_lt(tinyblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_tinyblob_lt(uint8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_uint8_le(tinyblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_tinyblob_le(uint8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_uint8_gt(tinyblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_tinyblob_gt(uint8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_uint8_ge(tinyblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_tinyblob_ge(uint8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_uint8_cmp(tinyblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_tinyblob_cmp(uint8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(blob, uint8); DROP OPERATOR IF EXISTS pg_catalog.=(uint8, blob); DROP OPERATOR IF EXISTS pg_catalog.<>(blob, uint8); DROP OPERATOR IF EXISTS pg_catalog.<>(uint8, blob); DROP OPERATOR IF EXISTS pg_catalog.<(blob, uint8); DROP OPERATOR IF EXISTS pg_catalog.<(uint8, blob); DROP OPERATOR IF EXISTS pg_catalog.<=(blob, uint8); DROP OPERATOR IF EXISTS pg_catalog.<=(uint8, blob); DROP OPERATOR IF EXISTS pg_catalog.>(blob, uint8); DROP OPERATOR IF EXISTS pg_catalog.>(uint8, blob); DROP OPERATOR IF EXISTS pg_catalog.>=(blob, uint8); DROP OPERATOR IF EXISTS pg_catalog.>=(uint8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_uint8_eq(blob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_blob_eq(uint8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_uint8_ne(blob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_blob_ne(uint8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_uint8_lt(blob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_blob_lt(uint8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_uint8_le(blob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_blob_le(uint8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_uint8_gt(blob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_blob_gt(uint8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_uint8_ge(blob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_blob_ge(uint8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_uint8_cmp(blob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_blob_cmp(uint8, blob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.=(uint8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.<>(uint8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.<(uint8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.<=(uint8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.>(uint8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.>=(uint8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_uint8_eq(mediumblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_mediumblob_eq(uint8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_uint8_ne(mediumblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_mediumblob_ne(uint8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_uint8_lt(mediumblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_mediumblob_lt(uint8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_uint8_le(mediumblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_mediumblob_le(uint8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_uint8_gt(mediumblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_mediumblob_gt(uint8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_uint8_ge(mediumblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_mediumblob_ge(uint8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_uint8_cmp(mediumblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_mediumblob_cmp(uint8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.=(uint8, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.<>(uint8, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.<(uint8, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.<=(uint8, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.>(uint8, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, uint8); DROP OPERATOR IF EXISTS pg_catalog.>=(uint8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_uint8_eq(longblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_longblob_eq(uint8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_uint8_ne(longblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_longblob_ne(uint8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_uint8_lt(longblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_longblob_lt(uint8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_uint8_le(longblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_longblob_le(uint8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_uint8_gt(longblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_longblob_gt(uint8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_uint8_ge(longblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_longblob_ge(uint8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_uint8_cmp(longblob, uint8); DROP FUNCTION IF EXISTS pg_catalog.uint8_longblob_cmp(uint8, longblob); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, float8); DROP OPERATOR IF EXISTS pg_catalog.=(float8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, float8); DROP OPERATOR IF EXISTS pg_catalog.<>(float8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, float8); DROP OPERATOR IF EXISTS pg_catalog.<(float8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, float8); DROP OPERATOR IF EXISTS pg_catalog.<=(float8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, float8); DROP OPERATOR IF EXISTS pg_catalog.>(float8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, float8); DROP OPERATOR IF EXISTS pg_catalog.>=(float8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_float8_eq(tinyblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_tinyblob_eq(float8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_float8_ne(tinyblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_tinyblob_ne(float8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_float8_lt(tinyblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_tinyblob_lt(float8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_float8_le(tinyblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_tinyblob_le(float8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_float8_gt(tinyblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_tinyblob_gt(float8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_float8_ge(tinyblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_tinyblob_ge(float8, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_float8_cmp(tinyblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_tinyblob_cmp(float8, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(blob, float8); DROP OPERATOR IF EXISTS pg_catalog.=(float8, blob); DROP OPERATOR IF EXISTS pg_catalog.<>(blob, float8); DROP OPERATOR IF EXISTS pg_catalog.<>(float8, blob); DROP OPERATOR IF EXISTS pg_catalog.<(blob, float8); DROP OPERATOR IF EXISTS pg_catalog.<(float8, blob); DROP OPERATOR IF EXISTS pg_catalog.<=(blob, float8); DROP OPERATOR IF EXISTS pg_catalog.<=(float8, blob); DROP OPERATOR IF EXISTS pg_catalog.>(blob, float8); DROP OPERATOR IF EXISTS pg_catalog.>(float8, blob); DROP OPERATOR IF EXISTS pg_catalog.>=(blob, float8); DROP OPERATOR IF EXISTS pg_catalog.>=(float8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_float8_eq(blob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_blob_eq(float8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_float8_ne(blob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_blob_ne(float8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_float8_lt(blob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_blob_lt(float8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_float8_le(blob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_blob_le(float8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_float8_gt(blob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_blob_gt(float8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_float8_ge(blob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_blob_ge(float8, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_float8_cmp(blob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_blob_cmp(float8, blob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, float8); DROP OPERATOR IF EXISTS pg_catalog.=(float8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, float8); DROP OPERATOR IF EXISTS pg_catalog.<>(float8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, float8); DROP OPERATOR IF EXISTS pg_catalog.<(float8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, float8); DROP OPERATOR IF EXISTS pg_catalog.<=(float8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, float8); DROP OPERATOR IF EXISTS pg_catalog.>(float8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, float8); DROP OPERATOR IF EXISTS pg_catalog.>=(float8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_float8_eq(mediumblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_mediumblob_eq(float8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_float8_ne(mediumblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_mediumblob_ne(float8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_float8_lt(mediumblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_mediumblob_lt(float8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_float8_le(mediumblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_mediumblob_le(float8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_float8_gt(mediumblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_mediumblob_gt(float8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_float8_ge(mediumblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_mediumblob_ge(float8, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_float8_cmp(mediumblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_mediumblob_cmp(float8, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, float8); DROP OPERATOR IF EXISTS pg_catalog.=(float8, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, float8); DROP OPERATOR IF EXISTS pg_catalog.<>(float8, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, float8); DROP OPERATOR IF EXISTS pg_catalog.<(float8, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, float8); DROP OPERATOR IF EXISTS pg_catalog.<=(float8, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, float8); DROP OPERATOR IF EXISTS pg_catalog.>(float8, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, float8); DROP OPERATOR IF EXISTS pg_catalog.>=(float8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_float8_eq(longblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_longblob_eq(float8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_float8_ne(longblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_longblob_ne(float8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_float8_lt(longblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_longblob_lt(float8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_float8_le(longblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_longblob_le(float8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_float8_gt(longblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_longblob_gt(float8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_float8_ge(longblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_longblob_ge(float8, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_float8_cmp(longblob, float8); DROP FUNCTION IF EXISTS pg_catalog.float8_longblob_cmp(float8, longblob); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.=(timestamp without time zone, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamp without time zone, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<(timestamp without time zone, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamp without time zone, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.>(timestamp without time zone, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamp without time zone, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_datetime_eq(tinyblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_tinyblob_eq(timestamp without time zone, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_datetime_ne(tinyblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_tinyblob_ne(timestamp without time zone, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_datetime_lt(tinyblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_tinyblob_lt(timestamp without time zone, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_datetime_le(tinyblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_tinyblob_le(timestamp without time zone, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_datetime_gt(tinyblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_tinyblob_gt(timestamp without time zone, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_datetime_ge(tinyblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_tinyblob_ge(timestamp without time zone, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_datetime_cmp(tinyblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_tinyblob_cmp(timestamp without time zone, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(blob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.=(timestamp without time zone, blob); DROP OPERATOR IF EXISTS pg_catalog.<>(blob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamp without time zone, blob); DROP OPERATOR IF EXISTS pg_catalog.<(blob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<(timestamp without time zone, blob); DROP OPERATOR IF EXISTS pg_catalog.<=(blob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamp without time zone, blob); DROP OPERATOR IF EXISTS pg_catalog.>(blob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.>(timestamp without time zone, blob); DROP OPERATOR IF EXISTS pg_catalog.>=(blob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamp without time zone, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_datetime_eq(blob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_blob_eq(timestamp without time zone, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_datetime_ne(blob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_blob_ne(timestamp without time zone, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_datetime_lt(blob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_blob_lt(timestamp without time zone, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_datetime_le(blob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_blob_le(timestamp without time zone, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_datetime_gt(blob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_blob_gt(timestamp without time zone, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_datetime_ge(blob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_blob_ge(timestamp without time zone, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_datetime_cmp(blob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_blob_cmp(timestamp without time zone, blob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.=(timestamp without time zone, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamp without time zone, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<(timestamp without time zone, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamp without time zone, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.>(timestamp without time zone, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamp without time zone, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_datetime_eq(mediumblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_mediumblob_eq(timestamp without time zone, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_datetime_ne(mediumblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_mediumblob_ne(timestamp without time zone, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_datetime_lt(mediumblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_mediumblob_lt(timestamp without time zone, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_datetime_le(mediumblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_mediumblob_le(timestamp without time zone, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_datetime_gt(mediumblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_mediumblob_gt(timestamp without time zone, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_datetime_ge(mediumblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_mediumblob_ge(timestamp without time zone, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_datetime_cmp(mediumblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_mediumblob_cmp(timestamp without time zone, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.=(timestamp without time zone, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamp without time zone, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<(timestamp without time zone, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamp without time zone, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.>(timestamp without time zone, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, timestamp without time zone); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamp without time zone, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_datetime_eq(longblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_longblob_eq(timestamp without time zone, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_datetime_ne(longblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_longblob_ne(timestamp without time zone, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_datetime_lt(longblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_longblob_lt(timestamp without time zone, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_datetime_le(longblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_longblob_le(timestamp without time zone, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_datetime_gt(longblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_longblob_gt(timestamp without time zone, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_datetime_ge(longblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_longblob_ge(timestamp without time zone, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_datetime_cmp(longblob, timestamp without time zone); DROP FUNCTION IF EXISTS pg_catalog.datetime_longblob_cmp(timestamp without time zone, longblob); DROP OPERATOR IF EXISTS pg_catalog.=(tinyblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.=(timestamptz, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<>(tinyblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamptz, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<(tinyblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.<(timestamptz, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.<=(tinyblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamptz, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>(tinyblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.>(timestamptz, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.>=(tinyblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamptz, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_timestamp_eq(tinyblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_tinyblob_eq(timestamptz, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_timestamp_ne(tinyblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_tinyblob_ne(timestamptz, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_timestamp_lt(tinyblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_tinyblob_lt(timestamptz, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_timestamp_le(tinyblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_tinyblob_le(timestamptz, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_timestamp_gt(tinyblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_tinyblob_gt(timestamptz, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_timestamp_ge(tinyblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_tinyblob_ge(timestamptz, tinyblob); DROP FUNCTION IF EXISTS pg_catalog.tinyblob_timestamp_cmp(tinyblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_tinyblob_cmp(timestamptz, tinyblob); DROP OPERATOR IF EXISTS pg_catalog.=(blob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.=(timestamptz, blob); DROP OPERATOR IF EXISTS pg_catalog.<>(blob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamptz, blob); DROP OPERATOR IF EXISTS pg_catalog.<(blob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.<(timestamptz, blob); DROP OPERATOR IF EXISTS pg_catalog.<=(blob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamptz, blob); DROP OPERATOR IF EXISTS pg_catalog.>(blob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.>(timestamptz, blob); DROP OPERATOR IF EXISTS pg_catalog.>=(blob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamptz, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_timestamp_eq(blob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_blob_eq(timestamptz, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_timestamp_ne(blob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_blob_ne(timestamptz, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_timestamp_lt(blob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_blob_lt(timestamptz, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_timestamp_le(blob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_blob_le(timestamptz, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_timestamp_gt(blob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_blob_gt(timestamptz, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_timestamp_ge(blob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_blob_ge(timestamptz, blob); DROP FUNCTION IF EXISTS pg_catalog.blob_timestamp_cmp(blob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_blob_cmp(timestamptz, blob); DROP OPERATOR IF EXISTS pg_catalog.=(mediumblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.=(timestamptz, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<>(mediumblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamptz, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<(mediumblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.<(timestamptz, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.<=(mediumblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamptz, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>(mediumblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.>(timestamptz, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.>=(mediumblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamptz, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_timestamp_eq(mediumblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_mediumblob_eq(timestamptz, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_timestamp_ne(mediumblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_mediumblob_ne(timestamptz, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_timestamp_lt(mediumblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_mediumblob_lt(timestamptz, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_timestamp_le(mediumblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_mediumblob_le(timestamptz, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_timestamp_gt(mediumblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_mediumblob_gt(timestamptz, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_timestamp_ge(mediumblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_mediumblob_ge(timestamptz, mediumblob); DROP FUNCTION IF EXISTS pg_catalog.mediumblob_timestamp_cmp(mediumblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_mediumblob_cmp(timestamptz, mediumblob); DROP OPERATOR IF EXISTS pg_catalog.=(longblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.=(timestamptz, longblob); DROP OPERATOR IF EXISTS pg_catalog.<>(longblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.<>(timestamptz, longblob); DROP OPERATOR IF EXISTS pg_catalog.<(longblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.<(timestamptz, longblob); DROP OPERATOR IF EXISTS pg_catalog.<=(longblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.<=(timestamptz, longblob); DROP OPERATOR IF EXISTS pg_catalog.>(longblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.>(timestamptz, longblob); DROP OPERATOR IF EXISTS pg_catalog.>=(longblob, timestamptz); DROP OPERATOR IF EXISTS pg_catalog.>=(timestamptz, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_timestamp_eq(longblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_longblob_eq(timestamptz, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_timestamp_ne(longblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_longblob_ne(timestamptz, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_timestamp_lt(longblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_longblob_lt(timestamptz, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_timestamp_le(longblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_longblob_le(timestamptz, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_timestamp_gt(longblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_longblob_gt(timestamptz, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_timestamp_ge(longblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_longblob_ge(timestamptz, longblob); DROP FUNCTION IF EXISTS pg_catalog.longblob_timestamp_cmp(longblob, timestamptz); DROP FUNCTION IF EXISTS pg_catalog.timestamp_longblob_cmp(timestamptz, longblob); DROP AGGREGATE IF EXISTS pg_catalog.stddev_pop(json); DROP AGGREGATE IF EXISTS pg_catalog.var_pop(json); DROP FUNCTION IF EXISTS pg_catalog.any_accum(numeric[], anyelement); DROP FUNCTION IF EXISTS pg_catalog.upper(int8); DROP FUNCTION IF EXISTS pg_catalog.upper(numeric); DROP FUNCTION IF EXISTS pg_catalog.upper(date); DROP FUNCTION IF EXISTS pg_catalog.upper(time); DROP FUNCTION IF EXISTS pg_catalog.upper(timestamp(0) without time zone); DROP FUNCTION IF EXISTS pg_catalog.upper(timestamp(0) with time zone); DROP FUNCTION IF EXISTS pg_catalog.upper(bit); DROP FUNCTION IF EXISTS pg_catalog.upper(boolean); DROP FUNCTION IF EXISTS pg_catalog.upper(year); DROP FUNCTION IF EXISTS pg_catalog.upper(char); DROP FUNCTION IF EXISTS pg_catalog.upper(varchar); DROP FUNCTION IF EXISTS pg_catalog.upper(tinyblob); DROP FUNCTION IF EXISTS pg_catalog.upper(binary); DROP FUNCTION IF EXISTS pg_catalog.upper(varbinary); DROP FUNCTION IF EXISTS pg_catalog.upper(blob); DROP FUNCTION IF EXISTS pg_catalog.upper(mediumblob); DROP FUNCTION IF EXISTS pg_catalog.upper(longblob); DROP FUNCTION IF EXISTS pg_catalog.upper(anyenum); DROP FUNCTION IF EXISTS pg_catalog.upper(anyset); DROP FUNCTION IF EXISTS pg_catalog.upper(json);