\echo Use "CREATE EXTENSION dolphin" to load this file. \quit
CREATE FUNCTION pg_catalog.dolphin_invoke()
    RETURNS VOID AS '$libdir/dolphin','dolphin_invoke' LANGUAGE C STRICT;

CREATE FUNCTION pg_catalog.dolphin_version()
    RETURNS text AS '$libdir/dolphin','dolphin_version' LANGUAGE C IMMUTABLE STRICT;

CREATE OR REPLACE FUNCTION pg_catalog.curdate()
returns date
as
$$
begin
    return (select current_date);
end;
$$
language plpgsql; 

-- create or replace type cast
CREATE OR REPLACE FUNCTION pg_catalog.bool_text(a bool)
returns text
as
$$
begin
  IF a is null then 
    return null;
  else
    if a = true then
      return '1';
    else 
      return '0';
    end if;
  end if;
end;
$$
language plpgsql;

-- create some functions for operator
CREATE OR REPLACE FUNCTION pg_catalog.b_mod(a numeric, b numeric)
returns numeric
as
$$
begin
  IF b = 0 then
    return null;
  else
    return (select a % b);
  end if;
end;
$$
language plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.regexp(a text, b text)
returns integer
as 
$$
begin
  if b = '' then
    raise 'invalid regular expression';
  else
    return (select lower(a) ~ lower(b))::integer;
  end if;
end;
$$
language plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.regexp(a text, b boolean)
returns integer
as 
$$
begin
  if b = true then
    return 1;
  elsif b = false then
    return 0;
  else
    raise 'invalid regular expression';
  end if;
end;
$$
language plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.not_regexp(a text, b text)
returns integer
as
$$
begin
  if b = '' then
    raise 'invalid regular expression';
  else
    return (select lower(a) !~ lower(b))::integer;
  end if;
end;
$$
language plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.not_regexp(a text, b boolean)
returns integer
as 
$$
begin
  if b = true then
    return 0;
  elsif b = false then
    return 1;
  else
    raise 'invalid regular expression';
  end if;
end;
$$
language plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.rlike(a text, b text)
returns integer
as
$$
begin
  if b = '' then
    raise 'invalid regular expression';
  else
    return (select lower(a) ~ lower(b))::integer;
  end if;
end;
$$
language plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.rlike(a text, b boolean)
returns integer
as 
$$
begin
  if b = true then
    return 1;
  elsif b = false then
    return b::Integer;
  else
    raise 'invalid regular expression';
  end if;
end;
$$
language plpgsql;

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;

CREATE OR REPLACE FUNCTION pg_catalog.locate(t1 text, t2 text)
returns integer
as 
$$
begin
   return (select position(t2 in t1))::integer;
end;
$$
language plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.locate(t1 text, t2 boolean)
returns integer
as 
$$
begin
   return 0;
end;
$$
language plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.locate(t1 text, t2 text, t3 integer)
returns integer
as 
$$
begin
  if t3 < 0 then
    return 0;
  else 
    return (select instr(t1, t2, t3));
  end if;
end;
$$
language plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.lcase(t1 text)
returns text
as 
$$
begin
   return (select lower(t1))::text;
end;
$$
language plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.ucase(t1 text)
returns text
as 
$$
begin
   return (select upper(t1))::text;
end;
$$
language plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.rand()
returns double precision       
as 
$$
begin
   return (select random());
end;
$$
language plpgsql;

CREATE OR REPLACE FUNCTION PG_CATALOG.truncate(t1 numeric, t2 integer)
returns numeric
as 
$$
begin
  return (select trunc(t1, t2));
end;
$$
language plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.varchar_int1(varchar) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.varchar_int2(varchar) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bpchar_int1(char) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bpchar_int2(char) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bpchar_text(bpchar) CASCADE;

CREATE FUNCTION pg_catalog.varchar_int1 (
varchar
) RETURNS tinyint LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varchar_int1';

CREATE FUNCTION pg_catalog.varchar_int2 (
varchar
) RETURNS smallint LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varchar_int2';

CREATE FUNCTION pg_catalog.bpchar_int1 (
char
) RETURNS tinyint LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bpchar_int1';

CREATE FUNCTION pg_catalog.bpchar_int2 (
char
) RETURNS smallint LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bpchar_int2';

CREATE FUNCTION pg_catalog.bpchar_text (
bpchar
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bpchar_text';

CREATE CAST (varchar AS tinyint) WITH FUNCTION varchar_int1(varchar) AS IMPLICIT;
CREATE CAST (char AS tinyint) WITH FUNCTION bpchar_int1(char) AS IMPLICIT;
CREATE CAST (varchar AS smallint) WITH FUNCTION varchar_int2(varchar) AS IMPLICIT;
CREATE CAST (char AS smallint) WITH FUNCTION bpchar_int2(char) AS IMPLICIT;
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
$$;

create or replace function pg_catalog.get_index_columns(OUT namespace name, OUT indexrelid oid, OUT indrelid oid, OUT indisunique bool, OUT indisusable bool, OUT seq_in_index int2, OUT attrnum int2, OUT collation int2) returns setof record
as $$
declare
query_str text;
item int2;
row_data record;
begin
query_str := 'select n.nspname, i.indexrelid, i.indrelid, i.indisunique, i.indisusable, i.indkey, i.indoption, i.indnkeyatts
              from pg_catalog.pg_index i
                left join pg_class c on c.oid = i.indexrelid
                left join pg_catalog.pg_namespace n on n.oid = c.relnamespace
              where n.nspname <> ''pg_catalog''
                and n.nspname <> ''db4ai''
                and n.nspname <> ''information_schema''
                and n.nspname !~ ''^pg_toast''';
for row_data in EXECUTE(query_str) LOOP
    for item in 0..row_data.indnkeyatts - 1 loop
        namespace := row_data.nspname;
        indexrelid := row_data.indexrelid;
        indrelid := row_data.indrelid;
        indisunique := row_data.indisunique;
        indisusable := row_data.indisusable;
        seq_in_index := item + 1;
        attrnum := row_data.indkey[item];
        collation := row_data.indoption[item];
        return next;
    end loop;
end loop;
end; $$
LANGUAGE 'plpgsql';

create view public.index_statistic as
select
  i.namespace as "namespace",
  (select relname from pg_class tc where tc.oid = i.indrelid) as "table",
  not i.indisunique as "non_unique",
  c.relname as "key_name",
  i.seq_in_index as "seq_in_index",
  a.attname as "column_name",
  (case when m.amcanorder
    then (
      case when i.collation & 1 then 'D' else 'A' END
    ) else null end
  ) as "collation",
  (select
      (case when ts.stadistinct = 0
        then NULL else (
          case when ts.stadistinct > 0 then ts.stadistinct else ts.stadistinct * tc.reltuples * -1 end
        ) end
      ) 
    from pg_class tc
      left join pg_statistic ts on tc.oid = ts.starelid
    where
      tc.oid = i.indrelid
      and ts.staattnum = i.attrnum
  ) as "cardinality",
  null as "sub_part",
  null as "packed",
  (case when a.attnotnull then '' else 'YES' end) as "null",
  m.amname as "index_type",
  (case when i.indisusable then '' else 'disabled' end) as "comment",
  (select description from pg_description where objoid = i.indexrelid) as "index_comment"
from
  (select * from get_index_columns()) i
  left join pg_class c on c.oid = i.indexrelid
  left join pg_attribute a on a.attrelid = i.indrelid
  and a.attnum = i.attrnum
  left join pg_am m on m.oid = c.relam
order by
  c.relname;

REVOKE ALL ON public.index_statistic FROM PUBLIC;
GRANT SELECT, REFERENCES ON public.index_statistic TO PUBLIC;

DROP FUNCTION IF EXISTS pg_catalog.rebuild_partition(text[]) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.remove_partitioning(text) CASCADE;

CREATE FUNCTION pg_catalog.remove_partitioning (
text
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'RemovePartitioning';

CREATE FUNCTION pg_catalog.rebuild_partition(text[])
RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'RebuildPartition';

CREATE FUNCTION pg_catalog.analyze_partition(text[],text,text)
RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'AnalyzePartitions';

CREATE OR REPLACE FUNCTION pg_catalog.analyze_tables (
IN tableName cstring[], OUT "Table" text, OUT "Op" text, OUT "Msg_type" text, OUT "Msg_text" text
) RETURNS setof record LANGUAGE C VOLATILE STRICT as '$libdir/dolphin',  'analyze_tables';


DROP FUNCTION IF EXISTS pg_catalog.bigint_any_value (bigint, bigint) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bigint_any_value (bigint, bigint) RETURNS bigint LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bigint_any_value';

drop aggregate if exists pg_catalog.any_value(bigint);
CREATE AGGREGATE pg_catalog.any_value(bigint) (
        sfunc = bigint_any_value,
        stype = int8
);

DROP FUNCTION IF EXISTS pg_catalog.numeric_any_value (numeric, numeric) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.numeric_any_value (numeric, numeric) RETURNS numeric LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_any_value';

drop aggregate if exists pg_catalog.any_value(numeric);
CREATE AGGREGATE pg_catalog.any_value(numeric) (
        sfunc = numeric_any_value,
        stype = numeric
);

DROP FUNCTION IF EXISTS pg_catalog.double_any_value (double precision, double precision) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.double_any_value (double precision, double precision) RETURNS double precision LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'double_any_value';

drop aggregate if exists pg_catalog.any_value(double precision);
CREATE AGGREGATE pg_catalog.any_value(double precision) (
        sfunc = double_any_value,
        stype = double precision
);

DROP FUNCTION IF EXISTS pg_catalog.float_any_value (float4, float4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.float_any_value (float4, float4) RETURNS float4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float_any_value';

drop aggregate if exists pg_catalog.any_value(float4);
CREATE AGGREGATE pg_catalog.any_value(float4) (
        sfunc = float_any_value,
        stype = float4
);

DROP FUNCTION IF EXISTS pg_catalog.text_any_value (text, text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.text_any_value (text, text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'text_any_value';

drop aggregate if exists pg_catalog.any_value(text);
CREATE AGGREGATE pg_catalog.any_value(text) (
        sfunc = text_any_value,
        stype = text
);

DROP FUNCTION IF EXISTS pg_catalog.bytea_any_value (bytea, bytea) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bytea_any_value (bytea, bytea) RETURNS bytea LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bytea_any_value';

drop aggregate if exists pg_catalog.any_value(bytea);
CREATE AGGREGATE pg_catalog.any_value(bytea) (
        sfunc = bytea_any_value,
        stype = bytea
);

DROP FUNCTION IF EXISTS pg_catalog.blob_any_value (blob, blob) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.blob_any_value (blob, blob) RETURNS blob LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'blob_any_value';

drop aggregate if exists pg_catalog.any_value(blob);
CREATE AGGREGATE pg_catalog.any_value(blob) (
        sfunc = blob_any_value,
        stype = blob
);

DROP FUNCTION IF EXISTS  pg_catalog.dolphin_attname_eq(name, name) CASCADE;
CREATE FUNCTION pg_catalog.dolphin_attname_eq(name, name) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_attname_eq';
DROP FUNCTION IF EXISTS pg_catalog.bit_count(numeric) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bit_count (numeric)  RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_numeric';
DROP FUNCTION IF EXISTS pg_catalog.bit_count(text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bit_count (text)  RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_text';
DROP FUNCTION IF EXISTS pg_catalog.bit_count_bit(text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bit_count_bit (text) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_bit';
DROP FUNCTION IF EXISTS pg_catalog.bit_count(bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bit_count (bit) RETURNS int8 AS $$ SELECT pg_catalog.bit_count_bit(cast($1 as text)) $$ LANGUAGE SQL;

-- support bit_xor aggregate for varbit

DROP FUNCTION IF EXISTS pg_catalog.varbit_bit_xor_transfn(varbit, varbit) CASCADE;
CREATE FUNCTION pg_catalog.varbit_bit_xor_transfn (
t1 varbit ,t2 varbit
) RETURNS varbit AS
$$
BEGIN
    IF t1 is null THEN
        RETURN t2;
    ELSEIF t2 is null THEN
        RETURN t1;
    ELSE
        RETURN (SELECT bitxor(t1, t2));
    END IF;
END;
$$
LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.varbit_bit_xor_finalfn(varbit) CASCADE;
CREATE FUNCTION pg_catalog.varbit_bit_xor_finalfn (
t varbit
) RETURNS int8 AS
$$
BEGIN
    IF t is null THEN
        RETURN 0;
    ELSE
        RETURN (SELECT int8(t));
    END IF;
END;
$$
LANGUAGE plpgsql;

drop aggregate if exists pg_catalog.bit_xor(varbit);
create aggregate pg_catalog.bit_xor(varbit) (SFUNC=varbit_bit_xor_transfn, finalfunc = varbit_bit_xor_finalfn ,STYPE= varbit);
DROP FUNCTION IF EXISTS pg_catalog.bin(bit) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.bin(bit) returns text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bin_bit';
DROP FUNCTION IF EXISTS pg_catalog.bin(text) cascade;
DROP FUNCTION IF EXISTS pg_catalog.bin(numeric) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.bin(text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bin_string';
CREATE OR REPLACE FUNCTION pg_catalog.bin(numeric) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bin_integer';

DROP FUNCTION IF EXISTS pg_catalog.elt(text, variadic arr "any") cascade;
DROP FUNCTION IF EXISTS pg_catalog.elt(int8, variadic arr "any") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.elt(text, variadic arr "any") returns text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'elt_string';
CREATE OR REPLACE FUNCTION pg_catalog.elt(int8, variadic arr "any") returns text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'elt_integer';
DROP FUNCTION IF EXISTS pg_catalog.elt(bit, variadic arr "any") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.elt(bit, variadic arr "any") returns text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'elt_bit';

DROP FUNCTION IF EXISTS pg_catalog.field(variadic arr "any") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.field(variadic arr "any") returns int8 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'field';

DROP FUNCTION IF EXISTS pg_catalog.find_in_set(text, text) cascade;
DROP FUNCTION IF EXISTS pg_catalog.find_in_set(numeric, text) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.find_in_set(text, text) returns int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'find_in_set_string';
CREATE OR REPLACE FUNCTION pg_catalog.find_in_set(numeric, text) returns int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'find_in_set_integer';

DROP FUNCTION IF EXISTS pg_catalog.soundex(text) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.soundex(text) returns text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'soundex';
DROP FUNCTION IF EXISTS pg_catalog.soundex(boolean) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.soundex(boolean) returns text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'soundex_bool';
DROP FUNCTION IF EXISTS pg_catalog.soundex(bit) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.soundex(bit) returns text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'soundex_bit';

DROP FUNCTION IF EXISTS pg_catalog.soundex_difference(text, text) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.soundex_difference(text, text) returns integer LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'soundex_difference';

DROP FUNCTION IF EXISTS pg_catalog.space(int4) cascade;
DROP FUNCTION IF EXISTS pg_catalog.space(text) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.space(int4) returns text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'space_integer';
CREATE OR REPLACE FUNCTION pg_catalog.space(text) returns text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'space_string';
DROP FUNCTION IF EXISTS pg_catalog.space(bit) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.space(bit) returns text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'space_bit';

DROP FUNCTION IF EXISTS pg_catalog.chara(variadic arr "any") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.chara(variadic arr "any") returns text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'm_char';

DROP FUNCTION IF EXISTS pg_catalog.insert(text, integer, integer, text) CASCADE;
CREATE FUNCTION pg_catalog.insert (text, bigint, bigint, text) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_insert';

DROP FUNCTION IF EXISTS pg_catalog.char_length(bool) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.char_length(bool) returns int4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'boolcharlen';
DROP FUNCTION IF EXISTS pg_catalog.char_length(bit) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.char_length(bit) returns int4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'c_bitoctetlength';

DROP FUNCTION IF EXISTS pg_catalog.character_length(bool) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.character_length(bool) returns int4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'boolcharlen';
DROP FUNCTION IF EXISTS pg_catalog.character_length(bit) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.character_length(bit) returns int4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'c_bitoctetlength';
DROP FUNCTION IF EXISTS pg_catalog.make_set(bigint, VARIADIC ARR "any") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.make_set(bigint, VARIADIC ARR "any") RETURNS text LANGUAGE C as '$libdir/dolphin', 'make_set';

DROP FUNCTION IF EXISTS pg_catalog.hex(int8) cascade;
DROP FUNCTION IF EXISTS pg_catalog.hex(text) cascade;
DROP FUNCTION IF EXISTS pg_catalog.hex(bytea) cascade;
DROP FUNCTION IF EXISTS pg_catalog.hex(bit) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.hex(int8) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int_to_hex';
CREATE OR REPLACE FUNCTION pg_catalog.hex(text) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_to_hex';
CREATE OR REPLACE FUNCTION pg_catalog.hex(bytea) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bytea_to_hex';
CREATE OR REPLACE FUNCTION pg_catalog.hex(bit) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bit_to_hex';

DROP FUNCTION IF EXISTS pg_catalog.uuid() cascade;
CREATE OR REPLACE FUNCTION pg_catalog.uuid() RETURNS varchar LANGUAGE C VOLATILE STRICT as '$libdir/dolphin', 'uuid_generate';

DROP FUNCTION IF EXISTS pg_catalog.db_b_format("any", int4) cascade;
DROP FUNCTION IF EXISTS pg_catalog.db_b_format("any", int4, "any") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.db_b_format("any", int4) RETURNS text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'db_b_format';
CREATE OR REPLACE FUNCTION pg_catalog.db_b_format("any", int4, "any") RETURNS text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'db_b_format_locale';

CREATE OR REPLACE FUNCTION pg_catalog.float8_bool(float8) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'float8_bool';
CREATE CAST (float8 as boolean) WITH FUNCTION float8_bool(float8) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.float4_bool(float4) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'float4_bool';
CREATE CAST (float4 as boolean) WITH FUNCTION float4_bool(float4) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.date_bool(date) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'date_bool';
CREATE CAST (date as boolean) WITH FUNCTION date_bool(date) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.time_bool(time) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'time_bool';
CREATE CAST (time as boolean) WITH FUNCTION time_bool(time) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.bit_bool(bit) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'bit_bool';
CREATE CAST (bit as boolean) WITH FUNCTION bit_bool(bit) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.text_bool(text) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'text_bool';
CREATE CAST (text as boolean) WITH FUNCTION text_bool(text) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.varchar_bool(varchar) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'varchar_bool';
CREATE CAST (varchar as boolean) WITH FUNCTION varchar_bool(varchar) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.char_bool(char) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'char_bool';
CREATE CAST (char as boolean) WITH FUNCTION char_bool(char) AS IMPLICIT;

CREATE FUNCTION pg_catalog.boolboollike(
bool,
bool
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'boolboollike';

CREATE OPERATOR pg_catalog.~~(leftarg = bool, rightarg = bool, procedure = pg_catalog.boolboollike);
CREATE OPERATOR pg_catalog.~~*(leftarg = bool, rightarg = bool, procedure = pg_catalog.boolboollike);

CREATE FUNCTION pg_catalog.booltextlike(
bool,
text
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'booltextlike';

CREATE OPERATOR pg_catalog.~~(leftarg = bool, rightarg = text, procedure = pg_catalog.booltextlike);
CREATE OPERATOR pg_catalog.~~*(leftarg = bool, rightarg = text, procedure = pg_catalog.booltextlike);

CREATE FUNCTION pg_catalog.textboollike(
text,
bool
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textboollike';

CREATE OPERATOR pg_catalog.~~(leftarg = text, rightarg = bool, procedure = pg_catalog.textboollike);
CREATE OPERATOR pg_catalog.~~*(leftarg = text, rightarg = bool, procedure = pg_catalog.textboollike);

CREATE FUNCTION pg_catalog.boolboolnlike(
bool,
bool
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'boolboolnlike';

CREATE OPERATOR pg_catalog.!~~(leftarg = bool, rightarg = bool, procedure = pg_catalog.boolboolnlike);
CREATE OPERATOR pg_catalog.!~~*(leftarg = bool, rightarg = bool, procedure = pg_catalog.boolboolnlike);

CREATE FUNCTION pg_catalog.booltextnlike(
bool,
text
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'booltextnlike';

CREATE OPERATOR pg_catalog.!~~(leftarg = bool, rightarg = text, procedure = pg_catalog.booltextnlike);
CREATE OPERATOR pg_catalog.!~~*(leftarg = bool, rightarg = text, procedure = pg_catalog.booltextnlike);

CREATE FUNCTION pg_catalog.textboolnlike(
text,
bool
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textboolnlike';

CREATE OPERATOR pg_catalog.!~~(leftarg = text, rightarg = bool, procedure = pg_catalog.textboolnlike);
CREATE OPERATOR pg_catalog.!~~*(leftarg = text, rightarg = bool, procedure = pg_catalog.textboolnlike);

CREATE FUNCTION pg_catalog.bitlike(
VarBit,
VarBit
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitlike';

CREATE FUNCTION pg_catalog.bitnlike(
VarBit,
VarBit
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitnlike';

CREATE OPERATOR pg_catalog.!~~(leftarg=VarBit, rightarg=VarBit, procedure=pg_catalog.bitnlike);
CREATE OPERATOR pg_catalog.!~~*(leftarg=VarBit, rightarg=VarBit, procedure=pg_catalog.bitnlike);

CREATE OPERATOR pg_catalog.~~(leftarg=VarBit, rightarg=VarBit, procedure=pg_catalog.bitlike);
CREATE OPERATOR pg_catalog.~~*(leftarg=VarBit, rightarg=VarBit, procedure=pg_catalog.bitlike);


CREATE FUNCTION pg_catalog.bitothernlike(
VarBit,
bool
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

CREATE OPERATOR pg_catalog.!~~(leftarg=VarBit, rightarg=bool, procedure=pg_catalog.bitothernlike);
CREATE OPERATOR pg_catalog.!~~*(leftarg=VarBit, rightarg=bool, procedure=pg_catalog.bitothernlike);

CREATE FUNCTION pg_catalog.bitothern2like(
bool,
VarBit
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

CREATE OPERATOR pg_catalog.!~~(leftarg=bool, rightarg=VarBit, procedure=pg_catalog.bitothern2like);
CREATE OPERATOR pg_catalog.!~~*(leftarg=bool, rightarg=VarBit, procedure=pg_catalog.bitothern2like);

CREATE FUNCTION pg_catalog.bitothern3like(
VarBit,
text
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

CREATE OPERATOR pg_catalog.!~~(leftarg=VarBit, rightarg=text, procedure=pg_catalog.bitothern3like);
CREATE OPERATOR pg_catalog.!~~*(leftarg=VarBit, rightarg=text, procedure=pg_catalog.bitothern3like);

CREATE FUNCTION pg_catalog.bitothern4like(
text,
VarBit
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

CREATE OPERATOR pg_catalog.!~~(leftarg=text, rightarg=VarBit, procedure=pg_catalog.bitothern4like);
CREATE OPERATOR pg_catalog.!~~*(leftarg=text, rightarg=VarBit, procedure=pg_catalog.bitothern4like);

CREATE FUNCTION pg_catalog.bitothern5like(
VarBit,
bytea
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

CREATE OPERATOR pg_catalog.!~~(leftarg=VarBit, rightarg=bytea, procedure=pg_catalog.bitothern5like);
CREATE OPERATOR pg_catalog.!~~*(leftarg=VarBit, rightarg=bytea, procedure=pg_catalog.bitothern5like);

CREATE FUNCTION pg_catalog.bitothern6like(
bytea,
VarBit
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

CREATE OPERATOR pg_catalog.!~~(leftarg=bytea, rightarg=VarBit, procedure=pg_catalog.bitothern6like);
CREATE OPERATOR pg_catalog.!~~*(leftarg=bytea, rightarg=VarBit, procedure=pg_catalog.bitothern6like);

CREATE FUNCTION pg_catalog.bitothern7like(
VarBit,
blob
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

CREATE OPERATOR pg_catalog.!~~(leftarg=VarBit, rightarg=blob, procedure=pg_catalog.bitothern7like);
CREATE OPERATOR pg_catalog.!~~*(leftarg=VarBit, rightarg=blob, procedure=pg_catalog.bitothern7like);

CREATE FUNCTION pg_catalog.bitothern8like(
blob,
VarBit
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

CREATE OPERATOR pg_catalog.!~~(leftarg=blob, rightarg=VarBit, procedure=pg_catalog.bitothern8like);
CREATE OPERATOR pg_catalog.!~~*(leftarg=blob, rightarg=VarBit, procedure=pg_catalog.bitothern8like);

CREATE FUNCTION pg_catalog.bitotherlike(
VarBit,
bool
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

CREATE OPERATOR pg_catalog.~~(leftarg=VarBit, rightarg=bool, procedure=pg_catalog.bitotherlike);
CREATE OPERATOR pg_catalog.~~*(leftarg=VarBit, rightarg=bool, procedure=pg_catalog.bitotherlike);

CREATE FUNCTION pg_catalog.bitother2like(
bool,
VarBit
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

CREATE OPERATOR pg_catalog.~~(leftarg=bool, rightarg=VarBit, procedure=pg_catalog.bitother2like);
CREATE OPERATOR pg_catalog.~~*(leftarg=bool, rightarg=VarBit, procedure=pg_catalog.bitother2like);

CREATE FUNCTION pg_catalog.bitother3like(
VarBit,
text
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

CREATE OPERATOR pg_catalog.~~(leftarg=VarBit, rightarg=text, procedure=pg_catalog.bitother3like);
CREATE OPERATOR pg_catalog.~~*(leftarg=VarBit, rightarg=text, procedure=pg_catalog.bitother3like);

CREATE FUNCTION pg_catalog.bitother4like(
text,
VarBit
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

CREATE OPERATOR pg_catalog.~~(leftarg=text, rightarg=VarBit, procedure=pg_catalog.bitother4like);
CREATE OPERATOR pg_catalog.~~*(leftarg=text, rightarg=VarBit, procedure=pg_catalog.bitother4like);

CREATE FUNCTION pg_catalog.bitother5like(
VarBit,
bytea
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

CREATE OPERATOR pg_catalog.~~(leftarg=VarBit, rightarg=bytea, procedure=pg_catalog.bitother5like);
CREATE OPERATOR pg_catalog.~~*(leftarg=VarBit, rightarg=bytea, procedure=pg_catalog.bitother5like);

CREATE FUNCTION pg_catalog.bitother6like(
bytea,
VarBit
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

CREATE OPERATOR pg_catalog.~~(leftarg=bytea, rightarg=VarBit, procedure=pg_catalog.bitother6like);
CREATE OPERATOR pg_catalog.~~*(leftarg=bytea, rightarg=VarBit, procedure=pg_catalog.bitother6like);

CREATE FUNCTION pg_catalog.bitother7like(
VarBit,
blob
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

CREATE OPERATOR pg_catalog.~~(leftarg=VarBit, rightarg=blob, procedure=pg_catalog.bitother7like);
CREATE OPERATOR pg_catalog.~~*(leftarg=VarBit, rightarg=blob, procedure=pg_catalog.bitother7like);

CREATE FUNCTION pg_catalog.bitother8like(
blob,
VarBit
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

CREATE OPERATOR pg_catalog.~~(leftarg=blob, rightarg=VarBit, procedure=pg_catalog.bitother8like);
CREATE OPERATOR pg_catalog.~~*(leftarg=blob, rightarg=VarBit, procedure=pg_catalog.bitother8like);

CREATE OPERATOR pg_catalog.~~*(leftarg = bytea, rightarg = bytea, procedure = pg_catalog.bytealike);
CREATE OPERATOR pg_catalog.!~~*(leftarg = bytea, rightarg = bytea, procedure = pg_catalog.byteanlike);

CREATE OPERATOR pg_catalog.~~*(leftarg=raw, rightarg=raw, procedure=pg_catalog.rawlike);
CREATE OPERATOR pg_catalog.!~~*(leftarg=raw, rightarg=raw, procedure=pg_catalog.rawnlike);

DROP FUNCTION IF EXISTS pg_catalog.b_between_and("any","any","any") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.b_between_and("any","any","any") returns boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'between_and';

DROP FUNCTION IF EXISTS pg_catalog.b_sym_between_and("any","any","any") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.b_sym_between_and("any","any","any") returns boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'sym_between_and';

DROP FUNCTION IF EXISTS pg_catalog.b_not_between_and("any","any","any") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.b_not_between_and("any","any","any") returns boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'not_between_and';

DROP FUNCTION IF EXISTS pg_catalog.b_not_sym_between_and("any","any","any") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.b_not_sym_between_and("any","any","any") returns boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'not_sym_between_and';
create or replace function pg_catalog.strcmp("any", "any") returns int language C immutable strict as '$libdir/dolphin', 'gs_strcmp';

create or replace function pg_catalog.gs_interval(variadic arr "any") returns int language C immutable as '$libdir/dolphin', 'gs_interval';

DROP FUNCTION IF EXISTS pg_catalog.connection_id() CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.connection_id()
RETURNS int8 AS
$$
BEGIN
    RETURN (select pg_backend_pid());
END;
$$
LANGUAGE plpgsql;
DROP FUNCTION IF EXISTS pg_catalog.is_ipv4(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.is_ipv6(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.is_ipv4(inet) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.is_ipv6(inet) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.is_ipv4(cstring) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.is_ipv6(cstring) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.is_ipv4(
text
) RETURNS int4 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'network_is_ipv4';
CREATE OR REPLACE FUNCTION pg_catalog.is_ipv6(
text
) RETURNS int4 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'network_is_ipv6';
CREATE OR REPLACE FUNCTION pg_catalog.is_ipv4(
inet
) RETURNS int4 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'network_is_ipv4';
CREATE OR REPLACE FUNCTION pg_catalog.is_ipv6(
inet
) RETURNS int4 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'network_is_ipv6';
CREATE OR REPLACE FUNCTION pg_catalog.is_ipv4(
cstring
) RETURNS int4 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'network_is_ipv4';
CREATE OR REPLACE FUNCTION pg_catalog.is_ipv6(
cstring
) RETURNS int4 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'network_is_ipv6';

DROP FUNCTION IF EXISTS pg_catalog.inet_aton(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet_aton(boolean) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(int) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet6_aton(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet6_ntoa(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet6_ntoa(bytea) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.inet_aton (
text
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'inetaton';

CREATE OR REPLACE FUNCTION pg_catalog.inet_aton (
boolean
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'inetaton';

CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa (
int8
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'inetntoa';

CREATE OR REPLACE FUNCTION pg_catalog.inet6_aton (
text
) RETURNS bytea LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'inetpton';

CREATE OR REPLACE FUNCTION pg_catalog.inet6_ntoa (
text
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'inetntop';

CREATE OR REPLACE FUNCTION pg_catalog.inet6_ntoa (
bytea
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'inetntop';

DROP FUNCTION IF EXISTS pg_catalog.is_ipv4_compat(bytea) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.is_ipv4_mapped(bytea) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.is_ipv4_compat (
bytea
) RETURNS int LANGUAGE C IMMUTABLE as '$libdir/dolphin',  'is_v4compat';

CREATE OR REPLACE FUNCTION pg_catalog.is_ipv4_mapped (
bytea
) RETURNS int LANGUAGE C IMMUTABLE as '$libdir/dolphin',  'is_v4mapped';
-- log10 float8
DROP FUNCTION IF EXISTS pg_catalog.log10(float8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.log10(float8)
RETURNS float8
AS
$$
BEGIN
    IF $1 <= 0 THEN
        RETURN NULL;
    end if;
    RETURN (SELECT dlog10($1));
END;
$$
LANGUAGE plpgsql;

-- log2 float8
DROP FUNCTION IF EXISTS pg_catalog.log2(float8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.log2 (
float8
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dlog2';

-- log10 numeric
DROP FUNCTION IF EXISTS pg_catalog.log10(numeric) CASCADE;
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;

-- log2 numeric
DROP FUNCTION IF EXISTS pg_catalog.log2(numeric) CASCADE;
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.conv(text, int4, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.conv (
text, int, int
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'conv_str';

DROP FUNCTION IF EXISTS pg_catalog.conv(numeric, int4, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.conv (
numeric, int4, int4
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'conv_num';

DROP FUNCTION IF EXISTS pg_catalog.crc32(text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.crc32 (
text
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'crc32';
DROP FUNCTION IF EXISTS pg_catalog.set_native_password(text, text) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.set_native_password(text, text) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'set_native_password';
create or replace function pg_catalog.b_plpgsql_call_handler() returns language_handler language C volatile as '$libdir/dolphin', 'b_plpgsql_call_handler';
create or replace function pg_catalog.b_plpgsql_inline_handler(internal) returns void language C strict volatile as '$libdir/dolphin', 'b_plpgsql_inline_handler';
create or replace function pg_catalog.b_plpgsql_validator(oid) returns void language C strict volatile as '$libdir/dolphin', 'b_plpgsql_validator';CREATE FUNCTION pg_catalog.show_object_grants(IN role_name TEXT,
                                              OUT relname NAME,
                                              OUT grantee OID,
                                              OUT grantor OID,
                                              OUT privs INT4,
                                              OUT grant_type TEXT,
                                              OUT grant_sql TEXT)
    RETURNS SETOF RECORD AS '$libdir/dolphin','ShowObjectGrants' 
 LANGUAGE C;

CREATE FUNCTION pg_catalog.show_any_privileges(IN role_name TEXT,
                                               OUT roleid OID,
                                               OUT privilege_type TEXT,
                                               OUT admin_option BOOL,
                                               OUT grant_sql TEXT)
    RETURNS SETOF RECORD AS '$libdir/dolphin','ShowAnyPrivileges' 
 LANGUAGE C;

CREATE FUNCTION pg_catalog.show_role_privilege(IN role_name TEXT,
                                               OUT role_name NAME,
                                               OUT grant_sql TEXT)
    RETURNS SETOF RECORD AS '$libdir/dolphin','ShowRolePrivilege' 
 LANGUAGE C;

CREATE FUNCTION pg_catalog.show_function_status(IN functionOrProcedure CHARACTER,
                                                OUT "Db" NAME,
                                                OUT "Name" NAME,
                                                OUT "Type" TEXT,
                                                OUT "Definer" NAME,
                                                OUT "Modified" tIMESTAMP WITH TIME ZONE,
                                                OUT "Created" tIMESTAMP WITH TIME ZONE,
                                                OUT "Security_type" TEXT,
                                                OUT "Comment" TEXT,
                                                OUT "character_set_client" TEXT,
                                                OUT "collation_connection" TEXT,
                                                OUT "Database Collation" NAME
)
    RETURNS SETOF RECORD AS '$libdir/dolphin','ShowFunctionStatus' 
 LANGUAGE C;

CREATE FUNCTION pg_catalog.show_triggers(IN schema_name NAME,
                                         OUT "Trigger" VARCHAR,
                                         OUT "Event" VARCHAR,
                                         OUT "Table" VARCHAR,
                                         OUT "Statement" VARCHAR,
                                         OUT "Timing" VARCHAR,
                                         OUT "Created" tIMESTAMP WITH TIME ZONE,
                                         OUT "sql_mode" VARCHAR,
                                         OUT "Definer" NAME,
                                         OUT "character_set_client" VARCHAR,
                                         OUT "collation_connection" VARCHAR,
                                         OUT "Database Collation" NAME
) RETURNS SETOF RECORD AS '$libdir/dolphin','ShowTriggers' 
 LANGUAGE C;

CREATE FUNCTION pg_catalog.show_character_set(OUT "charset" NAME,
                                         OUT "description" TEXT,
                                         OUT "default collation" TEXT,
                                         OUT "maxlen" INT4,
                                         OUT "server" BOOL
) RETURNS SETOF RECORD AS '$libdir/dolphin','ShowCharset' 
 LANGUAGE C;

CREATE FUNCTION pg_catalog.show_collation(OUT "collation" NAME,
                                         OUT "charset" NAME,
                                         OUT "id" OID,
                                         OUT "default" TEXT,
                                         OUT "compiled" TEXT,
                                         OUT "sortlen" INT4
) RETURNS SETOF RECORD AS '$libdir/dolphin','ShowCollation' 
 LANGUAGE C;CREATE OR REPLACE FUNCTION pg_catalog.pg_get_nonstrict_basic_value(typename text)
RETURNS text
AS
$$
BEGIN
    IF typename = 'timestamp' then
        return 'now';
    elsif typename = 'time' or typename = 'timetz' or typename = 'interval' or typename = 'reltime' then
        return '00:00:00';
    elsif typename = 'date' then
        return '1970-01-01';
    elsif typename = 'smalldatetime' then
        return '1970-01-01 08:00:00';
    elsif typename = 'abstime' then
        return '1970-01-01 08:00:00+08';
    elsif typename = 'uuid' then
        return '00000000-0000-0000-0000-000000000000';
    elsif typename = 'bool' then
        return 'false';
    elsif typename = 'point' or typename = 'polygon' then
        return '(0,0)';
    elsif typename = 'path' then
        return '((0,0))';
    elsif typename = 'circle' then
        return '(0,0),0';
    elsif typename = 'lseg' or typename = 'box' then
        return '(0,0),(0,0)';
    elsif typename = 'tinterval' then
        return '["1970-01-01 00:00:00+08" "1970-01-01 00:00:00+08"]';
    else
        return '0 or empty';
    end if;
end;
$$
LANGUAGE plpgsql;

CREATE VIEW public.pg_type_nonstrict_basic_value AS
    SELECT
            t.typname As typename,
            pg_get_nonstrict_basic_value(t.typname) As basic_value

    FROM pg_type t;
REVOKE ALL ON public.pg_type_nonstrict_basic_value  FROM PUBLIC;
GRANT SELECT, REFERENCES ON public.pg_type_nonstrict_basic_value  TO PUBLIC;

CREATE OR REPLACE FUNCTION pg_catalog.dolphin_types()
RETURNS text[][] LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_types';

DROP FUNCTION IF EXISTS pg_catalog.gs_master_status(OUT "Xlog_File_Name" text, OUT "Xlog_File_Offset" int4, OUT "Xlog_Lsn" text) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.gs_master_status (
OUT "Xlog_File_Name" text, OUT "Xlog_File_Offset" int4, OUT "Xlog_Lsn" text
) RETURNS setof record LANGUAGE C VOLATILE STRICT as '$libdir/dolphin', 'gs_master_status';

DROP FUNCTION IF EXISTS pg_catalog.get_lock(text, text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.get_lock(text, double precision) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.get_lock(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.release_lock(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.is_free_lock(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.is_used_lock(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.release_all_locks() CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.get_all_locks() CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.clear_all_invalid_locks() CASCADE;

CREATE FUNCTION pg_catalog.get_lock (
text,
text
) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'GetAdvisoryLockWithtimeTextFormat';

CREATE FUNCTION pg_catalog.get_lock (
text,
double precision
) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'GetAdvisoryLockWithtime';

CREATE FUNCTION pg_catalog.get_lock (
text
) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'GetAdvisoryLock';

CREATE FUNCTION pg_catalog.release_lock (
text
) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ReleaseAdvisoryLock';

CREATE FUNCTION pg_catalog.is_free_lock (
text
) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'IsFreeAdvisoryLock';

CREATE FUNCTION pg_catalog.is_used_lock (
text
) RETURNS bigint LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'IsUsedAdvisoryLock';

CREATE FUNCTION pg_catalog.release_all_locks (
) RETURNS bigint LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ReleaseAllAdvisoryLock';

CREATE FUNCTION pg_catalog.get_all_locks (
lockname out text,
sessionid out bigint
) RETURNS setof record LANGUAGE C STRICT as '$libdir/dolphin',  'GetAllAdvisoryLock';

CREATE FUNCTION pg_catalog.clear_all_invalid_locks (
) RETURNS bigint LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ClearInvalidLockName';

DROP FUNCTION IF EXISTS pg_catalog.gs_get_viewdef_name(text) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.gs_get_viewdef_name (
text
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'gs_get_viewdef_name';

DROP FUNCTION IF EXISTS pg_catalog.gs_get_viewdef_oid(integer) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.gs_get_viewdef_oid (
integer
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'gs_get_viewdef_oid';

DROP FUNCTION IF EXISTS pg_catalog.gs_get_schemadef_name(text) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.gs_get_schemadef_name (
text, boolean
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'gs_get_schemadef_name';

DROP FUNCTION IF EXISTS pg_catalog.ShowAllGUCReset(text) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.ShowAllGUCReset (
IN isReset boolean, OUT Variable_name text, OUT Value text
) RETURNS setof record LANGUAGE C VOLATILE STRICT as '$libdir/dolphin',  'ShowAllGUCReset';

DROP FUNCTION IF EXISTS pg_catalog.system_user() CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.system_user ()
RETURNS text
AS
$$
BEGIN
    RETURN (SELECT session_user);
END;
$$
LANGUAGE plpgsql;
DROP FUNCTION IF EXISTS pg_catalog.database() CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.database(
) RETURNS name LANGUAGE C STABLE STRICT AS '$libdir/dolphin','get_b_database';
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, int) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, int) RETURNS bytea LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bytea_left';

DROP FUNCTION IF EXISTS pg_catalog.right(bytea, int) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, int) RETURNS bytea LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bytea_right';

DROP FUNCTION IF EXISTS pg_catalog.quote(text) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.quote(t text)
returns text
as 
$$
begin
  return (select quote_literal(t));
end;
$$
language plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.quote(anyelement) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.quote(t anyelement)
returns text
as 
$$
begin
  return (select quote_literal(t));
end;
$$
language plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.ltrim(bytea, bytea) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.ltrim(bytea, bytea) RETURNS bytea LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'byteatrim_leading';

DROP FUNCTION IF EXISTS pg_catalog.rtrim(bytea, bytea) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.rtrim(bytea, bytea) RETURNS bytea LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'byteatrim_trailing';

DROP FUNCTION IF EXISTS pg_catalog.btrim(bytea) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.btrim(bytea) RETURNS bytea AS
$$
BEGIN
    RETURN (SELECT btrim($1, ' '::bytea));
END;
$$
LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.ltrim(bytea) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.ltrim(bytea) RETURNS bytea AS
$$
BEGIN
    RETURN (SELECT ltrim($1, ' '::bytea));
END;
$$
LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.rtrim(bytea) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.rtrim(bytea) RETURNS bytea AS
$$
BEGIN
    RETURN (SELECT rtrim($1, ' '::bytea));
END;
$$
LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.mid(text, int, int) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.mid(text, int, int) RETURNS text AS
$$
BEGIN
    RETURN (SELECT substr($1, $2, $3));
END;
$$
LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.mid(text, int) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.mid(text, int) RETURNS text AS
$$
BEGIN
    RETURN (SELECT substr($1, $2));
END;
$$
LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.mid(bytea, int, int) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.mid(bytea, int, int) RETURNS bytea AS
$$
BEGIN
    RETURN (SELECT substr($1, $2, $3));
END;
$$
LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.mid(bytea, int) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.mid(bytea, int) RETURNS bytea AS
$$
BEGIN
    RETURN (SELECT substr($1, $2));
END;
$$
LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.convert (text, name) CASCADE;
CREATE FUNCTION pg_catalog.convert (
text,
name
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'pg_convert_to_text';

create function pg_catalog.textxor (
text,
text
) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'textxor';


create function pg_catalog.boolxor (
boolean,
boolean
) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'boolxor';

CREATE OR REPLACE FUNCTION pg_catalog.ord (text) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'ord_text';

CREATE OR REPLACE FUNCTION pg_catalog.ord (numeric) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'ord_numeric';

DROP FUNCTION IF EXISTS pg_catalog.substring_index (text, text, numeric) CASCADE;
CREATE FUNCTION pg_catalog.substring_index (
text,
text,
numeric
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index';

DROP FUNCTION IF EXISTS pg_catalog.substring_index (boolean, text, numeric) CASCADE;
CREATE FUNCTION pg_catalog.substring_index (
boolean,
text,
numeric
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_bool_1';

DROP FUNCTION IF EXISTS pg_catalog.substring_index (text, boolean, numeric) CASCADE;
CREATE FUNCTION pg_catalog.substring_index (
text,
boolean,
numeric
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_bool_2';

DROP FUNCTION IF EXISTS pg_catalog.substring_index (boolean, boolean, numeric) CASCADE;
CREATE FUNCTION pg_catalog.substring_index (
boolean,
boolean,
numeric
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_2bool';

create function pg_catalog.bool_float8_xor(
boolean,
float8
) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bool_float8_xor';

create function pg_catalog.float8_bool_xor(
float8,
boolean
) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float8_bool_xor';
DROP FUNCTION IF EXISTS pg_catalog.b_db_sys_real_timestamp(integer) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.b_db_sys_real_timestamp(integer) returns timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'b_db_sys_real_timestamp';

DROP FUNCTION IF EXISTS pg_catalog.b_db_statement_start_time(integer) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.b_db_statement_start_time(integer) returns time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'b_db_statement_start_time';

DROP FUNCTION IF EXISTS pg_catalog.b_db_statement_start_timestamp(integer) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.b_db_statement_start_timestamp(integer) returns timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'b_db_statement_start_timestamp';

DROP FUNCTION IF EXISTS pg_catalog.curdate() CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.curdate() returns date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'curdate';

--CREATE TYPE
DROP TYPE IF EXISTS pg_catalog.year CASCADE;

DROP TYPE IF EXISTS pg_catalog._year CASCADE;

CREATE TYPE pg_catalog.year;

--CREATE YEAR'S BASIC FUNCTION

CREATE OR REPLACE FUNCTION pg_catalog.year_in (cstring) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_in';

CREATE OR REPLACE FUNCTION pg_catalog.year_out (year) RETURNS cstring LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_out';

CREATE OR REPLACE FUNCTION pg_catalog.year_send (year) RETURNS bytea LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_send';

CREATE OR REPLACE FUNCTION pg_catalog.year_recv (bytea) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_recv';

CREATE OR REPLACE FUNCTION pg_catalog.yeartypmodin (cstring[]) RETURNS integer LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'yeartypmodin';

CREATE OR REPLACE FUNCTION pg_catalog.yeartypmodout (integer) RETURNS cstring LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'yeartypmodout';

--COMPLETE YEAR'S TYPE

CREATE TYPE pg_catalog.year (input=year_in, output=year_out, internallength=2, passedbyvalue, alignment=int2, TYPMOD_IN=yeartypmodin, TYPMOD_OUT=yeartypmodout);

--CREATE YEAR'S COMPARATION FUNCTION

CREATE OR REPLACE FUNCTION pg_catalog.year_eq (year, year) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_eq';

CREATE OR REPLACE FUNCTION pg_catalog.year_ne (year, year) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_ne';

CREATE OR REPLACE FUNCTION pg_catalog.year_le (year, year) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_le';

CREATE OR REPLACE FUNCTION pg_catalog.year_lt (year, year) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_lt';

CREATE OR REPLACE FUNCTION pg_catalog.year_ge (year, year) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_ge';

CREATE OR REPLACE FUNCTION pg_catalog.year_gt (year, year) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_gt';

--CREATE YEAR'S CALCULATION FUNCTION

CREATE OR REPLACE FUNCTION pg_catalog.year_pl_interval (year, interval) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_pl_interval';

CREATE OR REPLACE FUNCTION pg_catalog.year_mi_interval (year, interval) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_mi_interval';

CREATE OR REPLACE FUNCTION pg_catalog.year_mi (year, year) RETURNS interval LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_mi';

CREATE OPERATOR - (
   leftarg = year,
   rightarg = year,
   procedure = year_mi,
   commutator = -
);

-- YEAR AND INTERVAL 

CREATE OPERATOR pg_catalog.+ (
   leftarg = year,
   rightarg = interval,
   procedure = year_pl_interval,
   commutator = operator(pg_catalog.+)
);

CREATE OPERATOR pg_catalog.- (
   leftarg = year,
   rightarg = interval,
   procedure = year_mi_interval,
   commutator = operator(pg_catalog.-)
);

CREATE OR REPLACE FUNCTION pg_catalog.interval_pl_year (interval, year) RETURNS year AS $$ SELECT $2 + $1  $$ LANGUAGE SQL;

CREATE OPERATOR pg_catalog.+ (
   leftarg = interval,
   rightarg = year,
   procedure = interval_pl_year,
   commutator = operator(pg_catalog.+)
);

--CREATE YEAR'S B-TREE SUPPORT FUNCTION

CREATE OR REPLACE FUNCTION pg_catalog.year_cmp (year, year) RETURNS integer LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_cmp';

CREATE OR REPLACE FUNCTION pg_catalog.year_sortsupport (internal) RETURNS void LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_sortsupport';

--CREATE YEAR'S CAST FUNCTION

CREATE OR REPLACE FUNCTION pg_catalog.int32_year (integer) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int32_year';

CREATE OR REPLACE FUNCTION pg_catalog.year_integer (year) RETURNS integer LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_integer';

CREATE FUNCTION pg_catalog.year (year, integer) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_scale';

DROP CAST IF EXISTS (year AS year) CASCADE;

CREATE CAST(year AS year) WITH FUNCTION year(year, integer) AS IMPLICIT;

DROP CAST IF EXISTS (integer AS year) CASCADE;

CREATE CAST(integer AS year) WITH FUNCTION int32_year(integer) AS IMPLICIT;

DROP CAST IF EXISTS (year AS integer) CASCADE;

CREATE CAST(year AS integer) WITH FUNCTION year_integer(year) AS IMPLICIT;

--CREATE OPERATOR

CREATE OPERATOR pg_catalog.=(leftarg = year, rightarg = year, procedure = year_eq, restrict = eqsel, join = eqjoinsel, MERGES);

CREATE OPERATOR pg_catalog.<>(leftarg = year, rightarg = year, procedure = year_ne, restrict = neqsel, join = neqjoinsel);

CREATE OPERATOR pg_catalog.<=(leftarg = year, rightarg = year, procedure = year_le, COMMUTATOR  = >=, NEGATOR  = >, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.<(leftarg = year, rightarg = year, procedure = year_lt, COMMUTATOR  = >, NEGATOR  = >=, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.>=(leftarg = year, rightarg = year, procedure = year_ge, COMMUTATOR  = <=, NEGATOR  = <, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.>(leftarg = year, rightarg = year, procedure = year_gt, COMMUTATOR  = <, NEGATOR  = <=, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR CLASS year_ops
    DEFAULT FOR TYPE year USING btree AS
        OPERATOR        1       < ,
        OPERATOR        2       <= ,
        OPERATOR        3       = ,
        OPERATOR        4       >= ,
        OPERATOR        5       > ,
        FUNCTION        1       year_cmp(year, year),
        FUNCTION        2       year_sortsupport(internal);

--CREATE YEAR'S MAX,MIN FUNCTION

CREATE OR REPLACE FUNCTION pg_catalog.year_larger (year, year) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_larger';

CREATE OR REPLACE FUNCTION pg_catalog.year_smaller (year, year) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_smaller';

CREATE AGGREGATE pg_catalog.max(year) (

SFUNC = year_larger,

STYPE = year,

SORTOP = >

);

CREATE AGGREGATE pg_catalog.min(year) (

SFUNC = year_smaller,

STYPE = year,

SORTOP = <

);

--CREATE DATE'S CAST FUNCTION

CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_date (int4) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int32_b_format_date';

DROP CAST IF EXISTS (int4 AS date) CASCADE;

CREATE CAST(int4 AS date) WITH FUNCTION int32_b_format_date(int4) AS IMPLICIT;

--CREATE TIME'S CAST FUNCTION

CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_time (int4) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int32_b_format_time';

CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_time (int8) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_b_format_time';

CREATE OR REPLACE FUNCTION pg_catalog.numeric_b_format_time (numeric) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_b_format_time';

DROP CAST IF EXISTS (int4 AS time) CASCADE;

CREATE CAST(int4 AS time) WITH FUNCTION int32_b_format_time(int4) AS IMPLICIT;

DROP CAST IF EXISTS (int8 AS time) CASCADE;

CREATE CAST(int8 AS time) WITH FUNCTION int64_b_format_time(int8) AS IMPLICIT;

DROP CAST IF EXISTS (numeric AS time) CASCADE;

CREATE CAST(numeric AS time) WITH FUNCTION numeric_b_format_time(numeric) AS IMPLICIT;

--CREATE timestamp(0) without time zone'S CAST FUNCTION

CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_datetime (int4) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int32_b_format_datetime';

CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_datetime (int8) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_b_format_datetime';

CREATE OR REPLACE FUNCTION pg_catalog.numeric_b_format_datetime (numeric) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_b_format_datetime';

DROP CAST IF EXISTS (int4 AS timestamp(0) without time zone) CASCADE;

CREATE CAST(int4 AS timestamp(0) without time zone) WITH FUNCTION int32_b_format_datetime(int4) AS IMPLICIT;

DROP CAST IF EXISTS (int8 AS timestamp(0) without time zone) CASCADE;

CREATE CAST(int8 AS timestamp(0) without time zone) WITH FUNCTION int64_b_format_datetime(int8) AS IMPLICIT;

DROP CAST IF EXISTS (numeric AS timestamp(0) without time zone) CASCADE;

CREATE CAST(numeric AS timestamp(0) without time zone) WITH FUNCTION numeric_b_format_datetime(numeric) AS IMPLICIT;

--CREATE timestamp(0) without time zone'S YEAR PART FUNCTION

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';

--CREATE TIMESTAMP'S CAST FUNCTION

CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_timestamp (int4) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int32_b_format_timestamp';

CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_timestamp (int8) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_b_format_timestamp';

CREATE OR REPLACE FUNCTION pg_catalog.numeric_b_format_timestamp (numeric) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_b_format_timestamp';

DROP CAST IF EXISTS (int4 AS timestamptz) CASCADE;

CREATE CAST(int4 AS timestamptz) WITH FUNCTION int32_b_format_timestamp(int4) AS IMPLICIT;

DROP CAST IF EXISTS (int8 AS timestamptz) CASCADE;

CREATE CAST(int8 AS timestamptz) WITH FUNCTION int64_b_format_timestamp(int8) AS IMPLICIT;

DROP CAST IF EXISTS (numeric AS timestamptz) CASCADE;

CREATE CAST(numeric AS timestamptz) WITH FUNCTION numeric_b_format_timestamp(numeric) AS IMPLICIT;

--CREATE TIME'S NEGETIVE UNRAY OPERATOR

CREATE OR REPLACE FUNCTION pg_catalog.negetive_time (time) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'negetive_time';

--OTHER TIME FUNCTIONS

-- CREATE b compatibility time function
CREATE OR REPLACE FUNCTION pg_catalog.makedate (int8, int8) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'makedate';
CREATE OR REPLACE FUNCTION pg_catalog.makedate (bit, bit) RETURNS date AS $$ SELECT pg_catalog.makedate(cast($1 as int8), cast($2 as int8)) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.makedate (bit, int8) RETURNS date AS $$ SELECT pg_catalog.makedate(cast($1 as int8), cast($2 as int8)) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.makedate (int8, bit) RETURNS date AS $$ SELECT pg_catalog.makedate(cast($1 as int8), cast($2 as int8)) $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.maketime (int8, int8, numeric) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'maketime';
CREATE OR REPLACE FUNCTION pg_catalog.maketime (bit, bit, numeric) RETURNS time AS $$ SELECT pg_catalog.maketime(cast($1 as int8), cast($2 as int8), $3) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.maketime (bit, int8, numeric) RETURNS time AS $$ SELECT pg_catalog.maketime(cast($1 as int8), cast($2 as int8), $3) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.maketime (int8, bit, numeric) RETURNS time AS $$ SELECT pg_catalog.maketime(cast($1 as int8), cast($2 as int8), $3) $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.sec_to_time (numeric) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'sec_to_time';
CREATE OR REPLACE FUNCTION pg_catalog.sec_to_time (text) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'sec_to_time_str';

CREATE OR REPLACE FUNCTION pg_catalog.subdate (text, int8) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'subdate_datetime_days_text';
CREATE OR REPLACE FUNCTION pg_catalog.subdate (text, text) RETURNS text AS $$ SELECT pg_catalog.subdate($1, cast($2 as int8))  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.subdate (text, bit) RETURNS text AS $$ SELECT pg_catalog.subdate($1, cast($2 as int8))  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.subdate (text, interval) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'subdate_datetime_interval_text';
CREATE OR REPLACE FUNCTION pg_catalog.subdate (numeric(24,6), int8) RETURNS text AS $$ SELECT pg_catalog.subdate(cast($1 as text), cast($2 as int8))  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.subdate (numeric(24,6), interval) RETURNS text AS $$ SELECT pg_catalog.subdate(cast($1 as text), $2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.subdate (time, int8) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'subdate_time_days';
CREATE OR REPLACE FUNCTION pg_catalog.subdate (time, interval) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'subdate_time_interval';

CREATE OR REPLACE FUNCTION pg_catalog.period_add (int8, int8) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'period_add';
CREATE OR REPLACE FUNCTION pg_catalog.period_add (bit, bit) RETURNS int8 AS $$ SELECT pg_catalog.period_add(cast($1 as int8), cast($2 as int8)) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.period_add (bit, int8) RETURNS int8 AS $$ SELECT pg_catalog.period_add(cast($1 as int8), cast($2 as int8)) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.period_add (int8, bit) RETURNS int8 AS $$ SELECT pg_catalog.period_add(cast($1 as int8), cast($2 as int8)) $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.period_diff (int8, int8) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'period_diff';
CREATE OR REPLACE FUNCTION pg_catalog.period_diff (bit, bit) RETURNS int8 AS $$ SELECT pg_catalog.period_diff(cast($1 as int8), cast($2 as int8)) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.period_diff (bit, int8) RETURNS int8 AS $$ SELECT pg_catalog.period_diff(cast($1 as int8), cast($2 as int8)) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.period_diff (int8, bit) RETURNS int8 AS $$ SELECT pg_catalog.period_diff(cast($1 as int8), cast($2 as int8)) $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.subtime ("any", "any") RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'subtime';

CREATE OR REPLACE FUNCTION pg_catalog.timediff ("any", "any") RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timediff';

CREATE OR REPLACE FUNCTION pg_catalog.time_format (text, text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_format';
CREATE OR REPLACE FUNCTION pg_catalog.time_format (date, text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_format_date';
CREATE OR REPLACE FUNCTION pg_catalog.time_format (numeric, text) RETURNS TEXT AS $$ SELECT pg_catalog.time_format(cast($1 as text), $2)  $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.time_mysql ("any") RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_mysql';

CREATE OR REPLACE FUNCTION pg_catalog.timestamp_mysql ("any") RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_param1';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_mysql ("any", "any") RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_param2';

CREATE OR REPLACE FUNCTION pg_catalog.timestamp_add (text, numeric, "any") RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_add_numeric';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_add (text, text, "any") RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_add_text';

CREATE OR REPLACE FUNCTION pg_catalog.to_days (timestamp(0) without time zone) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'to_days';
CREATE OR REPLACE FUNCTION pg_catalog.to_days (time) RETURNS int8 AS $$ SELECT pg_catalog.to_days(text_date('now') + $1)  $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.to_seconds ("any") RETURNS numeric LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'to_seconds';

CREATE OR REPLACE FUNCTION pg_catalog.unix_timestamp () RETURNS numeric LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'unix_timestamp_no_args';
CREATE OR REPLACE FUNCTION pg_catalog.unix_timestamp ("any") RETURNS numeric LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'unix_timestamp';

CREATE OR REPLACE FUNCTION pg_catalog.utc_timestamp_func (int4) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'utc_timestamp_func';
CREATE OR REPLACE FUNCTION pg_catalog.utc_date_func () RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'utc_date_func';
CREATE OR REPLACE FUNCTION pg_catalog.utc_time_func (int4) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'utc_time_func';

CREATE OPERATOR pg_catalog.- (
   rightarg = time,
   procedure = negetive_time
);

CREATE OR REPLACE FUNCTION pg_catalog.dayname(text) RETURNS text LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'dayname_text';
CREATE OR REPLACE FUNCTION pg_catalog.dayname(numeric) RETURNS text LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'dayname_numeric';

CREATE OR REPLACE FUNCTION pg_catalog.monthname(text) RETURNS text LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'monthname_text';
CREATE OR REPLACE FUNCTION pg_catalog.monthname(numeric) RETURNS text LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'monthname_numeric';

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;

CREATE OR REPLACE FUNCTION pg_catalog.month(text) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'month_text';
CREATE OR REPLACE FUNCTION pg_catalog.month(numeric) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'month_numeric';

CREATE OR REPLACE FUNCTION pg_catalog.b_db_last_day(text) RETURNS date LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'last_day_text';
CREATE OR REPLACE FUNCTION pg_catalog.b_db_last_day(numeric) RETURNS date LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'last_day_numeric';

CREATE OR REPLACE FUNCTION pg_catalog.b_db_date(text) RETURNS date LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'b_db_date_text';
CREATE OR REPLACE FUNCTION pg_catalog.b_db_date(numeric) RETURNS date LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'b_db_date_numeric';

CREATE OR REPLACE FUNCTION pg_catalog.day(text) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'dayofmonth_text';
CREATE OR REPLACE FUNCTION pg_catalog.day(numeric) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'dayofmonth_numeric';

CREATE OR REPLACE FUNCTION pg_catalog.week(text, int8) RETURNS int4 LANGUAGE C STABLE CALLED ON NULL INPUT as '$libdir/dolphin', 'week_text';
CREATE OR REPLACE FUNCTION pg_catalog.week(numeric, int8) RETURNS int4 LANGUAGE C STABLE CALLED ON NULL INPUT as '$libdir/dolphin', 'week_numeric';
CREATE OR REPLACE FUNCTION pg_catalog.week(text) RETURNS int4 AS $$ SELECT pg_catalog.week($1, null) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.week(numeric) RETURNS int4 AS $$ SELECT pg_catalog.week($1, null) $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.yearweek(text, int8) RETURNS int8 LANGUAGE C STABLE CALLED ON NULL INPUT as '$libdir/dolphin', 'yearweek_text';
CREATE OR REPLACE FUNCTION pg_catalog.yearweek(numeric, int8) RETURNS int8 LANGUAGE C STABLE CALLED ON NULL INPUT as '$libdir/dolphin', 'yearweek_numeric';
CREATE OR REPLACE FUNCTION pg_catalog.yearweek(text) RETURNS int8 AS $$ SELECT pg_catalog.yearweek($1, null) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.yearweek(numeric) RETURNS int8 AS $$ SELECT pg_catalog.yearweek($1, null) $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.datediff(text, text) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'datediff_t_t';
CREATE OR REPLACE FUNCTION pg_catalog.datediff(text, numeric) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'datediff_t_n';
CREATE OR REPLACE FUNCTION pg_catalog.datediff(numeric, text) RETURNS int4 AS $$ SELECT -pg_catalog.datediff($2, $1) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.datediff(numeric, numeric) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'datediff_n_n';
CREATE OR REPLACE FUNCTION pg_catalog.datediff(time, text) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'datediff_time_t';
CREATE OR REPLACE FUNCTION pg_catalog.datediff(time, numeric) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'datediff_time_n';
CREATE OR REPLACE FUNCTION pg_catalog.datediff(time, time) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'datediff_time_time';
CREATE OR REPLACE FUNCTION pg_catalog.datediff(text, time) RETURNS int4 AS $$ SELECT -pg_catalog.datediff($2, $1) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.datediff(numeric, time) RETURNS int4 AS $$ SELECT -pg_catalog.datediff($2, $1) $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.from_days(numeric) RETURNS text LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'from_days_numeric';
CREATE OR REPLACE FUNCTION pg_catalog.from_days(text) RETURNS text LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'from_days_text';

CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,text,text) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'timestampdiff_datetime_tt';
CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,numeric,numeric) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'timestampdiff_datetime_nn';
CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,text,numeric) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'timestampdiff_datetime_tn';
CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,numeric,text) RETURNS int8 AS $$ SELECT -pg_catalog.b_timestampdiff($1, $3, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,time,time) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'timestampdiff_time';
CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,time,text) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'timestampdiff_time_before_t';
CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,time,numeric) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'timestampdiff_time_before_n';
CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,text,time) RETURNS int8 AS $$ SELECT -pg_catalog.b_timestampdiff($1, $3, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,numeric,time) RETURNS int8 AS $$ SELECT -pg_catalog.b_timestampdiff($1, $3, $2) $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.convert_tz(text,text,text) RETURNS timestamp(0) without time zone LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'convert_tz_t';
CREATE OR REPLACE FUNCTION pg_catalog.convert_tz(numeric,text,text) RETURNS timestamp(0) without time zone LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'convert_tz_n';
CREATE OR REPLACE FUNCTION pg_catalog.convert_tz(time,text,text) RETURNS timestamp(0) without time zone LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'convert_tz_time';

CREATE OR REPLACE FUNCTION pg_catalog.adddate (text, int8) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'adddate_datetime_days_t';
CREATE OR REPLACE FUNCTION pg_catalog.adddate (text, text) RETURNS text AS $$ SELECT pg_catalog.adddate($1, cast($2 as int8))  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.adddate (text, bit) RETURNS text AS $$ SELECT pg_catalog.adddate($1, cast($2 as int8))  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.adddate (text, interval) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'adddate_datetime_interval_t';
CREATE OR REPLACE FUNCTION pg_catalog.adddate (numeric, int8) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'adddate_datetime_days_n';
CREATE OR REPLACE FUNCTION pg_catalog.adddate (numeric, interval) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'adddate_datetime_interval_n';
CREATE OR REPLACE FUNCTION pg_catalog.adddate (time, int8) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'adddate_time_days';
CREATE OR REPLACE FUNCTION pg_catalog.adddate (time, interval) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'adddate_time_interval';

CREATE OR REPLACE FUNCTION pg_catalog.date_sub (text, interval) RETURNS text AS $$ SELECT pg_catalog.adddate($1, -$2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_sub (numeric, interval) RETURNS text AS $$ SELECT pg_catalog.adddate($1, -$2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_sub (time, interval) RETURNS time AS $$ SELECT pg_catalog.adddate($1, -$2)  $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.date_add (text, interval) RETURNS text AS $$ SELECT pg_catalog.adddate($1, $2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_add (numeric, interval) RETURNS text AS $$ SELECT pg_catalog.adddate($1, $2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_add (time, interval) RETURNS time AS $$ SELECT pg_catalog.adddate($1, $2)  $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.addtime (text, text) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'addtime_text';
CREATE OR REPLACE FUNCTION pg_catalog.addtime (date, text) RETURNS TEXT LANGUAGE SQL STABLE STRICT as 'select pg_catalog.addtime(cast(0 as time), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.addtime (date, timestamp(0) without time zone) RETURNS TEXT LANGUAGE SQL STABLE STRICT as 'select pg_catalog.addtime(cast(0 as time), cast($2 as time))';
CREATE OR REPLACE FUNCTION pg_catalog.addtime (date, date) RETURNS TEXT LANGUAGE SQL STABLE STRICT as 'select pg_catalog.addtime(cast(0 as time), cast(0 as time))';
CREATE OR REPLACE FUNCTION pg_catalog.addtime (text, timestamp(0) without time zone) RETURNS TEXT LANGUAGE SQL STABLE STRICT as 'select pg_catalog.addtime($1, cast($2 as time))';
CREATE OR REPLACE FUNCTION pg_catalog.addtime (text, date) RETURNS TEXT LANGUAGE SQL STABLE STRICT as 'select pg_catalog.addtime($1, cast(0 as time))';
CREATE OR REPLACE FUNCTION pg_catalog.addtime (numeric, numeric) RETURNS TEXT LANGUAGE SQL STABLE STRICT as 'select pg_catalog.addtime(cast($1 as text), cast($2 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.addtime (text, numeric) RETURNS TEXT LANGUAGE SQL STABLE STRICT as 'select pg_catalog.addtime($1, cast($2 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.addtime (numeric, text) RETURNS TEXT LANGUAGE SQL STABLE STRICT as 'select pg_catalog.addtime(cast($1 as text), $2)';

CREATE OR REPLACE FUNCTION pg_catalog.hour (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetHour';
CREATE OR REPLACE FUNCTION pg_catalog.microsecond (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMicrosecond';
CREATE OR REPLACE FUNCTION pg_catalog.minute (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMinute';
CREATE OR REPLACE FUNCTION pg_catalog.second (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetSecond';

CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth (timestamptz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''day'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth (timetz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''day'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth (abstime) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''day'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth (date) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''day'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth (time) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''day'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth (timestamp(0) with time zone) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''day'', $1)';

CREATE OR REPLACE FUNCTION pg_catalog.dayofweek (timestamptz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select 1 + pg_catalog.date_part(''dow'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofweek (timetz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select 1 + pg_catalog.date_part(''dow'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofweek (abstime) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select 1 + pg_catalog.date_part(''dow'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofweek (date) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select 1 + pg_catalog.date_part(''dow'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofweek (time) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select 1 + pg_catalog.date_part(''dow'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofweek (timestamp(0) with time zone) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select 1 + pg_catalog.date_part(''dow'', $1)';

CREATE OR REPLACE FUNCTION pg_catalog.dayofyear (timestamptz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''doy'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofyear (timetz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''doy'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofyear (abstime) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''doy'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofyear (date) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''doy'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofyear (time) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''doy'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.dayofyear (timestamp(0) with time zone) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''doy'', $1)';

CREATE OR REPLACE FUNCTION pg_catalog.quarter (timestamptz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (timetz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (abstime) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (date) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (time) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (timestamp(0) with time zone) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)';

CREATE OR REPLACE FUNCTION pg_catalog.weekday (timestamptz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1) - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (timetz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1) - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (abstime) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1) - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (date) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1) - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (time) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1) - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (timestamp(0) with time zone) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1) - 1';

CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (timestamptz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (timetz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (abstime) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (date) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (time) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (timestamp(0) with time zone) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)';

CREATE OR REPLACE FUNCTION pg_catalog.get_format (int4, text) RETURNS TEXT LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'get_format';

CREATE OR REPLACE FUNCTION pg_catalog.date_format (text, text) RETURNS TEXT LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'date_format_text';
CREATE OR REPLACE FUNCTION pg_catalog.date_format (numeric, text) RETURNS TEXT LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'date_format_numeric';

CREATE OR REPLACE FUNCTION pg_catalog.b_extract (text, text) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'b_extract_text';
CREATE OR REPLACE FUNCTION pg_catalog.b_extract (text, numeric) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'b_extract_numeric';

CREATE OR REPLACE FUNCTION pg_catalog.str_to_date (text, text) RETURNS text LANGUAGE C STABLE CALLED ON NULL INPUT as '$libdir/dolphin', 'str_to_date';

CREATE OR REPLACE FUNCTION pg_catalog.from_unixtime (numeric) RETURNS timestamp(0) without time zone LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'from_unixtime_with_one_arg';
CREATE OR REPLACE FUNCTION pg_catalog.from_unixtime (numeric, text) RETURNS TEXT LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'from_unixtime_with_two_arg';


-- support bit_xor for date

DROP FUNCTION IF EXISTS pg_catalog.date_xor_transfn(int16, date) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.date_xor_transfn (
int16, date
) RETURNS int16 LANGUAGE C as '$libdir/dolphin',  'date_xor_transfn';

DROP FUNCTION IF EXISTS pg_catalog.date_agg_finalfn(int16) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.date_agg_finalfn (
int16
) RETURNS int16 LANGUAGE C as '$libdir/dolphin',  'date_agg_finalfn';

drop aggregate if exists pg_catalog.bit_xor(date);
create aggregate pg_catalog.bit_xor(date) (SFUNC=date_xor_transfn, finalfunc = date_agg_finalfn,  STYPE= int16);

-- support bit_xor aggregate for year

DROP FUNCTION IF EXISTS pg_catalog.year_xor_transfn(integer, year) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.year_xor_transfn (
integer, year
) RETURNS integer LANGUAGE C as '$libdir/dolphin',  'year_xor_transfn';

drop aggregate if exists pg_catalog.bit_xor(year);
create aggregate pg_catalog.bit_xor(year) (SFUNC=year_xor_transfn, STYPE= integer);

-- support bit_xor for datetime and timestamp
DROP FUNCTION IF EXISTS pg_catalog.timestamp_xor_transfn(int16, timestamp(0) with time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_xor_transfn (
int16, timestamp(0) with time zone
) RETURNS int16 LANGUAGE C as '$libdir/dolphin',  'timestamp_xor_transfn';

DROP FUNCTION IF EXISTS pg_catalog.timestamp_agg_finalfn(int16) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_agg_finalfn (
int16
) RETURNS int16 LANGUAGE C as '$libdir/dolphin',  'timestamp_agg_finalfn';

drop aggregate if exists pg_catalog.bit_xor(timestamp(0) with time zone);
create aggregate pg_catalog.bit_xor(timestamp(0) with time zone) (SFUNC=timestamp_xor_transfn, finalfunc=timestamp_agg_finalfn, STYPE=int16);

-- support bit_xor aggregate for time

DROP FUNCTION IF EXISTS pg_catalog.time_xor_transfn(int16, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_xor_transfn (
int16, time
) RETURNS int16 LANGUAGE C as '$libdir/dolphin',  'time_xor_transfn';

create aggregate pg_catalog.bit_xor(time) (SFUNC=time_xor_transfn, STYPE= int16);

DROP FUNCTION IF EXISTS pg_catalog.timetz_xor_transfn(int16, time with time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timetz_xor_transfn (
int16, time with time zone
) RETURNS int16 LANGUAGE C as '$libdir/dolphin',  'timetz_xor_transfn';

create aggregate pg_catalog.bit_xor(time with time zone) (SFUNC=timetz_xor_transfn, STYPE= int16);


DROP FUNCTION IF EXISTS pg_catalog.year_any_value (year, year) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.year_any_value (year, year) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_any_value';

drop aggregate if exists pg_catalog.any_value(year);
CREATE AGGREGATE pg_catalog.any_value(year) (
        sfunc = year_any_value,
        stype = year
);

DROP FUNCTION IF EXISTS pg_catalog.time_int8(time) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.time_int8(time) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time_int8';
CREATE CAST (time as int8) with function pg_catalog.time_int8(time);
CREATE OR REPLACE FUNCTION pg_catalog.time_float (time) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_float';
DROP CAST IF EXISTS (time AS float8) CASCADE;
CREATE CAST(time AS float8) WITH FUNCTION time_float(time) AS IMPLICIT;
DROP FUNCTION IF EXISTS pg_catalog.time_numeric(time) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.time_numeric(time) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time_numeric';
CREATE CAST (time as numeric) with function pg_catalog.time_numeric(time);

CREATE OR REPLACE FUNCTION pg_catalog.time_integer (time) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.time_float($1) as integer)';
DROP CAST IF EXISTS (time AS integer) CASCADE;
CREATE CAST(time AS integer) WITH FUNCTION time_integer(time);

CREATE OR REPLACE FUNCTION pg_catalog.time_pl_float (time, float8) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.time_float($1) + $2';
-- DROP OPERATOR IF EXISTS + (time, float8);
CREATE OPERATOR pg_catalog.+ (
    PROCEDURE = time_pl_float,
    LEFTARG = time,
    RIGHTARG = float8
);

CREATE OR REPLACE FUNCTION pg_catalog.time_mi_float (time, float8) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.time_float($1) - $2';
-- DROP OPERATOR IF EXISTS - (time, float8);
CREATE OPERATOR pg_catalog.- (
    PROCEDURE = time_mi_float,
    LEFTARG = time,
    RIGHTARG = float8
);

CREATE OR REPLACE FUNCTION pg_catalog.datetime_float (timestamp(0) without time zone) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'datetime_float';
DROP CAST IF EXISTS (timestamp(0) without time zone AS float8) CASCADE;
CREATE CAST(timestamp(0) without time zone AS float8) WITH FUNCTION datetime_float(timestamp(0) without time zone) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.datetime_bigint (timestamp(0) without time zone) RETURNS bigint LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as bigint)';
DROP CAST IF EXISTS (timestamp(0) without time zone AS bigint) CASCADE;
CREATE CAST(timestamp(0) without time zone AS bigint) WITH FUNCTION datetime_bigint(timestamp(0) without time zone);

CREATE OR REPLACE FUNCTION pg_catalog.datetime_pl_float (timestamp(0) without time zone, float8) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.datetime_float($1) + $2';
-- DROP OPERATOR IF EXISTS + (timestamp(0) without time zone, float8);
CREATE OPERATOR pg_catalog.+ (
    PROCEDURE = datetime_pl_float,
    LEFTARG = timestamp(0) without time zone,
    RIGHTARG = float8
);

CREATE OR REPLACE FUNCTION pg_catalog.datetime_mi_float (timestamp(0) without time zone, float8) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.datetime_float($1) - $2';
-- DROP OPERATOR IF EXISTS - (timestamp(0) without time zone, float8);
CREATE OPERATOR pg_catalog.- (
    PROCEDURE = datetime_mi_float,
    LEFTARG = timestamp(0) without time zone,
    RIGHTARG = float8
);

CREATE OR REPLACE FUNCTION pg_catalog.date_int (date) RETURNS int4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'date_int';
DROP CAST IF EXISTS (date AS integer) CASCADE;
CREATE CAST(date AS integer) WITH FUNCTION date_int(date);

-- CREATE OR REPLACE FUNCTION pg_catalog.date_pl_int (date, integer) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_int($1) + $2';
-- -- DROP OPERATOR + (date, integer);
-- CREATE OPERATOR + (
--     PROCEDURE = date_pl_int,
--     LEFTARG = date,
--     RIGHTARG = integer
-- );

-- CREATE OR REPLACE FUNCTION pg_catalog.date_mi_int (date, integer) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_int($1) - $2';
-- -- DROP OPERATOR - (date, integer);
-- CREATE OPERATOR - (
--     PROCEDURE = date_mi_int,
--     LEFTARG = date,
--     RIGHTARG = integer
-- );

create function pg_catalog.datexor(
date,
date
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'datexor';

create function pg_catalog.timexor(
time,
time
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timexor';

create function pg_catalog.date_time_xor(
date,
time
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_time_xor';

create function pg_catalog.time_date_xor(
time,
date
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_date_xor';

create function pg_catalog.time_text_xor(
time,
text
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_text_xor';

create function pg_catalog.text_time_xor(
text,
time
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_time_xor';

create function pg_catalog.date_text_xor(
date,
text
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_text_xor';

create function pg_catalog.text_date_xor(
text,
date
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_date_xor';

create function pg_catalog.date_int8_xor(
date,
int8
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_int8_xor';

create function pg_catalog.int8_date_xor(
int8,
date
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_date_xor';

create function pg_catalog.time_int8_xor(
time,
int8
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_int8_xor';

create function pg_catalog.int8_time_xor(
int8,
time
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_time_xor';

create function pg_catalog.date_float8_xor(
date,
float8
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_float8_xor';

create function pg_catalog.float8_date_xor(
float8,
date
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float8_date_xor';

create function pg_catalog.timestampxor(
timestamp,
timestamp
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestampxor';

create function pg_catalog.timestamp_int8_xor(
timestamp,
int8
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamp_int8_xor';

create function pg_catalog.int8_timestamp_xor(
int8,
timestamp
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_timestamp_xor';

create function pg_catalog.timestamp_float8_xor(
timestamp,
float8
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamp_float8_xor';

create function pg_catalog.float8_timestamp_xor(
float8,
timestamp
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float8_timestamp_xor';

create function pg_catalog.timestamp_text_xor(
timestamp,
text
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamp_text_xor';

create function pg_catalog.text_timestamp_xor(
text,
timestamp
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_timestamp_xor';

create function pg_catalog.timestamptzxor(
timestampTz,
timestampTz
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptzxor';

create function pg_catalog.timestamptz_int8_xor(
timestampTz,
int8
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptz_int8_xor';

create function pg_catalog.int8_timestamptz_xor(
int8,
timestampTz
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_timestamptz_xor';

create function pg_catalog.timestamptz_float8_xor(
timestampTz,
float8
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptz_float8_xor';

create function pg_catalog.float8_timestamptz_xor(
float8,
timestampTz
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float8_timestamptz_xor';

create function pg_catalog.timestamptz_text_xor(
timestampTz,
text
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptz_text_xor';

create function pg_catalog.text_timestamptz_xor(
text,
timestampTz
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_timestamptz_xor';

DROP FUNCTION IF EXISTS pg_catalog.sleep(float8) CASCADE;
CREATE FUNCTION pg_catalog.sleep (float8)
RETURNS int LANGUAGE C STABLE CALLED ON NULL INPUT as '$libdir/dolphin', 'db_b_sleep';

DROP FUNCTION IF EXISTS pg_catalog.timetz_int8(timetz) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.timetz_int8(timetz) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timetz_int8';
CREATE CAST (timetz as int8) with function pg_catalog.timetz_int8(timetz);

DROP FUNCTION IF EXISTS pg_catalog.timetz_float8(timetz) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.timetz_float8(timetz) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timetz_float8';
CREATE CAST (timetz as float8) with function pg_catalog.timetz_float8(timetz);

DROP FUNCTION IF EXISTS pg_catalog.timetz_numeric(timetz) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.timetz_numeric(timetz) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timetz_numeric';
CREATE CAST (timetz as numeric) with function pg_catalog.timetz_numeric(timetz);

DROP FUNCTION IF EXISTS pg_catalog.timestamp_numeric("timestamp") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_numeric("timestamp") RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamp_numeric';
CREATE CAST ("timestamp" as numeric) with function pg_catalog.timestamp_numeric("timestamp");

DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int8("timestamptz") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_int8("timestamptz") RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamptz_int8';
CREATE CAST ("timestamptz" as int8) with function pg_catalog.timestamptz_int8("timestamptz");

DROP FUNCTION IF EXISTS pg_catalog.timestamptz_float8("timestamptz") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_float8("timestamptz") RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamptz_float8';
CREATE CAST ("timestamptz" as float8) with function pg_catalog.timestamptz_float8("timestamptz");

DROP FUNCTION IF EXISTS pg_catalog.timestamptz_numeric("timestamptz") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_numeric("timestamptz") RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamptz_numeric';
CREATE CAST ("timestamptz" as numeric) with function pg_catalog.timestamptz_numeric("timestamptz");

DROP FUNCTION IF EXISTS pg_catalog.date_int8("date") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.date_int8("date") RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'date_int8';
CREATE CAST ("date" as int8) with function pg_catalog.date_int8("date");

DROP FUNCTION IF EXISTS pg_catalog.date2float8("date") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.date2float8("date") RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::float8; $$;
CREATE CAST ("date" as float8) with function pg_catalog.date2float8("date");

DROP FUNCTION IF EXISTS pg_catalog.date_numeric("date") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.date_numeric("date") RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'date_numeric';
CREATE CAST ("date" as numeric) with function pg_catalog.date_numeric("date");

DROP FUNCTION IF EXISTS pg_catalog.date_any_value (date, date) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.date_any_value (date, date) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'date_any_value';

DROP FUNCTION IF EXISTS pg_catalog.year_float8("year") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.year_float8("year") RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_float8';
drop CAST IF EXISTS (year AS float8) CASCADE;
CREATE CAST ("year" as float8) with function pg_catalog.year_float8("year");

DROP FUNCTION IF EXISTS pg_catalog.year_numeric("year") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.year_numeric("year") RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_numeric';
drop CAST IF EXISTS (year AS numeric) CASCADE;
CREATE CAST ("year" as numeric) with function pg_catalog.year_numeric("year");

drop aggregate if exists pg_catalog.any_value(date);
CREATE AGGREGATE pg_catalog.any_value(date) (
        sfunc = date_any_value,
        stype = date
);

DROP FUNCTION IF EXISTS pg_catalog.time_any_value (time, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_any_value (time, time) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_any_value';

drop aggregate if exists pg_catalog.any_value(time);
CREATE AGGREGATE pg_catalog.any_value(time) (
        sfunc = time_any_value,
        stype = time
);

DROP FUNCTION IF EXISTS pg_catalog.timetz_any_value (timetz, timetz) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timetz_any_value (timetz, timetz) RETURNS timetz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timetz_any_value';

drop aggregate if exists pg_catalog.any_value(timetz);
CREATE AGGREGATE pg_catalog.any_value(timetz) (
        sfunc = timetz_any_value,
        stype = timetz
);

DROP FUNCTION IF EXISTS pg_catalog.timestamp_any_value (timestamp, timestamp) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_any_value (timestamp, timestamp) RETURNS timestamp LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_any_value';

drop aggregate if exists pg_catalog.any_value(timestamp);
CREATE AGGREGATE pg_catalog.any_value(timestamp) (
        sfunc = timestamp_any_value,
        stype = timestamp
);

DROP FUNCTION IF EXISTS pg_catalog.timestamptz_any_value (timestamptz, timestamptz) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_any_value (timestamptz, timestamptz) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_any_value';

drop aggregate if exists pg_catalog.any_value(timestamptz);
CREATE AGGREGATE pg_catalog.any_value(timestamptz) (
        sfunc = timestamptz_any_value,
        stype = timestamptz
);
DROP FUNCTION IF EXISTS pg_catalog.enum2float8(anyenum) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.enum2float8(anyenum) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'Enum2Float8';

INSERT INTO pg_catalog.pg_cast
-- castsource is anyenum(3500), casttarget(701) is float8, castowner is 10(superuser)
SELECT 3500, 701, oid, 'i', 'f', 10
FROM pg_proc WHERE 
proname = 'enum2float8' AND
-- namespace is pg_catalog
pronamespace = 11 AND
-- input arg is anyenum
proargtypes='3500' AND
-- return type is float8
prorettype = 701;

DROP FUNCTION IF EXISTS pg_catalog.enumtextlt(anyenum, text) CASCADE; 
CREATE FUNCTION pg_catalog.enumtextlt ( 
anyenum, text 
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtextlt';
DROP FUNCTION IF EXISTS pg_catalog.enumtextle(anyenum, text) CASCADE; 
CREATE FUNCTION pg_catalog.enumtextle ( 
anyenum, text 
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtextle';
DROP FUNCTION IF EXISTS pg_catalog.enumtextne(anyenum, text) CASCADE; 
CREATE FUNCTION pg_catalog.enumtextne ( 
anyenum, text 
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtextne';
DROP FUNCTION IF EXISTS pg_catalog.enumtexteq(anyenum, text) CASCADE; 
CREATE FUNCTION pg_catalog.enumtexteq ( 
anyenum, text 
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtexteq';
DROP FUNCTION IF EXISTS pg_catalog.enumtextgt(anyenum, text) CASCADE; 
CREATE FUNCTION pg_catalog.enumtextgt ( 
anyenum, text 
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtextgt';
DROP FUNCTION IF EXISTS pg_catalog.enumtextge(anyenum, text) CASCADE; 
CREATE FUNCTION pg_catalog.enumtextge ( 
anyenum, text 
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtextge';
DROP FUNCTION IF EXISTS pg_catalog.textenumlt(text, anyenum) CASCADE; 
CREATE FUNCTION pg_catalog.textenumlt ( 
text, anyenum 
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textenumlt';
DROP FUNCTION IF EXISTS pg_catalog.textenumle(text, anyenum) CASCADE; 
CREATE FUNCTION pg_catalog.textenumle ( 
text, anyenum 
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textenumle';
DROP FUNCTION IF EXISTS pg_catalog.textenumne(text, anyenum) CASCADE; 
CREATE FUNCTION pg_catalog.textenumne ( 
text, anyenum 
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textenumne';
DROP FUNCTION IF EXISTS pg_catalog.textenumeq(text, anyenum) CASCADE; 
CREATE FUNCTION pg_catalog.textenumeq ( 
text, anyenum 
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textenumeq';
DROP FUNCTION IF EXISTS pg_catalog.textenumgt(text, anyenum) CASCADE; 
CREATE FUNCTION pg_catalog.textenumgt ( 
text, anyenum 
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textenumgt';
DROP FUNCTION IF EXISTS pg_catalog.textenumge(text, anyenum) CASCADE; 
CREATE FUNCTION pg_catalog.textenumge ( 
text, anyenum 
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textenumge';

CREATE OPERATOR pg_catalog.=( 
 PROCEDURE = enumtexteq, LEFTARG = anyenum, RIGHTARG = text, COMMUTATOR = OPERATOR(pg_catalog.=), NEGATOR = OPERATOR(pg_catalog.<>), RESTRICT = eqsel, JOIN = eqjoinsel, HASHES
);

CREATE OPERATOR pg_catalog.<>( 
 PROCEDURE = enumtextne, LEFTARG = anyenum, RIGHTARG = text, COMMUTATOR = OPERATOR(pg_catalog.<>), NEGATOR = OPERATOR(pg_catalog.=), RESTRICT = neqsel, JOIN = neqjoinsel
);

CREATE OPERATOR pg_catalog.<( 
 PROCEDURE = enumtextlt, LEFTARG = anyenum, RIGHTARG = text, COMMUTATOR = OPERATOR(pg_catalog.>), NEGATOR = OPERATOR(pg_catalog.>=), RESTRICT = scalarltsel, JOIN = scalarltjoinsel
);

CREATE OPERATOR pg_catalog.>( 
 PROCEDURE = enumtextgt, LEFTARG = anyenum, RIGHTARG = text, COMMUTATOR = OPERATOR(pg_catalog.<), NEGATOR = OPERATOR(pg_catalog.<=), RESTRICT = scalargtsel, JOIN = scalargtjoinsel
);

CREATE OPERATOR pg_catalog.<=( 
 PROCEDURE = enumtextle, LEFTARG = anyenum, RIGHTARG = text, COMMUTATOR = OPERATOR(pg_catalog.>=), NEGATOR = OPERATOR(pg_catalog.>), RESTRICT = scalarltsel, JOIN = scalarltjoinsel
);

CREATE OPERATOR pg_catalog.>=( 
 PROCEDURE = enumtextge, LEFTARG = anyenum, RIGHTARG = text, COMMUTATOR = OPERATOR(pg_catalog.<=), NEGATOR = OPERATOR(pg_catalog.<), RESTRICT = scalargtsel, JOIN = scalargtjoinsel
);

CREATE OPERATOR pg_catalog.=( 
 PROCEDURE = textenumeq, LEFTARG = text, RIGHTARG = anyenum, COMMUTATOR = OPERATOR(pg_catalog.=), NEGATOR = OPERATOR(pg_catalog.<>), RESTRICT = eqsel, JOIN = eqjoinsel, HASHES
);

CREATE OPERATOR pg_catalog.<>( 
 PROCEDURE = textenumne, LEFTARG = text, RIGHTARG = anyenum, COMMUTATOR = OPERATOR(pg_catalog.<>), NEGATOR = OPERATOR(pg_catalog.=), RESTRICT = neqsel, JOIN = neqjoinsel
);

CREATE OPERATOR pg_catalog.<( 
 PROCEDURE = textenumlt, LEFTARG = text, RIGHTARG = anyenum, COMMUTATOR = OPERATOR(pg_catalog.>), NEGATOR = OPERATOR(pg_catalog.>=), RESTRICT = scalarltsel, JOIN = scalarltjoinsel
);

CREATE OPERATOR pg_catalog.>( 
 PROCEDURE = textenumgt, LEFTARG = text, RIGHTARG = anyenum, COMMUTATOR = OPERATOR(pg_catalog.<), NEGATOR = OPERATOR(pg_catalog.<=), RESTRICT = scalargtsel, JOIN = scalargtjoinsel
);

CREATE OPERATOR pg_catalog.<=( 
 PROCEDURE = textenumle, LEFTARG = text, RIGHTARG = anyenum, COMMUTATOR = OPERATOR(pg_catalog.>=), NEGATOR = OPERATOR(pg_catalog.>), RESTRICT = scalarltsel, JOIN = scalarltjoinsel
);

CREATE OPERATOR pg_catalog.>=( 
 PROCEDURE = textenumge, LEFTARG = text, RIGHTARG = anyenum, COMMUTATOR = OPERATOR(pg_catalog.<=), NEGATOR = OPERATOR(pg_catalog.<), RESTRICT = scalargtsel, JOIN = scalargtjoinsel
);
CREATE OR REPLACE FUNCTION pg_catalog.export_set (numeric, text, text, text, numeric) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_5args';
CREATE OR REPLACE FUNCTION pg_catalog.export_set (numeric, text, text, text) RETURNS text LANGUAGE C STABLE STRICT  as '$libdir/dolphin', 'export_set_4args';
CREATE OR REPLACE FUNCTION pg_catalog.export_set (numeric, text, text)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_3args';
DROP FUNCTION IF EXISTS pg_catalog.from_base64 (text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.from_base64 (bool) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.from_base64 (bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.from_base64 (text)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_decode';

CREATE OR REPLACE FUNCTION pg_catalog.from_base64 (bool1 bool)
RETURNS text
AS
$$
BEGIN
    RETURN (SELECT from_base64(''));
END;
$$
LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.from_base64(bit1 bit)
RETURNS text
AS
$$
BEGIN
    RETURN (SELECT from_base64(encode((decode(hex(bit1), 'hex')), 'escape')));
END;
$$
LANGUAGE plpgsql;CREATE OR REPLACE FUNCTION pg_catalog.json_quote(text) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_quote';

CREATE OR REPLACE FUNCTION pg_catalog.json_array(variadic "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_array';
CREATE OR REPLACE FUNCTION pg_catalog.json_array() RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_array';

create or replace function pg_catalog.json_object_mysql(variadic arr "any") returns json language C immutable as '$libdir/dolphin', 'json_object_mysql';
create or replace function pg_catalog.json_object_noarg() returns json language C immutable as '$libdir/dolphin', 'json_object_noarg';

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_contains_path("any", text, variadic text[]) RETURNS boolean LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_contains_path';

CREATE OR REPLACE FUNCTION pg_catalog.json_extract("any", variadic text[]) RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin',  'json_extract';

CREATE OR REPLACE FUNCTION pg_catalog.json_keys("any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_keys';
CREATE OR REPLACE FUNCTION pg_catalog.json_keys("any",text) RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_keys';

CREATE OR REPLACE FUNCTION pg_catalog.json_search("any",text,"any") RETURNS text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_search';
CREATE OR REPLACE FUNCTION pg_catalog.json_search("any",text,"any","any") RETURNS text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_search';
CREATE OR REPLACE FUNCTION pg_catalog.json_search("any",text,"any","any",variadic text[]) RETURNS text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_search';

CREATE OR REPLACE FUNCTION pg_catalog.json_array_append("any", VARIADIC "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_array_append';

CREATE OR REPLACE FUNCTION pg_catalog.json_append("any", VARIADIC "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_append';

CREATE OR REPLACE FUNCTION pg_catalog.json_unquote("any") RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','json_unquote';

CREATE OR REPLACE FUNCTION pg_catalog.json_merge_preserve(variadic arr "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_merge_preserve';

CREATE OR REPLACE FUNCTION pg_catalog.json_merge(variadic arr "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_merge';

CREATE OR REPLACE FUNCTION pg_catalog.json_merge_patch(variadic arr "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_merge_patch';

CREATE OR REPLACE FUNCTION pg_catalog.json_insert(variadic "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_insert';

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_replace(variadic arr "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_replace';

CREATE OR REPLACE FUNCTION pg_catalog.json_remove(variadic arr "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_remove';

CREATE OR REPLACE FUNCTION pg_catalog.json_array_insert(variadic arr "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_array_insert';

CREATE OR REPLACE FUNCTION pg_catalog.json_set(variadic "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_set';

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 aggregate pg_catalog.json_arrayagg("any") (SFUNC = json_agg_transfn, STYPE = internal, finalfunc = json_agg_finalfn);

CREATE FUNCTION pg_catalog.json_objectagg_mysql_transfn (
    internal, "any", "any"
) RETURNS internal LANGUAGE C as '$libdir/dolphin', 'json_objectagg_mysql_transfn';

CREATE OR REPLACE FUNCTION pg_catalog.json_objectagg_finalfn(
    internal
) RETURNS json LANGUAGE C as '$libdir/dolphin', 'json_objectagg_finalfn';

create aggregate pg_catalog.json_objectagg("any", "any") (SFUNC = json_objectagg_mysql_transfn, STYPE = internal, finalfunc = json_objectagg_finalfn);

CREATE OR REPLACE FUNCTION pg_catalog.json_valid("any") RETURNS boolean LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_valid';

CREATE OR REPLACE FUNCTION pg_catalog.json_storage_size("any") RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_storage_size';

CREATE OR REPLACE FUNCTION pg_catalog.json_pretty("any") RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_pretty';

CREATE OR REPLACE FUNCTION pg_catalog.json_type("any") RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_type';
DROP FUNCTION IF EXISTS pg_catalog.oct(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.oct(boolean) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.oct(bit) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.oct(t1 text) RETURNS text AS
$$
BEGIN
    RETURN (SELECT conv(t1, 10, 8));
END;
$$
LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.oct(t1 bit) RETURNS text AS
$$
BEGIN
    RETURN (SELECT conv(t1, 10, 8));
END;
$$
LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.oct(t1 boolean) RETURNS text AS
$$
BEGIN
    RETURN int4(t1);
END;
$$
LANGUAGE plpgsql;
DROP FUNCTION IF EXISTS pg_catalog.schema () CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.schema ()
RETURNS text
AS
$$
BEGIN
    RETURN (SELECT CURRENT_SCHEMA());
END;
$$
LANGUAGE plpgsql;CREATE OR REPLACE FUNCTION pg_catalog.show_status(is_session boolean)
RETURNS TABLE (VARIABLE_NAME text, VALUE text) AS
$$
DECLARE sql_mode text;
BEGIN
EXECUTE IMMEDIATE 'show dolphin.sql_mode' into sql_mode;
set dolphin.sql_mode='ansi_quotes,pipes_as_concat';
RETURN QUERY
select 'os_runtime_count' as variable_name , count(*)::text as value from dbe_perf.global_os_runtime
union
select concat(nodename, '-', memorytype) as variable_name, memorymbytes::text as value from dbe_perf.global_memory_node_detail
union
select unnest(array['p80', 'p95']) as variable_name, unnest(array[p80, p95]::text[]) as value from dbe_perf.statement_responsetime_percentile
union
select 'global_instance_time_count' as variable_name, count(*)::text as value from dbe_perf.global_instance_time
union
select unnest(array['node_name', 'worker_info', 'session_info', 'stream_info']) as variable_name, unnest(array[node_name, worker_info, session_info, stream_info]) as value from dbe_perf.global_threadpool_status
union
select unnest(array['group_id', 'bind_numa_id', 'bind_cpu_number', 'listener']) as variable_name, unnest(array[group_id, bind_numa_id, bind_cpu_number, listener]::text[]) as value from dbe_perf.global_threadpool_status
union
select 'os_threads_count' as variable_name,count(*)::text as value from dbe_perf.global_os_threads
union
select unnest(array['node_name', 'user_name']) as variable_name, unnest(array[node_name, user_name]) as value from dbe_perf.summary_user_login
union
select unnest(array['login_counter', 'logout_counter', 'user_id']) as variable_name, unnest(array[login_counter, logout_counter, user_id]::text[]) as value from dbe_perf.summary_user_login
union
select unnest(array['select_count', 'update_count', 'insert_count', 'delete_count', 'ddl_count', 'dml_count', 'dcl_count']) as variable_name, unnest(array[select_count, update_count, insert_count, delete_count, ddl_count, dml_count, dcl_count]::text[]) as value from dbe_perf.summary_workload_sql_count
union
select unnest(array['node_name', 'workload']) as variable_name, unnest(array[node_name, workload]::text[]) as value from dbe_perf.global_workload_transaction
union
select unnest(array['commit_counter', 'rollback_counter', 'resp_min', 'resp_max', 'resp_avg', 'resp_total', 'bg_commit_counter', 'bg_rollback_counter', 'bg_resp_min', 'bg_resp_max', 'bg_resp_avg', 'bg_resp_total']) as variable_name,
unnest(array[commit_counter, rollback_counter, resp_min, resp_max, resp_avg, resp_total, bg_commit_counter, bg_rollback_counter, bg_resp_min, bg_resp_max, bg_resp_avg, bg_resp_total]::text[]) as value from dbe_perf.global_workload_transaction
union
select 'node_name' as variable_name, node_name::text as value from dbe_perf.global_bgwriter_stat
union
select 'stats_reset' as variable_name, stats_reset::text as value from dbe_perf.global_bgwriter_stat
union
select unnest(array['checkpoint_write_time', 'checkpoint_sync_time']) as variable_name, unnest(array[checkpoint_write_time, checkpoint_sync_time]::text[]) as value from dbe_perf.global_bgwriter_stat
union
select unnest(array['checkpoints_timed', 'checkpoints_req', 'buffers_checkpoint', 'buffers_clean', 'maxwritten_clean', 'buffers_backend', 'buffers_backend_fsync', 'buffers_alloc']) as variable_name, unnest(array[checkpoints_timed, checkpoints_req, buffers_checkpoint, buffers_clean, maxwritten_clean, buffers_backend, buffers_backend_fsync, buffers_alloc]::text[]) as value from dbe_perf.global_bgwriter_stat
union
select unnest(array['phyrds', 'phywrts', 'phyblkrd', 'phyblkwrt']) as variable_name, unnest(array[phyrds, phywrts, phyblkrd, phyblkwrt]::text[]) as value from dbe_perf.summary_rel_iostat
union
select 'summary_file_iostat_count' as variable_name, count(*)::text as value from dbe_perf.summary_file_iostat
union
select unnest(array['phywrts', 'phyblkwrt', 'writetim', 'avgiotim', 'lstiotim', 'miniotim', 'maxiowtm']) as variable_name, unnest(array[phywrts, phyblkwrt, writetim, avgiotim, lstiotim, miniotim, maxiowtm]::text[]) as value from dbe_perf.summary_file_redo_iostat
union
select unnest(array['node_name', 'worker_info']) as variable_name, unnest(array[node_name, worker_info]::text[]) as value from dbe_perf.global_redo_status union select unnest(array['redo_start_ptr', 'redo_start_time', 'redo_done_time', 'curr_time', 'min_recovery_point', 'read_ptr', 'last_replayed_read_ptr', 'recovery_done_ptr', 'read_xlog_io_counter', 'read_xlog_io_total_dur', 'read_data_io_counter', 'read_data_io_total_dur', 'write_data_io_counter', 'write_data_io_total_dur', 'process_pending_counter', 'process_pending_total_dur', 'apply_counter', 'apply_total_dur', 'speed', 'local_max_ptr', 'primary_flush_ptr']) as variable_name, unnest(array[redo_start_ptr, redo_start_time, redo_done_time, curr_time, min_recovery_point, read_ptr, last_replayed_read_ptr, recovery_done_ptr, read_xlog_io_counter, read_xlog_io_total_dur, read_data_io_counter, read_data_io_total_dur, write_data_io_counter, write_data_io_total_dur, process_pending_counter, process_pending_total_dur, apply_counter, apply_total_dur, speed, local_max_ptr, primary_flush_ptr]::text[]) as value from dbe_perf.global_redo_status
union
select unnest(array['node_name', 'ckpt_redo_point']) as variable_name, unnest(array[node_name, ckpt_redo_point]::text[]) as value from dbe_perf.global_ckpt_status union select unnest(array['ckpt_clog_flush_num', 'ckpt_csnlog_flush_num', 'ckpt_multixact_flush_num', 'ckpt_predicate_flush_num', 'ckpt_twophase_flush_num']) as variable_name, unnest(array[ckpt_clog_flush_num, ckpt_csnlog_flush_num, ckpt_multixact_flush_num, ckpt_predicate_flush_num, ckpt_twophase_flush_num]::text[]) as value from dbe_perf.global_ckpt_status
union
select unnest(array['databaseid', 'tablespaceid', 'relfilenode']) as variable_name, unnest(array[databaseid, tablespaceid, relfilenode]::text[]) as value from dbe_perf.summary_stat_bad_block
union
select unnest(array['forknum', 'error_count']) as variable_name, unnest(array[forknum, error_count]::text[]) as value from dbe_perf.summary_stat_bad_block
union
select unnest(array['first_time', 'last_time']) as variable_name, unnest(array[first_time, last_time]::text[]) as value from dbe_perf.summary_stat_bad_block
union
select unnest(array['node_name', 'queue_head_page_rec_lsn', 'queue_rec_lsn', 'current_xlog_insert_lsn', 'ckpt_redo_point']) as variable_name, unnest(array[node_name, queue_head_page_rec_lsn, queue_rec_lsn, current_xlog_insert_lsn, ckpt_redo_point]) as value from dbe_perf.global_pagewriter_status
union
select unnest(array['pgwr_actual_flush_total_num', 'pgwr_last_flush_num', 'remain_dirty_page_num']) as variable_name, unnest(array[pgwr_actual_flush_total_num, pgwr_last_flush_num, remain_dirty_page_num]::text[]) as value from dbe_perf.global_pagewriter_status
union
select unnest(array['confl_tablespace', 'confl_lock', 'confl_snapshot', 'confl_bufferpin', 'confl_deadlock']) as variable_name, unnest(array[confl_tablespace, confl_lock, confl_snapshot, confl_bufferpin, confl_deadlock]::text[]) as value from dbe_perf.summary_stat_database_conflicts where datname = current_database()
union
select 'wait_events_count' as variable_name, count(*)::text as value from dbe_perf.global_wait_events
union
select 'locks_count' as variable_name,count(*)::text as value from pg_locks where database in (select oid from pg_database where datname = current_database())
union
select 'datname' as variable_name, datname::text as value from pg_stat_database where datname = current_database()
union
select unnest(array['numbackends', 'xact_commit', 'xact_rollback', 'blks_read', 'blks_hit', 'tup_returned', 'tup_fetched', 'tup_inserted', 'tup_updated', 'tup_deleted', 'conflicts', 'temp_files', 'temp_bytes', 'deadlocks', 'datid']) as variable_name, unnest(array[numbackends, xact_commit, xact_rollback, blks_read, blks_hit, tup_returned, tup_fetched, tup_inserted, tup_updated, tup_deleted, conflicts, temp_files, temp_bytes, deadlocks, datid]::text[]) as value from pg_stat_database where datname = current_database()
union
select unnest(array['blk_read_time', 'blk_write_time']) as variable_name, unnest(array[blk_read_time, blk_write_time]::text[]) as value from pg_stat_database where datname = current_database()
union
select 'stats_reset' as variable_name, stats_reset::text as value from pg_stat_database where datname = current_database()
union
select unnest(array['curr_dwn', 'curr_start_page', 'file_trunc_num', 'file_reset_num', 'total_writes', 'low_threshold_writes', 'high_threshold_writes', 'total_pages', 'low_threshold_pages', 'high_threshold_pages', 'file_id']) as variable_name, unnest(array[curr_dwn, curr_start_page, file_trunc_num, file_reset_num, total_writes, low_threshold_writes, high_threshold_writes, total_pages, low_threshold_pages, high_threshold_pages, file_id]::text[]) as value from dbe_perf.global_double_write_status
union
select unnest(array['active', 'dummy_standby']) as variable_name, unnest(array[active, dummy_standby]::text[]) as value from dbe_perf.global_replication_slots
union
select 'datoid' as variable_name, datoid::text as value from dbe_perf.global_replication_slots
union
select unnest(array['node_name', 'database']) as variable_name, unnest(array[node_name, database]::text[]) as value from dbe_perf.global_replication_slots
union
select unnest(array['slot_name', 'plugin', 'slot_type', 'restart_lsn']) as variable_name, unnest(array[slot_name, plugin, slot_type, restart_lsn]) as value from dbe_perf.global_replication_slots
union
select unnest(array['x_min', 'catalog_xmin']) as variable_name, unnest(array[x_min, catalog_xmin]::text[]) as value from dbe_perf.global_replication_slots
union
select unnest(array['node_name', 'usename']) as variable_name, unnest(array[node_name, usename]::text[]) as value from dbe_perf.global_replication_stat
union
select unnest(array['pid', 'client_port', 'sync_priority']) as variable_name, unnest(array[pid, client_port, sync_priority]) as value from dbe_perf.global_replication_stat
union
select 'usesysid' as variable_name, usesysid::text as value from dbe_perf.global_replication_stat
union
select 'backend_start' as variable_name, backend_start::text as value from dbe_perf.global_replication_stat
union
select 'client_addr' as variable_name, client_addr::text as value from dbe_perf.global_replication_stat
union
select unnest(array['application_name', 'client_hostname', 'state', 'sender_sent_location', 'receiver_write_location', 'receiver_flush_location', 'receiver_replay_location', 'sync_state']) as variable_name, unnest(array[application_name, client_hostname, state, sender_sent_location, receiver_write_location, receiver_flush_location, receiver_replay_location, sync_state]) as value from dbe_perf.global_replication_stat
union
select unnest(array['owner', 'database']) as variable_name, unnest(array[owner, database]::text[]) as value from dbe_perf.summary_transactions_prepared_xacts
union
select 'transaction' as variable_name, transaction::text as value from dbe_perf.summary_transactions_prepared_xacts
union
select 'gid' as variable_name, gid as value from dbe_perf.summary_transactions_prepared_xacts
union
select 'prepared' as variable_name, prepared::text as value from dbe_perf.summary_transactions_prepared_xacts order by variable_name;
EXECUTE IMMEDIATE 'set dolphin.sql_mode=''' || sql_mode || '''';
END;
$$
LANGUAGE plpgsql;CREATE OPERATOR pg_catalog.+(
leftarg = int1, rightarg = int1, procedure = int1pl,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(int1, int1) IS 'int1pl';

CREATE OPERATOR pg_catalog.-(
leftarg = int1, rightarg = int1, procedure = int1mi,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(int1, int1) IS 'int1mi';

CREATE OPERATOR pg_catalog.*(
leftarg = int1, rightarg = int1, procedure = int1mul,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(int1, int1) IS 'int1mul';

CREATE OPERATOR pg_catalog.%(
leftarg = int1, rightarg = int1, procedure = int1mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(int1, int1) IS 'int1mod';

CREATE OPERATOR pg_catalog.&(
leftarg = int1, rightarg = int1, procedure = int1and,
commutator=operator(pg_catalog.&)
);
COMMENT ON OPERATOR pg_catalog.&(int1, int1) IS 'int1and';

CREATE OPERATOR pg_catalog.|(
leftarg = int1, rightarg = int1, procedure = int1or,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(int1, int1) IS 'int1or';

CREATE OPERATOR pg_catalog.#(
leftarg = int1, rightarg = int1, procedure = int1xor,
commutator=operator(pg_catalog.#)
);
COMMENT ON OPERATOR pg_catalog.#(int1, int1) IS 'int1xor';

CREATE OPERATOR pg_catalog.>>(
leftarg = int1, rightarg = int4, procedure = int1shr
);
COMMENT ON OPERATOR pg_catalog.>>(int1, int4) IS 'int1shr';

CREATE OPERATOR pg_catalog.<<(
leftarg = int1, rightarg = int4, procedure = int1shl
);
COMMENT ON OPERATOR pg_catalog.<<(int1, int4) IS 'int1shl';

CREATE OPERATOR pg_catalog.~(
rightarg = int1, procedure = int1not
);

CREATE OPERATOR pg_catalog.+(
rightarg = int1, procedure = int1up
);

CREATE OPERATOR pg_catalog.-(
rightarg = int1, procedure = int1um
);

CREATE OPERATOR pg_catalog.@(
rightarg = int1, procedure = int1abs
);

DROP FUNCTION IF EXISTS pg_catalog.int1_accum(numeric[], int1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int1_accum(numeric[], int1)
 RETURNS numeric[] LANGUAGE C STRICT AS  '$libdir/dolphin',  'int1_accum';

drop aggregate if exists pg_catalog.stddev_pop(int1);
create aggregate pg_catalog.stddev_pop(int1) (SFUNC=int1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

DROP FUNCTION IF EXISTS pg_catalog.int1_list_agg_transfn(internal, int1, text) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.int1_list_agg_transfn(internal, int1, text)
 RETURNS internal LANGUAGE C AS	'$libdir/dolphin',	'int1_list_agg_transfn';

DROP FUNCTION IF EXISTS pg_catalog.int1_list_agg_noarg2_transfn(internal, int1) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.int1_list_agg_noarg2_transfn(internal, int1)
 RETURNS internal LANGUAGE C  AS '$libdir/dolphin',	'int1_list_agg_noarg2_transfn';

drop aggregate if exists pg_catalog.listagg(int1,text);
create aggregate pg_catalog.listagg(int1,text) (SFUNC=int1_list_agg_transfn, finalfunc = list_agg_finalfn,  STYPE= internal);

drop aggregate if exists pg_catalog.listagg(int1);
create aggregate pg_catalog.listagg(int1) (SFUNC=int1_list_agg_noarg2_transfn, finalfunc = list_agg_finalfn,  STYPE= internal);

drop aggregate if exists pg_catalog.var_pop(int1);
create aggregate pg_catalog.var_pop(int1) (SFUNC=int1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.var_samp(int1);
create aggregate pg_catalog.var_samp(int1) (SFUNC=int1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.variance(int1);
create aggregate pg_catalog.variance(int1) (SFUNC=int1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

CREATE OR REPLACE FUNCTION pg_catalog.int12eq (
int1,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int12eq';

CREATE OR REPLACE FUNCTION pg_catalog.int12lt (
int1,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int12lt';

CREATE OR REPLACE FUNCTION pg_catalog.int12le (
int1,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int12le';

CREATE OR REPLACE FUNCTION pg_catalog.int12gt (
int1,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int12gt';

CREATE OR REPLACE FUNCTION pg_catalog.int12ge (
int1,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int12ge';

CREATE OR REPLACE FUNCTION pg_catalog.int14eq (
int1,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int14eq';

CREATE OR REPLACE FUNCTION pg_catalog.int14lt (
int1,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int14lt';

CREATE OR REPLACE FUNCTION pg_catalog.int14le (
int1,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int14le';

CREATE OR REPLACE FUNCTION pg_catalog.int14gt (
int1,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int14gt';

CREATE OR REPLACE FUNCTION pg_catalog.int14ge (
int1,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int14ge';

CREATE OR REPLACE FUNCTION pg_catalog.int18eq (
int1,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int18eq';

CREATE OR REPLACE FUNCTION pg_catalog.int18lt (
int1,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int18lt';

CREATE OR REPLACE FUNCTION pg_catalog.int18le (
int1,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int18le';

CREATE OR REPLACE FUNCTION pg_catalog.int18gt (
int1,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int18gt';

CREATE OR REPLACE FUNCTION pg_catalog.int18ge (
int1,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int18ge';

CREATE OPERATOR pg_catalog.=(
leftarg = int1, rightarg = int2, procedure = int12eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(int1, int2) IS 'int12eq';

CREATE OPERATOR pg_catalog.<(
leftarg = int1, rightarg = int2, procedure = int12lt,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<(int1, int2) IS 'int12lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = int1, rightarg = int2, procedure = int12le,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<=(int1, int2) IS 'int12le';

CREATE OPERATOR pg_catalog.>(
leftarg = int1, rightarg = int2, procedure = int12gt,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>(int1, int2) IS 'int12gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = int1, rightarg = int2, procedure = int12ge,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>=(int1, int2) IS 'int12ge';

CREATE OPERATOR pg_catalog.=(
leftarg = int1, rightarg = int4, procedure = int14eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(int1, int4) IS 'int14eq';

CREATE OPERATOR pg_catalog.<(
leftarg = int1, rightarg = int4, procedure = int14lt,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<(int1, int4) IS 'int14lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = int1, rightarg = int4, procedure = int14le,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<=(int1, int4) IS 'int14le';

CREATE OPERATOR pg_catalog.>(
leftarg = int1, rightarg = int4, procedure = int14gt,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>(int1, int4) IS 'int14gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = int1, rightarg = int4, procedure = int14ge,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>=(int1, int4) IS 'int14ge';

CREATE OPERATOR pg_catalog.=(
leftarg = int1, rightarg = int8, procedure = int18eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(int1, int8) IS 'int18eq';

CREATE OPERATOR pg_catalog.<(
leftarg = int1, rightarg = int8, procedure = int18lt,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<(int1, int8) IS 'int18lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = int1, rightarg = int8, procedure = int18le,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<=(int1, int8) IS 'int18le';

CREATE OPERATOR pg_catalog.>(
leftarg = int1, rightarg = int8, procedure = int18gt,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>(int1, int8) IS 'int18gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = int1, rightarg = int8, procedure = int18ge,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>=(int1, int8) IS 'int18ge';

CREATE OR REPLACE FUNCTION pg_catalog.int12cmp (
int1,int2
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int12cmp';

CREATE OR REPLACE FUNCTION pg_catalog.int14cmp (
int1,int4
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int14cmp';

CREATE OR REPLACE FUNCTION pg_catalog.int18cmp (
int1,int8
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int18cmp';

CREATE OPERATOR CLASS int1_ops
    FOR TYPE int1 USING btree family int1_ops AS
        OPERATOR        1       <(int1, int2),
        OPERATOR        1       <(int1, int4),
        OPERATOR        1       <(int1, int8),
        OPERATOR        2       <=(int1, int2),
        OPERATOR        2       <=(int1, int4),
        OPERATOR        2       <=(int1, int8),
        OPERATOR        3       =(int1, int2),
        OPERATOR        3       =(int1, int4),
        OPERATOR        3       =(int1, int8),
        OPERATOR        4       >=(int1, int2),
        OPERATOR        4       >=(int1, int4),
        OPERATOR        4       >=(int1, int8),
        OPERATOR        5       >(int1, int2),
        OPERATOR        5       >(int1, int4),
        OPERATOR        5       >(int1, int8),
        FUNCTION        1       int12cmp(int1, int2),
        FUNCTION        1       int14cmp(int1, int4),
        FUNCTION        1       int18cmp(int1, int8);

CREATE OPERATOR CLASS int1_ops
    FOR TYPE int1 USING cbtree family int1_ops AS
        OPERATOR        1       <(int1, int2),
        OPERATOR        1       <(int1, int4),
        OPERATOR        1       <(int1, int8),
        OPERATOR        2       <=(int1, int2),
        OPERATOR        2       <=(int1, int4),
        OPERATOR        2       <=(int1, int8),
        OPERATOR        3       =(int1, int2),
        OPERATOR        3       =(int1, int4),
        OPERATOR        3       =(int1, int8),
        OPERATOR        4       >=(int1, int2),
        OPERATOR        4       >=(int1, int4),
        OPERATOR        4       >=(int1, int8),
        OPERATOR        5       >(int1, int2),
        OPERATOR        5       >(int1, int4),
        OPERATOR        5       >(int1, int8),
        FUNCTION        1       int12cmp(int1, int2),
        FUNCTION        1       int14cmp(int1, int4),
        FUNCTION        1       int18cmp(int1, int8);

CREATE OPERATOR CLASS int1_ops
    FOR TYPE int1 USING ubtree family int1_ops AS
        OPERATOR        1       <(int1, int2),
        OPERATOR        1       <(int1, int4),
        OPERATOR        1       <(int1, int8),
        OPERATOR        2       <=(int1, int2),
        OPERATOR        2       <=(int1, int4),
        OPERATOR        2       <=(int1, int8),
        OPERATOR        3       =(int1, int2),
        OPERATOR        3       =(int1, int4),
        OPERATOR        3       =(int1, int8),
        OPERATOR        4       >=(int1, int2),
        OPERATOR        4       >=(int1, int4),
        OPERATOR        4       >=(int1, int8),
        OPERATOR        5       >(int1, int2),
        OPERATOR        5       >(int1, int4),
        OPERATOR        5       >(int1, int8),
        FUNCTION        1       int12cmp(int1, int2),
        FUNCTION        1       int14cmp(int1, int4),
        FUNCTION        1       int18cmp(int1, int8);

CREATE OPERATOR CLASS int1_ops
    FOR TYPE int1 USING hash family int1_ops AS
        OPERATOR        1       =(int1, int2),
        OPERATOR        1       =(int1, int4),
        OPERATOR        1       =(int1, int8),
        FUNCTION        1       hashint2(int2),
        FUNCTION        1       hashint4(int4),
        FUNCTION        1       hashint8(int8);
DROP FUNCTION IF EXISTS pg_catalog.to_base64 (bytea) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.to_base64 (numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.to_base64 (text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.to_base64 (bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (bytea)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode';

CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (num1 numeric)
RETURNS text
AS
$$
BEGIN
    RETURN (SELECT to_base64(cast(to_char(num1) AS bytea)));
END;
$$
LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (t1 text)
RETURNS text
AS
$$
BEGIN
    RETURN (SELECT to_base64(cast(t1 AS bytea)));
END;
$$
LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.to_base64(bit1 bit)
RETURNS text
AS
$$
BEGIN
    RETURN (SELECT to_base64((decode(hex(bit1), 'hex'))));
END;
$$
LANGUAGE plpgsql;DROP FUNCTION IF EXISTS pg_catalog.unhex (text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.unhex (numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.unhex (bool) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.unhex (bytea) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.unhex ("timestamp") CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.unhex (text)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'unhex';

CREATE OR REPLACE FUNCTION pg_catalog.unhex (num1 numeric)
RETURNS text
AS
$$
BEGIN
    RETURN (SELECT unhex(to_char(num1)));
END;
$$
LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.unhex (bool1 bool)
RETURNS text
AS
$$
BEGIN
    RETURN (SELECT unhex(cast(bool1 AS numeric)));
END;
$$
LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.unhex (bin1 bytea)
RETURNS text
AS
$$
BEGIN
    RETURN NULL;
END;
$$
LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.unhex (datetime1 "timestamp")
RETURNS text
AS
$$
BEGIN
    RETURN NULL;
END;
$$
LANGUAGE plpgsql;--------------------------------------------------------------
-- add new type  uint1
--------------------------------------------------------------
DROP TYPE IF EXISTS pg_catalog.uint1 CASCADE;
DROP TYPE IF EXISTS pg_catalog._uint1 CASCADE;

CREATE TYPE pg_catalog.uint1;

DROP FUNCTION IF EXISTS pg_catalog.uint1in(cstring) CASCADE;
CREATE FUNCTION pg_catalog.uint1in (
cstring
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1in';

DROP FUNCTION IF EXISTS pg_catalog.uint1out(uint1) CASCADE;
CREATE FUNCTION pg_catalog.uint1out (
uint1
) RETURNS cstring LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint1out';

DROP FUNCTION IF EXISTS pg_catalog.uint1send(uint1) CASCADE;
CREATE FUNCTION pg_catalog.uint1send (
uint1
) RETURNS bytea LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint1send';

DROP FUNCTION IF EXISTS pg_catalog.uint1recv(internal) CASCADE;
CREATE FUNCTION pg_catalog.uint1recv (
internal
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint1recv';

CREATE TYPE pg_catalog.uint1 (input=uint1in, output=uint1out, RECEIVE = uint1recv, SEND = uint1send,  category='C' ,INTERNALLENGTH  = 1,PASSEDBYVALUE,alignment = char);
COMMENT ON TYPE pg_catalog.uint1 IS 'uint1';
COMMENT ON TYPE pg_catalog._uint1 IS '_uint1';

-- add new type  uint2
--------------------------------------------------------------
DROP TYPE IF EXISTS pg_catalog.uint2 CASCADE;
DROP TYPE IF EXISTS pg_catalog._uint2 CASCADE;

CREATE TYPE pg_catalog.uint2;

DROP FUNCTION IF EXISTS pg_catalog.uint2in(cstring) CASCADE;
CREATE FUNCTION pg_catalog.uint2in (
cstring
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2in';

DROP FUNCTION IF EXISTS pg_catalog.uint2out(uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2out (
uint2
) RETURNS cstring LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint2out';

DROP FUNCTION IF EXISTS pg_catalog.uint2send(uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2send (
uint2

) RETURNS bytea LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint2send';

DROP FUNCTION IF EXISTS pg_catalog.uint2recv(internal) CASCADE;
CREATE FUNCTION pg_catalog.uint2recv (
internal
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint2recv';

CREATE TYPE pg_catalog.uint2 (input=uint2in, output=uint2out, RECEIVE = uint2recv, SEND = uint2send,  category='C' ,INTERNALLENGTH  = 2,PASSEDBYVALUE,alignment = int2);
COMMENT ON TYPE pg_catalog.uint2 IS 'uint2';
COMMENT ON TYPE pg_catalog._uint2 IS '_uint2';

-- add new type  uint4
--------------------------------------------------------------
DROP TYPE IF EXISTS pg_catalog.uint4 CASCADE;
DROP TYPE IF EXISTS pg_catalog._uint4 CASCADE;

CREATE TYPE pg_catalog.uint4;

DROP FUNCTION IF EXISTS pg_catalog.uint4in(cstring) CASCADE;
CREATE FUNCTION pg_catalog.uint4in (
cstring
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4in';

DROP FUNCTION IF EXISTS pg_catalog.uint4out(uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4out (
uint4
) RETURNS cstring LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint4out';

DROP FUNCTION IF EXISTS pg_catalog.uint4send(uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4send (
uint4

) RETURNS bytea LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint4send';

DROP FUNCTION IF EXISTS pg_catalog.uint4recv(internal) CASCADE;
CREATE FUNCTION pg_catalog.uint4recv (
internal
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint4recv';

CREATE TYPE pg_catalog.uint4 (input=uint4in, output=uint4out, RECEIVE = uint4recv, SEND = uint4send,  category='C' ,INTERNALLENGTH  = 4,PASSEDBYVALUE,alignment = int4);
COMMENT ON TYPE pg_catalog.uint4 IS 'uint4';
COMMENT ON TYPE pg_catalog._uint4 IS '_uint4';

-- add new type  uint8
--------------------------------------------------------------
DROP TYPE IF EXISTS pg_catalog.uint8 CASCADE;
DROP TYPE IF EXISTS pg_catalog._uint8 CASCADE;

CREATE TYPE pg_catalog.uint8;

DROP FUNCTION IF EXISTS pg_catalog.uint8in(cstring) CASCADE;
CREATE FUNCTION pg_catalog.uint8in (
cstring
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8in';

DROP FUNCTION IF EXISTS pg_catalog.uint8out(uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8out (
uint8
) RETURNS cstring LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint8out';

DROP FUNCTION IF EXISTS pg_catalog.uint8send(uint1) CASCADE;
CREATE FUNCTION pg_catalog.uint8send (
uint8
) RETURNS bytea LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint8send';

DROP FUNCTION IF EXISTS pg_catalog.uint8recv(internal) CASCADE;
CREATE FUNCTION pg_catalog.uint8recv (
internal
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint8recv';

CREATE TYPE pg_catalog.uint8 (input=uint8in, output=uint8out, RECEIVE = uint8recv, SEND = uint8send,  category='C' ,INTERNALLENGTH  = 8,PASSEDBYVALUE ,alignment = double);
COMMENT ON TYPE pg_catalog.uint8 IS 'uint8';
COMMENT ON TYPE pg_catalog._uint8 IS '_uint8';

----------------------------------------------------------------
-- add function
----------------------------------------------------------------
DROP FUNCTION IF EXISTS pg_catalog.i1toui1(int1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.i2toui1(int2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.i4toui1(int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.i8toui1(int8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.f4toui1(float4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.f8toui1(float8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui2toui1(uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui4toui1(uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui8toui1(uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.numeric_uint1(numeric) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.ui1toui2(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui1toui4(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui1toui8(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui1toi1(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui1toi2(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui1toi4(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui1toi8(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui1tof4(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui1tof8(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1_numeric(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1smaller(uint1,uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1larger(uint1,uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1eq(uint1,uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1ne(uint1,uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1lt(uint1,uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1le(uint1,uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1gt(uint1,uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1ge(uint1,uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1cmp(uint1,uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint12cmp(uint1,uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint14cmp(uint1,uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint18cmp(uint1,uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1_int1cmp(uint1,int1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1_int2cmp(uint1,int2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1_int4cmp(uint1,int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1_int8cmp(uint1,int8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.hashuint1(uint1) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.i1toui1 (
int1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1toui1';

CREATE OR REPLACE FUNCTION pg_catalog.i2toui1 (
int2
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i2toui1';

CREATE OR REPLACE FUNCTION pg_catalog.i4toui1 (
int4
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i4toui1';

CREATE OR REPLACE FUNCTION pg_catalog.i8toui1 (
int8
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i8toui1';

CREATE OR REPLACE FUNCTION pg_catalog.f4toui1 (
float4
) RETURNS  uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f4toui1';
CREATE OR REPLACE FUNCTION pg_catalog.f8toui1 (
float8
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f8toui1';

CREATE OR REPLACE FUNCTION pg_catalog.ui2toui1 (
uint2
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui2toui1';

CREATE OR REPLACE FUNCTION pg_catalog.ui4toui1 (
uint4
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui4toui1';

CREATE OR REPLACE FUNCTION pg_catalog.ui8toui1 (
uint8
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui8toui1';

CREATE OR REPLACE FUNCTION pg_catalog.numeric_uint1 (
Numeric
) RETURNS  uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'numeric_uint1';

CREATE OR REPLACE FUNCTION pg_catalog.ui1toi1 (
uint1
) RETURNS int1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui1toi1';
CREATE OR REPLACE FUNCTION pg_catalog.ui1toi2 (
uint1
) RETURNS int2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui1toi2';

CREATE OR REPLACE FUNCTION pg_catalog.ui1toi4 (
uint1
) RETURNS  int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui1toi4';
CREATE OR REPLACE FUNCTION pg_catalog.ui1toi8 (
uint1
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui1toi8';

CREATE OR REPLACE FUNCTION pg_catalog.ui1tof4 (
uint1
) RETURNS  float4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui1tof4';
CREATE OR REPLACE FUNCTION pg_catalog.ui1tof8 (
uint1
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui1tof8';

CREATE OR REPLACE FUNCTION pg_catalog.ui1toui2 (
uint1
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui1toui2';

CREATE OR REPLACE FUNCTION pg_catalog.ui1toui4 (
uint1
) RETURNS  uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui1toui4';
CREATE OR REPLACE FUNCTION pg_catalog.ui1toui8 (
uint1
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui1toui8';

CREATE OR REPLACE FUNCTION pg_catalog.uint1_numeric (
uint1
) RETURNS Numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_numeric';

CREATE OR REPLACE FUNCTION pg_catalog.uint1smaller (
uint1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1smaller';

CREATE OR REPLACE FUNCTION pg_catalog.uint1larger (
uint1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1larger';

CREATE OR REPLACE FUNCTION pg_catalog.uint1eq (
uint1,uint1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1eq';

CREATE OR REPLACE FUNCTION pg_catalog.uint1ne (
uint1,uint1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1ne';

CREATE OR REPLACE FUNCTION pg_catalog.uint1lt (
uint1,uint1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1lt';

CREATE OR REPLACE FUNCTION pg_catalog.uint1le (
uint1,uint1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1le';

CREATE OR REPLACE FUNCTION pg_catalog.uint1gt (
uint1,uint1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1gt';

CREATE OR REPLACE FUNCTION pg_catalog.uint1ge (
uint1,uint1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1ge';

CREATE OR REPLACE FUNCTION pg_catalog.uint1cmp (
uint1,uint1
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1cmp';

CREATE OR REPLACE FUNCTION pg_catalog.uint12cmp (
uint1,uint2
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint12cmp';

CREATE OR REPLACE FUNCTION pg_catalog.uint14cmp (
uint1,uint4
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint14cmp';

CREATE OR REPLACE FUNCTION pg_catalog.uint18cmp (
uint1,uint8
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint18cmp';

CREATE OR REPLACE FUNCTION pg_catalog.uint1_int1cmp (
uint1,int1
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int1cmp';

CREATE OR REPLACE FUNCTION pg_catalog.uint1_int2cmp (
uint1,int2
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int2cmp';

CREATE OR REPLACE FUNCTION pg_catalog.uint1_int4cmp (
uint1,int4
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int4cmp';

CREATE OR REPLACE FUNCTION pg_catalog.uint1_int8cmp (
uint1,int8
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int8cmp';

CREATE OR REPLACE FUNCTION pg_catalog.hashuint1 (
uint1
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'hashuint1';

DROP FUNCTION IF EXISTS pg_catalog.NUMTODAY(uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.NUMTODAY(uint1)
RETURNS INTERVAL
AS $$ SELECT NUMTODSINTERVAL(uint1_numeric($1),'DAY')$$
LANGUAGE SQL IMMUTABLE STRICT;

DROP FUNCTION IF EXISTS pg_catalog.TO_TEXT(uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.TO_TEXT(UINT1)
RETURNS TEXT
AS $$ select CAST(uint1out($1) AS VARCHAR2)  $$
LANGUAGE SQL  STRICT IMMUTABLE;

DROP FUNCTION IF EXISTS pg_catalog.uint1pl(uint1,uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1pl (
uint1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1pl';

DROP FUNCTION IF EXISTS pg_catalog.uint1mi(uint1,uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1mi (
uint1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1mi';

DROP FUNCTION IF EXISTS pg_catalog.uint1mul(uint1,uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1mul (
uint1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1mul';

DROP FUNCTION IF EXISTS pg_catalog.uint1div(uint1,uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1div (
uint1,uint1
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1div';

DROP FUNCTION IF EXISTS pg_catalog.uint1abs(uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1abs (
uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1abs';

DROP FUNCTION IF EXISTS pg_catalog.uint1mod(uint1,uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1mod (
uint1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1mod';

DROP FUNCTION IF EXISTS pg_catalog.uint1and(uint1,uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1and (
uint1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1and';

DROP FUNCTION IF EXISTS pg_catalog.uint1or(uint1,uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1or (
uint1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1or';

DROP FUNCTION IF EXISTS pg_catalog.uint1xor(uint1,uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1xor (
uint1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1xor';

DROP FUNCTION IF EXISTS pg_catalog.uint1um(uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1um (
uint1
) RETURNS int2 LANGUAGE C STRICT IMMUTABLE  as '$libdir/dolphin',  'uint1um';

DROP FUNCTION IF EXISTS pg_catalog.uint1not(uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1not (
uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1not';

DROP FUNCTION IF EXISTS pg_catalog.uint1up(uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1up (
uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1up';

DROP FUNCTION IF EXISTS pg_catalog.uint1_avg_accum(bigint[], uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1_avg_accum(bigint[], uint1)
 RETURNS bigint[] LANGUAGE C STRICT AS  '$libdir/dolphin',  'uint1_avg_accum';
 
DROP FUNCTION IF EXISTS pg_catalog.uint1_accum(numeric[], uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1_accum(numeric[], uint1)
 RETURNS numeric[] LANGUAGE C STRICT AS  '$libdir/dolphin',  'uint1_accum';
 
DROP FUNCTION IF EXISTS pg_catalog.uint1_sum(int8, uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1_sum(int8, uint1)
RETURNS int8 LANGUAGE C AS  '$libdir/dolphin',  'uint1_sum';

DROP FUNCTION IF EXISTS pg_catalog.uint1_bool(uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1_bool(uint1)
RETURNS bool LANGUAGE C STRICT AS  '$libdir/dolphin',  'uint1_bool';

DROP FUNCTION IF EXISTS pg_catalog.bool_uint1(bool) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bool_uint1(bool)
RETURNS uint1 LANGUAGE C STRICT AS  '$libdir/dolphin',  'bool_uint1';

CREATE OR REPLACE FUNCTION pg_catalog.CAST_TO_UNSIGNED(NUM NUMBER)
RETURNS UINT8
AS $$
BEGIN
    IF NUM IS NULL THEN
        RETURN NULL;
    ELSIF REGEXP_LIKE(NUM, '-.*\.') THEN
        RETURN 0;
    ELSIF NUM < -9223372036854775808 THEN
        RETURN 0;
    ELSIF NUM >= -9223372036854775808 and NUM < 0 THEN
        RETURN NUM + 18446744073709551616;
    ELSEIF NUM >= 0 and NUM <= 18446744073709551615 THEN
        RETURN NUM;
    ELSIF NUM > 18446744073709551615 THEN
		RETURN 18446744073709551615;
    END IF;
END;
$$ LANGUAGE PLPGSQL;

DROP FUNCTION IF EXISTS pg_catalog.uint1_list_agg_transfn(internal, uint1, text) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint1_list_agg_transfn(internal, uint1, text)
 RETURNS internal LANGUAGE C AS	'$libdir/dolphin',	'uint1_list_agg_transfn';

DROP FUNCTION IF EXISTS pg_catalog.uint1_list_agg_noarg2_transfn(internal, uint1) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint1_list_agg_noarg2_transfn(internal, uint1)
 RETURNS internal LANGUAGE C  AS '$libdir/dolphin',	'uint1_list_agg_noarg2_transfn';

 DROP FUNCTION IF EXISTS pg_catalog.numeric_cast_uint1(numeric) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.numeric_cast_uint1 (
numeric
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'numeric_cast_uint1';

DROP FUNCTION IF EXISTS pg_catalog.numeric_cast_uint2(numeric) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.numeric_cast_uint2 (
numeric
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'numeric_cast_uint2';

DROP FUNCTION IF EXISTS pg_catalog.numeric_cast_uint4(numeric) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.numeric_cast_uint4 (
numeric
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'numeric_cast_uint4';

DROP FUNCTION IF EXISTS pg_catalog.numeric_cast_uint8(numeric) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.numeric_cast_uint8 (
numeric
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'numeric_cast_uint8';
----------------------------------------------------------------
-- add cast
----------------------------------------------------------------
drop  CAST  IF EXISTS (int4 AS  uint1) CASCADE;
drop  CAST  IF EXISTS (int8 AS  uint1) CASCADE;
drop  CAST  IF EXISTS (int2 AS  uint1) CASCADE;
drop  CAST  IF EXISTS (int1 AS  uint1) CASCADE;
            
drop  CAST  IF EXISTS (TEXT AS  uint1) CASCADE;
drop  CAST  IF EXISTS (numeric AS  uint1) CASCADE;
drop  CAST  IF EXISTS (uint4 AS  uint1) CASCADE;
drop  CAST  IF EXISTS (uint8 AS  uint1) CASCADE;
drop  CAST  IF EXISTS (uint2 AS  uint1) CASCADE;
            
drop  CAST  IF EXISTS (uint1 AS  int4) CASCADE;
drop  CAST  IF EXISTS (uint1 AS  int8) CASCADE;
drop  CAST  IF EXISTS (uint1 AS  int2) CASCADE;
drop  CAST  IF EXISTS (uint1 AS  int1) CASCADE;
drop  CAST  IF EXISTS (uint1 AS  TEXT) CASCADE;
drop  CAST  IF EXISTS (uint1 AS  numeric) CASCADE;
drop  CAST  IF EXISTS (uint1 AS  INTERVAL) CASCADE;
drop  CAST  IF EXISTS (uint1 AS  uint4) CASCADE;
drop  CAST  IF EXISTS (uint1 AS  uint8) CASCADE;
drop  CAST  IF EXISTS (uint1 AS  uint2) CASCADE;
drop  CAST  IF EXISTS (uint1 AS  bool) CASCADE;
drop  CAST  IF EXISTS (bool AS  uint1) CASCADE;

CREATE CAST (int4 AS uint1) WITH FUNCTION i4toui1(int4) AS IMPLICIT;
CREATE CAST (int8 AS uint1) WITH FUNCTION i8toui1(int8) AS IMPLICIT;
CREATE CAST (int2 AS uint1) WITH FUNCTION i2toui1(int2) AS IMPLICIT;
CREATE CAST (int1 AS uint1) WITH FUNCTION i1toui1(int1) AS IMPLICIT;
CREATE CAST (float4 AS uint1) WITH FUNCTION f4toui1(float4) AS IMPLICIT;
CREATE CAST (float8 AS uint1) WITH FUNCTION f8toui1(float8) AS IMPLICIT;
CREATE CAST (uint8 AS uint1) WITH FUNCTION ui8toui1(uint8) AS IMPLICIT;
CREATE CAST (uint4 AS uint1) WITH FUNCTION ui4toui1(uint4) AS IMPLICIT;
CREATE CAST (uint2 AS uint1) WITH FUNCTION ui2toui1(uint2) AS IMPLICIT;

CREATE CAST (uint1 AS int1) WITH FUNCTION ui1toi1(uint1) AS IMPLICIT;
CREATE CAST (uint1 AS int4) WITH FUNCTION ui1toi4(uint1) AS IMPLICIT;
CREATE CAST (uint1 AS int8) WITH FUNCTION ui1toi8(uint1) AS IMPLICIT;
CREATE CAST (uint1 AS int2) WITH FUNCTION ui1toi2(uint1) AS IMPLICIT;
CREATE CAST (uint1 AS float4) WITH FUNCTION ui1tof4(uint1) AS IMPLICIT;
CREATE CAST (uint1 AS float8) WITH FUNCTION ui1tof8(uint1) AS IMPLICIT;
CREATE CAST (uint1 AS uint2) WITH FUNCTION ui1toui2(uint1) AS IMPLICIT;
CREATE CAST (uint1 AS uint4) WITH FUNCTION ui1toui4(uint1) AS IMPLICIT;
CREATE CAST (uint1 AS uint8) WITH FUNCTION ui1toui8(uint1) AS IMPLICIT;
CREATE CAST (uint1 AS bool) WITH FUNCTION uint1_bool(uint1) AS IMPLICIT;
CREATE CAST (bool AS uint1) WITH FUNCTION bool_uint1(bool) AS IMPLICIT;

CREATE CAST (UINT1 AS TEXT) WITH FUNCTION TO_TEXT(UINT1) AS IMPLICIT;
CREATE CAST (UINT1 AS numeric) WITH FUNCTION uint1_numeric(UINT1) AS IMPLICIT;
CREATE CAST (numeric AS UINT1) WITH FUNCTION numeric_uint1(Numeric) AS IMPLICIT;

CREATE CAST (UINT1 AS INTERVAL) WITH FUNCTION NUMTODAY(UINT1) AS IMPLICIT;
----------------------------------------------------------------
-- add  OPERATOR 
----------------------------------------------------------------

CREATE OPERATOR pg_catalog.=(
leftarg = uint1, rightarg = uint1, procedure = uint1eq,
commutator=operator(pg_catalog.=),
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint1, uint1) IS 'uint1eq';

CREATE OPERATOR pg_catalog.<>(
leftarg = uint1, rightarg = uint1, procedure = uint1ne,
restrict = neqsel, join = neqjoinsel
);
COMMENT ON OPERATOR pg_catalog.<>(uint1, uint1) IS 'uint1ne';

CREATE OPERATOR pg_catalog.<(
leftarg = uint1, rightarg = uint1, procedure = uint1lt,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<(uint1, uint1) IS 'uint1lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint1, rightarg = uint1, procedure = uint1le,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<=(uint1, uint1) IS 'uint1le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint1, rightarg = uint1, procedure = uint1gt,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>(uint1, uint1) IS 'uint1gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint1, rightarg = uint1, procedure = uint1ge,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>=(uint1, uint1) IS 'uint1ge';

CREATE OPERATOR pg_catalog.+(
leftarg = uint1, rightarg = uint1, procedure = uint1pl,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(uint1, uint1) IS 'uint1pl';

CREATE OPERATOR pg_catalog.-(
leftarg = uint1, rightarg = uint1, procedure = uint1mi,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(uint1, uint1) IS 'uint1mi';

CREATE OPERATOR pg_catalog.*(
leftarg = uint1, rightarg = uint1, procedure = uint1mul,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(uint1, uint1) IS 'uint1mul';

CREATE OPERATOR pg_catalog./(
leftarg = uint1, rightarg = uint1, procedure = uint1div,
commutator=operator(pg_catalog./)
);
COMMENT ON OPERATOR pg_catalog./(uint1, uint1) IS 'uint1div';

CREATE OPERATOR pg_catalog.@(
rightarg = uint1,  procedure = uint1abs

);

CREATE OPERATOR pg_catalog.%(
leftarg = uint1, rightarg = uint1, procedure = uint1mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(uint1, uint1) IS 'uint1mod';

CREATE OPERATOR pg_catalog.+(
rightarg = uint1, procedure = uint1up
);

CREATE OPERATOR pg_catalog.-(
rightarg = uint1, procedure = uint1um
);

CREATE OR REPLACE FUNCTION pg_catalog.uint1(text)
RETURNS uint1
LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_uint1';
CREATE CAST (TEXT AS UINT1) WITH FUNCTION UINT1(TEXT) AS IMPLICIT;
DROP FUNCTION IF EXISTS pg_catalog.uint1_int1_mod(uint1,int1) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int1_mod (
uint1,int1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int1_mod';
CREATE OPERATOR pg_catalog.%(
leftarg = uint1, rightarg = int1, procedure = uint1_int1_mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(uint1, int1) IS 'uint1_int1_mod';

DROP FUNCTION IF EXISTS pg_catalog.int1_uint1_mod(int1,uint1) CASCADE;
CREATE FUNCTION pg_catalog.int1_uint1_mod (
int1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_uint1_mod';
CREATE OPERATOR pg_catalog.%(
leftarg = int1, rightarg = uint1, procedure = int1_uint1_mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(int1, uint1) IS 'int1_uint1_mod';

-------------------uint1 int 1---------------

DROP FUNCTION IF EXISTS pg_catalog.uint1_pl_int1(uint1,int1) CASCADE;
CREATE FUNCTION pg_catalog.uint1_pl_int1 (
uint1,int1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_pl_int1';

DROP FUNCTION IF EXISTS pg_catalog.uint1_mi_int1(uint1,int1) CASCADE;
CREATE FUNCTION pg_catalog.uint1_mi_int1 (
uint1,int1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_mi_int1';

DROP FUNCTION IF EXISTS pg_catalog.uint1_mul_int1(uint1,int1) CASCADE;
CREATE FUNCTION pg_catalog.uint1_mul_int1 (
uint1,int1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_mul_int1';

DROP FUNCTION IF EXISTS pg_catalog.uint1_div_int1(uint1,int1) CASCADE;
CREATE FUNCTION pg_catalog.uint1_div_int1 (
uint1,int1
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_div_int1';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int1_eq(uint1,int1) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int1_eq (
uint1,int1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int1_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int1_ne(uint1,int1) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int1_ne (
uint1,int1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int1_ne';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int1_lt(uint1,int1) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int1_lt (
uint1,int1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int1_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int1_le(uint1,int1) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int1_le (
uint1,int1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int1_le';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int1_gt(uint1,int1) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int1_gt (
uint1,int1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int1_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int1_ge(uint1,int1) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int1_ge (
uint1,int1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int1_ge';

CREATE OPERATOR pg_catalog.+(
leftarg = uint1, rightarg = int1, procedure = uint1_pl_int1,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(uint1, int1) IS 'uint1_pl_int1';

CREATE OPERATOR pg_catalog.-(
leftarg = uint1, rightarg = int1, procedure = uint1_mi_int1,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(uint1, int1) IS 'uint1_mi_int1';

CREATE OPERATOR pg_catalog.*(
leftarg = uint1, rightarg = int1, procedure = uint1_mul_int1,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(uint1, int1) IS 'uint1_mul_int1';

CREATE OPERATOR pg_catalog./(
leftarg = uint1, rightarg = int1, procedure = uint1_div_int1,
commutator=operator(pg_catalog./)
);
COMMENT ON OPERATOR pg_catalog./(uint1, int1) IS 'uint1_div_int1';

CREATE OPERATOR pg_catalog.=(
leftarg = uint1, rightarg = int1, procedure = uint1_int1_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint1, int1) IS 'uint1_int1_eq';

CREATE OPERATOR pg_catalog.<>(
leftarg = uint1, rightarg = int1, procedure = uint1_int1_ne
);
COMMENT ON OPERATOR pg_catalog.<>(uint1, int1) IS 'uint1_int1_ne';

CREATE OPERATOR pg_catalog.<(
leftarg = uint1, rightarg = int1, procedure = uint1_int1_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint1, int1) IS 'uint1_int1_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint1, rightarg = int1, procedure = uint1_int1_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint1, int1) IS 'uint1_int1_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint1, rightarg = int1, procedure = uint1_int1_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint1, int1) IS 'uint1_int1_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint1, rightarg = int1, procedure = uint1_int1_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint1, int1) IS 'uint1_int1_ge';
-------------------uint1 int 1---------------

-------------------int1 uint1---------------

DROP FUNCTION IF EXISTS pg_catalog.int1_pl_uint1(int1,uint1) CASCADE;
CREATE FUNCTION pg_catalog.int1_pl_uint1 (
int1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_pl_uint1';

DROP FUNCTION IF EXISTS pg_catalog.int1_mi_uint1(int1,uint1) CASCADE;
CREATE FUNCTION pg_catalog.int1_mi_uint1 (
int1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_mi_uint1';
DROP FUNCTION IF EXISTS pg_catalog.int1_mul_uint1(int1,uint1) CASCADE;
CREATE FUNCTION pg_catalog.int1_mul_uint1 (
int1,uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_mul_uint1';

DROP FUNCTION IF EXISTS pg_catalog.int1_div_uint1(int1,uint1) CASCADE;
CREATE FUNCTION pg_catalog.int1_div_uint1 (
int1,uint1
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_div_uint1';

DROP FUNCTION IF EXISTS pg_catalog.int1_uint1_eq(int1,uint1) CASCADE;
CREATE FUNCTION pg_catalog.int1_uint1_eq (
int1,uint1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_uint1_eq';

DROP FUNCTION IF EXISTS pg_catalog.int1_uint1_ne(int1,uint1) CASCADE;
CREATE FUNCTION pg_catalog.int1_uint1_ne (
int1,uint1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_uint1_ne';

DROP FUNCTION IF EXISTS pg_catalog.int1_uint1_lt(int1,uint1) CASCADE;
CREATE FUNCTION pg_catalog.int1_uint1_lt (
int1,uint1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_uint1_lt';

DROP FUNCTION IF EXISTS pg_catalog.int1_uint1_le(int1,uint1) CASCADE;
CREATE FUNCTION pg_catalog.int1_uint1_le (
int1,uint1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_uint1_le';

DROP FUNCTION IF EXISTS pg_catalog.int1_uint1_gt(int1,uint1) CASCADE;
CREATE FUNCTION pg_catalog.int1_uint1_gt (
int1,uint1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_uint1_gt';

DROP FUNCTION IF EXISTS pg_catalog.int1_uint1_ge(int1,uint1) CASCADE;
CREATE FUNCTION pg_catalog.int1_uint1_ge (
int1,uint1
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_uint1_ge';

CREATE OPERATOR pg_catalog.+(
leftarg = int1, rightarg = uint1, procedure = int1_pl_uint1,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(int1, uint1) IS 'int1_pl_uint1';

CREATE OPERATOR pg_catalog.-(
leftarg = int1, rightarg = uint1, procedure = int1_mi_uint1,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(int1, uint1) IS 'int1_mi_uint1';

CREATE OPERATOR pg_catalog.*(
leftarg = int1, rightarg = uint1, procedure = int1_mul_uint1,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(int1, uint1) IS 'int1_mul_uint1';

CREATE OPERATOR pg_catalog./(
leftarg = int1, rightarg = uint1, procedure = int1_div_uint1,
commutator=operator(pg_catalog./)
);
COMMENT ON OPERATOR pg_catalog./(int1, uint1) IS 'int1_div_uint1';

CREATE OPERATOR pg_catalog.=(
leftarg = int1, rightarg = uint1, procedure = int1_uint1_eq,
commutator=operator(pg_catalog.=),
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(int1, uint1) IS 'int1_uint1_eq';

CREATE OPERATOR pg_catalog.<>(
leftarg = int1, rightarg = uint1, procedure = int1_uint1_ne
);
COMMENT ON OPERATOR pg_catalog.<>(int1, uint1) IS 'int1_uint1_ne';

CREATE OPERATOR pg_catalog.<(
leftarg = int1, rightarg = uint1, procedure = int1_uint1_lt
);
COMMENT ON OPERATOR pg_catalog.<(int1, uint1) IS 'int1_uint1_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = int1, rightarg = uint1, procedure = int1_uint1_le
);
COMMENT ON OPERATOR pg_catalog.<=(int1, uint1) IS 'int1_uint1_le';

CREATE OPERATOR pg_catalog.>(
leftarg = int1, rightarg = uint1, procedure = int1_uint1_gt
);
COMMENT ON OPERATOR pg_catalog.>(int1, uint1) IS 'int1_uint1_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = int1, rightarg = uint1, procedure = int1_uint1_ge
);
COMMENT ON OPERATOR pg_catalog.>=(int1, uint1) IS 'int1_uint1_ge';

-------------------int1 uint1---------------

----------------------------------------------------------------
-- add  agg 
----------------------------------------------------------------

drop aggregate if exists pg_catalog.avg(uint1);
create aggregate pg_catalog.avg(uint1) (SFUNC=uint1_avg_accum, cFUNC=int8_avg_collect, STYPE= bigint[], finalfunc = int8_avg, initcond = '{0,0}', initcollect = '{0,0}');

drop aggregate if exists pg_catalog.sum(uint1);
create aggregate pg_catalog.sum(uint1) (SFUNC=uint1_sum, cFUNC=int8_sum_to_int8, STYPE= int8 );

drop aggregate if exists pg_catalog.min(uint1);
create aggregate pg_catalog.min(uint1) (SFUNC=uint1smaller,cFUNC = uint1smaller,  STYPE= uint1,SORTOP = '<');

drop aggregate if exists pg_catalog.max(uint1);
create aggregate pg_catalog.max(uint1) (SFUNC=uint1larger, cFUNC=uint1larger, STYPE= uint1,SORTOP = '>');

drop aggregate if exists pg_catalog.var_samp(uint1);
create aggregate pg_catalog.var_samp(uint1) (SFUNC=uint1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.var_pop(uint1);
create aggregate pg_catalog.var_pop(uint1) (SFUNC=uint1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.variance(uint1);
create aggregate pg_catalog.variance(uint1) (SFUNC=uint1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.stddev_pop(uint1);
create aggregate pg_catalog.stddev_pop(uint1) (SFUNC=uint1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.stddev_samp(uint1);
create aggregate pg_catalog.stddev_samp(uint1) (SFUNC=uint1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.stddev(uint1);
create aggregate pg_catalog.stddev(uint1) (SFUNC=uint1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.std(uint1);
create aggregate pg_catalog.std(uint1) (SFUNC=uint1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.bit_and(uint1);
create aggregate pg_catalog.bit_and(uint1) (SFUNC=uint1and, cFUNC = uint1and, STYPE= uint1);

drop aggregate if exists pg_catalog.bit_or(uint1);
create aggregate pg_catalog.bit_or(uint1) (SFUNC=uint1or, cFUNC = uint1or,  STYPE= uint1);
drop aggregate if exists pg_catalog.bit_xor(uint1);
create aggregate pg_catalog.bit_xor(uint1) (SFUNC=uint1xor, cFUNC = uint1xor,  STYPE= uint1);

drop aggregate if exists pg_catalog.listagg(uint1,text);
create aggregate pg_catalog.listagg(uint1,text) (SFUNC=uint1_list_agg_transfn, finalfunc = list_agg_finalfn,  STYPE= internal);

drop aggregate if exists pg_catalog.listagg(uint1);
create aggregate pg_catalog.listagg(uint1) (SFUNC=uint1_list_agg_noarg2_transfn, finalfunc = list_agg_finalfn,  STYPE= internal);

----------------------------------------------------------------
-- add UNIT2
----------------------------------------------------------------

----------------------------------------------------------------
-- add function
----------------------------------------------------------------
DROP FUNCTION IF EXISTS pg_catalog.i1toui2(int1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.i2toui2(int2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.i4toui2(int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.i8toui2(int8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.f4toui2(float4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.f8toui2(float8) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.ui4toui2(uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui8toui2(uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.numeric_uint2(numeric) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.ui2toui4(uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui2toui8(uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui2toi1(uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui2toi2(uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui2toi4(uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui2toi8(uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui2tof4(uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui2tof8(uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2_numeric(uint2) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint2smaller(uint2,uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2larger(uint2,uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2eq(uint2,uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2ne(uint2,uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2lt(uint2,uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2le(uint2,uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2gt(uint2,uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2ge(uint2,uint2) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint2cmp(uint2,uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint24cmp(uint2,uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint28cmp(uint2,uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2_int2cmp(uint2,int2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2_int4cmp(uint2,int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2_int8cmp(uint2,int8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.hashuint2(uint2) CASCADE;

CREATE FUNCTION pg_catalog.i1toui2 (
int1
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1toui2';

CREATE FUNCTION pg_catalog.i2toui2 (
int2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i2toui2';

CREATE FUNCTION pg_catalog.i4toui2 (
int4
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i4toui2';

CREATE FUNCTION pg_catalog.i8toui2 (
int8
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i8toui2';

CREATE FUNCTION pg_catalog.f4toui2 (
float4
) RETURNS  uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f4toui2';
CREATE FUNCTION pg_catalog.f8toui2 (
float8
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f8toui2';

CREATE FUNCTION pg_catalog.ui4toui2 (
uint4
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui4toui2';

CREATE FUNCTION pg_catalog.ui8toui2 (
uint8
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui8toui2';

CREATE FUNCTION pg_catalog.numeric_uint2 (
Numeric
) RETURNS  uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'numeric_uint2';

CREATE FUNCTION pg_catalog.ui2toi1 (
uint2
) RETURNS int1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui2toi1';
CREATE FUNCTION pg_catalog.ui2toi2 (
uint2
) RETURNS int2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui2toi2';

CREATE FUNCTION pg_catalog.ui2toi4 (
uint2
) RETURNS  int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui2toi4';
CREATE FUNCTION pg_catalog.ui2toi8 (
uint2
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui2toi8';

CREATE FUNCTION pg_catalog.ui2tof4 (
uint2
) RETURNS  float4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui2tof4';
CREATE FUNCTION pg_catalog.ui2tof8 (
uint2
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui2tof8';

CREATE FUNCTION pg_catalog.ui2toui4 (
uint2
) RETURNS  uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui2toui4';
CREATE FUNCTION pg_catalog.ui2toui8 (
uint2
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui2toui8';

CREATE FUNCTION pg_catalog.uint2_numeric (
uint2
) RETURNS Numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_numeric';

CREATE FUNCTION pg_catalog.uint2smaller (
uint2,uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2smaller';

CREATE FUNCTION pg_catalog.uint2larger (
uint2,uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2larger';

CREATE FUNCTION pg_catalog.uint2eq (
uint2,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2eq';

CREATE FUNCTION pg_catalog.uint2ne (
uint2,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2ne';

CREATE FUNCTION pg_catalog.uint2lt (
uint2,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2lt';

CREATE FUNCTION pg_catalog.uint2le (
uint2,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2le';

CREATE FUNCTION pg_catalog.uint2gt (
uint2,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2gt';

CREATE FUNCTION pg_catalog.uint2ge (
uint2,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2ge';

CREATE FUNCTION pg_catalog.uint2cmp (
uint2,uint2
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2cmp';

CREATE FUNCTION pg_catalog.uint24cmp (
uint2,uint4
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint24cmp';

CREATE FUNCTION pg_catalog.uint28cmp (
uint2,uint8
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint28cmp';

CREATE FUNCTION pg_catalog.uint2_int2cmp (
uint2,int2
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int2cmp';

CREATE FUNCTION pg_catalog.uint2_int4cmp (
uint2,int4
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int4cmp';

CREATE FUNCTION pg_catalog.uint2_int8cmp (
uint2,int8
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int8cmp';

CREATE FUNCTION pg_catalog.hashuint2 (
uint2
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'hashuint2';

CREATE OR REPLACE FUNCTION pg_catalog.NUMTODAY(uint2)
RETURNS INTERVAL
AS $$ SELECT NUMTODSINTERVAL(uint2_numeric($1),'DAY')$$
LANGUAGE SQL IMMUTABLE STRICT;

CREATE OR REPLACE FUNCTION pg_catalog.TO_TEXT(uint2)
RETURNS TEXT
AS $$ select CAST(uint2out($1) AS VARCHAR2)  $$
LANGUAGE SQL  STRICT IMMUTABLE;

DROP FUNCTION IF EXISTS pg_catalog.uint2_bool(uint2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint2_bool(uint2)
RETURNS bool LANGUAGE C STRICT AS  '$libdir/dolphin',  'uint2_bool';

DROP FUNCTION IF EXISTS pg_catalog.bool_uint2(bool) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bool_uint2(bool)
RETURNS uint2 LANGUAGE C STRICT AS  '$libdir/dolphin',  'bool_uint2';

DROP FUNCTION IF EXISTS pg_catalog.uint2pl(uint2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2pl (
uint2,uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2pl';

DROP FUNCTION IF EXISTS pg_catalog.uint2mi(uint2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2mi (
uint2,uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2mi';

DROP FUNCTION IF EXISTS pg_catalog.uint2mul(uint2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2mul (
uint2,uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2mul';

DROP FUNCTION IF EXISTS pg_catalog.uint2div(uint2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2div (
uint2,uint2
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2div';

DROP FUNCTION IF EXISTS pg_catalog.uint2abs(uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2abs (
uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2abs';

DROP FUNCTION IF EXISTS pg_catalog.uint2mod(uint2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2mod (
uint2,uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2mod';

DROP FUNCTION IF EXISTS pg_catalog.uint2and(uint2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2and (
uint2,uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2and';

DROP FUNCTION IF EXISTS pg_catalog.uint2or(uint2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2or (
uint2,uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2or';

DROP FUNCTION IF EXISTS pg_catalog.uint2xor(uint2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2xor (
uint2,uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT  as '$libdir/dolphin',  'uint2xor';

DROP FUNCTION IF EXISTS pg_catalog.uint2um(uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2um (
uint2
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT  as '$libdir/dolphin',  'uint2um';

DROP FUNCTION IF EXISTS pg_catalog.uint2not(uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2not (
uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT  as '$libdir/dolphin',  'uint2not';
DROP FUNCTION IF EXISTS pg_catalog.uint2up(uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint2up (
uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT  as '$libdir/dolphin',  'uint2up';

DROP FUNCTION IF EXISTS pg_catalog.uint2_avg_accum(bigint[], uint2) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint2_avg_accum(bigint[], uint2)
 RETURNS bigint[] LANGUAGE C STRICT AS  '$libdir/dolphin',  'uint2_avg_accum';

DROP FUNCTION IF EXISTS pg_catalog.uint2_accum(numeric[], uint2) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint2_accum(numeric[], uint2)
 RETURNS numeric[] LANGUAGE C STRICT AS  '$libdir/dolphin',  'uint2_accum';

DROP FUNCTION IF EXISTS pg_catalog.uint2_sum(int8, uint2) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint2_sum(int8, uint2)
RETURNS int8 LANGUAGE C AS  '$libdir/dolphin',  'uint2_sum';

DROP FUNCTION IF EXISTS pg_catalog.uint2_list_agg_transfn(internal, uint2, text) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint2_list_agg_transfn(internal, uint2, text)
 RETURNS internal LANGUAGE C AS	'$libdir/dolphin',	'uint2_list_agg_transfn';

DROP FUNCTION IF EXISTS pg_catalog.uint2_list_agg_noarg2_transfn(internal, uint2) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint2_list_agg_noarg2_transfn(internal, uint2)
 RETURNS internal LANGUAGE C  AS '$libdir/dolphin',	'uint2_list_agg_noarg2_transfn';

----------------------------------------------------------------
-- add cast
----------------------------------------------------------------

drop  CAST  IF EXISTS(int4 AS  uint2) CASCADE;
drop  CAST  IF EXISTS(int8 AS  uint2) CASCADE;
drop  CAST  IF EXISTS(int2 AS  uint2) CASCADE;
drop  CAST  IF EXISTS(int1 AS  uint2) CASCADE;
drop  CAST  IF EXISTS(TEXT AS  uint2) CASCADE;
drop  CAST  IF EXISTS(numeric AS  uint2) CASCADE;
drop  CAST  IF EXISTS(uint4 AS  uint2) CASCADE;
drop  CAST  IF EXISTS(uint8 AS  uint2) CASCADE;
    
drop  CAST  IF EXISTS(uint2 AS  int4) CASCADE;
drop  CAST  IF EXISTS(uint2 AS  int8) CASCADE;
drop  CAST  IF EXISTS(uint2 AS  int2) CASCADE;
drop  CAST  IF EXISTS(uint2 AS  int1) CASCADE;
drop  CAST  IF EXISTS(uint2 AS  TEXT) CASCADE;
drop  CAST  IF EXISTS(uint2 AS  numeric) CASCADE;
drop  CAST  IF EXISTS(uint2 AS  INTERVAL) CASCADE;
drop  CAST  IF EXISTS(uint2 AS  uint4) CASCADE;
drop  CAST  IF EXISTS(uint2 AS  uint8) CASCADE;
drop  CAST  IF EXISTS (uint2 AS  bool) CASCADE;
drop  CAST  IF EXISTS (bool AS  uint2) CASCADE;

CREATE CAST (int4 AS uint2) WITH FUNCTION i4toui2(int4) AS IMPLICIT;
CREATE CAST (int8 AS uint2) WITH FUNCTION i8toui2(int8) AS IMPLICIT;
CREATE CAST (int2 AS uint2) WITH FUNCTION i2toui2(int2) AS IMPLICIT;
CREATE CAST (int1 AS uint2) WITH FUNCTION i1toui2(int1) AS IMPLICIT;
CREATE CAST (float4 AS uint2) WITH FUNCTION f4toui2(float4) AS IMPLICIT;
CREATE CAST (float8 AS uint2) WITH FUNCTION f8toui2(float8) AS IMPLICIT;
CREATE CAST (uint8 AS uint2) WITH FUNCTION ui8toui2(uint8) AS IMPLICIT;
CREATE CAST (uint4 AS uint2) WITH FUNCTION ui4toui2(uint4) AS IMPLICIT;

CREATE CAST (uint2 AS int1) WITH FUNCTION ui2toi1(uint2) AS IMPLICIT;
CREATE CAST (uint2 AS int4) WITH FUNCTION ui2toi4(uint2) AS IMPLICIT;
CREATE CAST (uint2 AS int8) WITH FUNCTION ui2toi8(uint2) AS IMPLICIT;
CREATE CAST (uint2 AS int2) WITH FUNCTION ui2toi2(uint2) AS IMPLICIT;
CREATE CAST (uint2 AS float4) WITH FUNCTION ui2tof4(uint2) AS IMPLICIT;
CREATE CAST (uint2 AS float8) WITH FUNCTION ui2tof8(uint2) AS IMPLICIT;

CREATE CAST (uint2 AS uint4) WITH FUNCTION ui2toui4(uint2) AS IMPLICIT;
CREATE CAST (uint2 AS uint8) WITH FUNCTION ui2toui8(uint2) AS IMPLICIT;

CREATE CAST (uint2 AS bool) WITH FUNCTION uint2_bool(uint2) AS IMPLICIT;
CREATE CAST (bool AS uint2) WITH FUNCTION bool_uint2(bool) AS IMPLICIT;

CREATE CAST (uint2 AS TEXT) WITH FUNCTION TO_TEXT(uint2) AS IMPLICIT;
CREATE CAST (uint2 AS numeric) WITH FUNCTION uint2_numeric(uint2) AS IMPLICIT;
CREATE CAST (numeric AS uint2) WITH FUNCTION numeric_uint2(Numeric) AS IMPLICIT;

CREATE CAST (uint2 AS INTERVAL) WITH FUNCTION NUMTODAY(uint2) AS IMPLICIT;

----------------------------------------------------------------
-- add  OPERATOR 
----------------------------------------------------------------

CREATE OPERATOR pg_catalog.=(
leftarg = uint2, rightarg = uint2, procedure = uint2eq,
commutator=operator(pg_catalog.=),
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint2, uint2) IS 'uint2eq';

CREATE OPERATOR pg_catalog.<>(
leftarg = uint2, rightarg = uint2, procedure = uint2ne,
restrict = neqsel, join = neqjoinsel
);
COMMENT ON OPERATOR pg_catalog.<>(uint2, uint2) IS 'uint2ne';

CREATE OPERATOR pg_catalog.<(
leftarg = uint2, rightarg = uint2, procedure = uint2lt,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<(uint2, uint2) IS 'uint2lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint2, rightarg = uint2, procedure = uint2le,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<=(uint2, uint2) IS 'uint2le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint2, rightarg = uint2, procedure = uint2gt,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>(uint2, uint2) IS 'uint2gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint2, rightarg = uint2, procedure = uint2ge,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>=(uint2, uint2) IS 'uint2ge';

CREATE OPERATOR pg_catalog.+(
leftarg = uint2, rightarg = uint2, procedure = uint2pl,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(uint2, uint2) IS 'uint2pl';

CREATE OPERATOR pg_catalog.-(
leftarg = uint2, rightarg = uint2, procedure = uint2mi,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(uint2, uint2) IS 'uint2mi';

CREATE OPERATOR pg_catalog.*(
leftarg = uint2, rightarg = uint2, procedure = uint2mul,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(uint2, uint2) IS 'uint2mul';

CREATE OPERATOR pg_catalog./(
leftarg = uint2, rightarg = uint2, procedure = uint2div,
commutator=operator(pg_catalog./)
);
COMMENT ON OPERATOR pg_catalog./(uint2, uint2) IS 'uint2div';

CREATE OPERATOR pg_catalog.@(
rightarg = uint2,  procedure = uint2abs

);

CREATE OPERATOR pg_catalog.%(
leftarg = uint2, rightarg = uint2, procedure = uint2mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(uint2, uint2) IS 'uint2mod';

CREATE OPERATOR pg_catalog.+(
rightarg = uint2, procedure = uint2up
);

CREATE OPERATOR pg_catalog.-(
rightarg = uint2, procedure = uint2um
);

CREATE OR REPLACE FUNCTION pg_catalog.uint2(text)
RETURNS uint2
LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_uint2';
CREATE CAST (TEXT AS uint2) WITH FUNCTION uint2(TEXT) AS IMPLICIT;

DROP FUNCTION IF EXISTS pg_catalog.uint2_int2_mod(uint2,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int2_mod (
uint2,int2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int2_mod';
CREATE OPERATOR pg_catalog.%(
leftarg = uint2, rightarg = int2, procedure = uint2_int2_mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(uint2, int2) IS 'uint2_int2_mod';

DROP FUNCTION IF EXISTS pg_catalog.int2_uint2_mod(int2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.int2_uint2_mod (
int2,uint2
) RETURNS int2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_uint2_mod';
CREATE OPERATOR pg_catalog.%(
leftarg = int2, rightarg = uint2, procedure = int2_uint2_mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(int2, uint2) IS 'int2_uint2_mod';

-------------------uint2 int2---------------
DROP FUNCTION IF EXISTS pg_catalog.uint2_pl_int2(uint2,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint2_pl_int2 (
uint2,int2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_pl_int2';

DROP FUNCTION IF EXISTS pg_catalog.uint2_mi_int2(uint2,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint2_mi_int2 (
uint2,int2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_mi_int2';

DROP FUNCTION IF EXISTS pg_catalog.uint2_mul_int2(uint2,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint2_mul_int2 (
uint2,int2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_mul_int2';

DROP FUNCTION IF EXISTS pg_catalog.uint2_div_int2(uint2,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint2_div_int2 (
uint2,int2
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_div_int2';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int2_eq(uint2,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int2_eq (
uint2,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int2_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int2_ne(uint2,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int2_ne (
uint2,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int2_ne';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int2_lt(uint2,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int2_lt (
uint2,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int2_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int2_le(uint2,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int2_le (
uint2,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int2_le';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int2_gt(uint2,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int2_gt (
uint2,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int2_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int2_ge(uint2,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int2_ge (
uint2,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int2_ge';

CREATE OPERATOR pg_catalog.+(
leftarg = uint2, rightarg = int2, procedure = uint2_pl_int2,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(uint2, uint2) IS 'uint2_pl_int2';

CREATE OPERATOR pg_catalog.-(
leftarg = uint2, rightarg = int2, procedure = uint2_mi_int2,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(uint2, int2) IS 'uint2_mi_int2';

CREATE OPERATOR pg_catalog.*(
leftarg = uint2, rightarg = int2, procedure = uint2_mul_int2,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(uint2, uint2) IS 'uint2_mul_int2';

CREATE OPERATOR pg_catalog./(
leftarg = uint2, rightarg = int2, procedure = uint2_div_int2,
commutator=operator(pg_catalog./)
);
COMMENT ON OPERATOR pg_catalog./(uint2, int2) IS 'uint2_div_int2';

CREATE OPERATOR pg_catalog.=(
leftarg = uint2, rightarg = int2, procedure = uint2_int2_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint2, int2) IS 'uint2_int2_eq';

CREATE OPERATOR pg_catalog.<>(
leftarg = uint2, rightarg = int2, procedure = uint2_int2_ne
);
COMMENT ON OPERATOR pg_catalog.<>(uint2, int2) IS 'uint2_int2_ne';

CREATE OPERATOR pg_catalog.<(
leftarg = uint2, rightarg = int2, procedure = uint2_int2_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint2, int2) IS 'uint2_int2_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint2, rightarg = int2, procedure = uint2_int2_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint2, int2) IS 'uint2_int2_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint2, rightarg = int2, procedure = uint2_int2_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint2, int2) IS 'uint2_int2_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint2, rightarg = int2, procedure = uint2_int2_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint2, int2) IS 'uint2_int2_ge';

-------------------uint2 int2---------------

-------------------int2 uint2---------------

DROP FUNCTION IF EXISTS pg_catalog.int2_pl_uint2(int2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.int2_pl_uint2 (
int2,uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_pl_uint2';

DROP FUNCTION IF EXISTS pg_catalog.int2_mi_uint2(int2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.int2_mi_uint2 (
int2,uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_mi_uint2';
DROP FUNCTION IF EXISTS pg_catalog.int2_mul_uint2(int2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.int2_mul_uint2 (
int2,uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_mul_uint2';

DROP FUNCTION IF EXISTS pg_catalog.int2_div_uint2(int2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.int2_div_uint2 (
int2,uint2
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_div_uint2';

DROP FUNCTION IF EXISTS pg_catalog.int2_uint2_eq(int2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.int2_uint2_eq (
int2,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_uint2_eq';

DROP FUNCTION IF EXISTS pg_catalog.int2_uint2_ne(int2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.int2_uint2_ne (
int2,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_uint2_ne';

DROP FUNCTION IF EXISTS pg_catalog.int2_uint2_lt(int2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.int2_uint2_lt (
int2,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_uint2_lt';

DROP FUNCTION IF EXISTS pg_catalog.int2_uint2_le(int2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.int2_uint2_le (
int2,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_uint2_le';

DROP FUNCTION IF EXISTS pg_catalog.int2_uint2_gt(int2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.int2_uint2_gt (
int2,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_uint2_gt';

DROP FUNCTION IF EXISTS pg_catalog.int2_uint2_ge(int2,uint2) CASCADE;
CREATE FUNCTION pg_catalog.int2_uint2_ge (
int2,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_uint2_ge';

CREATE OPERATOR pg_catalog.+(
leftarg = int2, rightarg = uint2, procedure = int2_pl_uint2,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(int2, uint2) IS 'int2_pl_uint2';

CREATE OPERATOR pg_catalog.-(
leftarg = int2, rightarg = uint2, procedure = int2_mi_uint2,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(int2, uint2) IS 'int2_mi_uint2';

CREATE OPERATOR pg_catalog.*(
leftarg = int2, rightarg = uint2, procedure = int2_mul_uint2,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(int2, uint2) IS 'int2_mul_uint2';

CREATE OPERATOR pg_catalog./(
leftarg = int2, rightarg = uint2, procedure = int2_div_uint2,
commutator=operator(pg_catalog./)
);
COMMENT ON OPERATOR pg_catalog./(int2, uint2) IS 'int2_div_uint2';

CREATE OPERATOR pg_catalog.=(
leftarg = int2, rightarg = uint2, procedure = int2_uint2_eq,
commutator=operator(pg_catalog.=),
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(int2, uint2) IS 'int2_uint2_eq';

CREATE OPERATOR pg_catalog.<>(
leftarg = int2, rightarg = uint2, procedure = int2_uint2_ne
);
COMMENT ON OPERATOR pg_catalog.<>(int2, uint2) IS 'int2_uint2_ne';

CREATE OPERATOR pg_catalog.<(
leftarg = int2, rightarg = uint2, procedure = int2_uint2_lt
);
COMMENT ON OPERATOR pg_catalog.<(int2, uint2) IS 'int2_uint2_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = int2, rightarg = uint2, procedure = int2_uint2_le
);
COMMENT ON OPERATOR pg_catalog.<=(int2, uint2) IS 'int2_uint2_le';

CREATE OPERATOR pg_catalog.>(
leftarg = int2, rightarg = uint2, procedure = int2_uint2_gt
);
COMMENT ON OPERATOR pg_catalog.>(int2, uint2) IS 'int2_uint2_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = int2, rightarg = uint2, procedure = int2_uint2_ge
);
COMMENT ON OPERATOR pg_catalog.>=(int2, uint2) IS 'int2_uint2_ge';

-------------------int2 uint2---------------
----------------------------------------------------------------
-- add  agg 
----------------------------------------------------------------

drop aggregate if exists pg_catalog.avg(uint2);
create aggregate pg_catalog.avg(uint2) (SFUNC=uint2_avg_accum, cFUNC=int8_avg_collect, STYPE= bigint[], finalfunc = int8_avg, initcond = '{0,0}', initcollect = '{0,0}');

drop aggregate if exists pg_catalog.sum(uint2);
create aggregate pg_catalog.sum(uint2) (SFUNC=uint2_sum, cFUNC=int8_sum_to_int8, STYPE= int8 );

drop aggregate if exists pg_catalog.min(uint2);
create aggregate pg_catalog.min(uint2) (SFUNC=uint2smaller,cFUNC = uint2smaller,  STYPE= uint2,SORTOP = '<');

drop aggregate if exists pg_catalog.max(uint2);
create aggregate pg_catalog.max(uint2) (SFUNC=uint2larger, cFUNC=uint2larger, STYPE= uint2,SORTOP = '>');

drop aggregate if exists pg_catalog.var_samp(uint2);
create aggregate pg_catalog.var_samp(uint2) (SFUNC=uint2_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.var_pop(uint2);
create aggregate pg_catalog.var_pop(uint2) (SFUNC=uint2_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.variance(uint2);
create aggregate pg_catalog.variance(uint2) (SFUNC=uint2_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.stddev_pop(uint2);
create aggregate pg_catalog.stddev_pop(uint2) (SFUNC=uint2_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.stddev_samp(uint2);
create aggregate pg_catalog.stddev_samp(uint2) (SFUNC=uint2_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.stddev(uint2);
create aggregate pg_catalog.stddev(uint2) (SFUNC=uint2_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.std(uint2);
create aggregate pg_catalog.std(uint2) (SFUNC=uint2_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.bit_and(uint2);
create aggregate pg_catalog.bit_and(uint2) (SFUNC=uint2and, cFUNC = uint2and, STYPE= uint2);

drop aggregate if exists pg_catalog.bit_or(uint2);
create aggregate pg_catalog.bit_or(uint2) (SFUNC=uint2or, cFUNC = uint2or,  STYPE= uint2);
drop aggregate if exists pg_catalog.bit_xor(uint2);
create aggregate pg_catalog.bit_xor(uint2) (SFUNC=uint2xor, cFUNC = uint2xor,  STYPE= uint2);

drop aggregate if exists pg_catalog.listagg(uint2,text);
create aggregate pg_catalog.listagg(uint2,text) (SFUNC=uint2_list_agg_transfn, finalfunc = list_agg_finalfn,  STYPE= internal);

drop aggregate if exists pg_catalog.listagg(uint2);
create aggregate pg_catalog.listagg(uint2) (SFUNC=uint2_list_agg_noarg2_transfn, finalfunc = list_agg_finalfn,  STYPE= internal);

----------------------------------------------------------------
-------------------uint4 ---------------
----------------------------------------------------------------

DROP FUNCTION IF EXISTS pg_catalog.i1toui4(int1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.i2toui4(int2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.i4toui4(int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.i8toui4(int8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.f4toui4(float4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.f8toui4(float8) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.ui8toui4(uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.numeric_uint4(numeric) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.ui4toui8(uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui4toi1(uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui4toi2(uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui4toi4(uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui4toi8(uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui4tof4(uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui4tof8(uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4_numeric(uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4smaller(uint4,uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4larger(uint4,uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4eq(uint4,uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4ne(uint4,uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4lt(uint4,uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4le(uint4,uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4gt(uint4,uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4ge(uint4,uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4cmp(uint4,uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint48cmp(uint4,uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4_int4cmp(uint4,int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4_int8cmp(uint4,int8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.hashuint4(uint4) CASCADE;
CREATE FUNCTION pg_catalog.i1toui4 (
int1
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1toui4';
CREATE FUNCTION pg_catalog.i2toui4 (
int2
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i2toui4';
CREATE FUNCTION pg_catalog.i4toui4 (
int4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i4toui4';
CREATE FUNCTION pg_catalog.i8toui4 (
int8
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i8toui4';
CREATE FUNCTION pg_catalog.f4toui4 (
float4
) RETURNS  uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f4toui4';
CREATE FUNCTION pg_catalog.f8toui4 (
float8
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f8toui4';

CREATE FUNCTION pg_catalog.ui8toui4 (
uint8
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui8toui4';
CREATE FUNCTION pg_catalog.numeric_uint4 (
Numeric
) RETURNS  uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'numeric_uint4';
CREATE FUNCTION pg_catalog.ui4toi1 (
uint4
) RETURNS int1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui4toi1';
CREATE FUNCTION pg_catalog.ui4toi2 (
uint4
) RETURNS int2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui4toi2';
CREATE FUNCTION pg_catalog.ui4toi4 (
uint4
) RETURNS  int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui4toi4';
CREATE FUNCTION pg_catalog.ui4toi8 (
uint4
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui4toi8';
CREATE FUNCTION pg_catalog.ui4tof4 (
uint4
) RETURNS  float4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui4tof4';
CREATE FUNCTION pg_catalog.ui4tof8 (
uint4
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui4tof8';

CREATE FUNCTION pg_catalog.ui4toui8 (
uint4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui4toui8';
CREATE FUNCTION pg_catalog.uint4_numeric (
uint4
) RETURNS Numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_numeric';
CREATE FUNCTION pg_catalog.uint4smaller (
uint4,uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4smaller';
CREATE FUNCTION pg_catalog.uint4larger (
uint4,uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4larger';
CREATE FUNCTION pg_catalog.uint4eq (
uint4,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4eq';
CREATE FUNCTION pg_catalog.uint4ne (
uint4,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4ne';
CREATE FUNCTION pg_catalog.uint4lt (
uint4,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4lt';
CREATE FUNCTION pg_catalog.uint4le (
uint4,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4le';
CREATE FUNCTION pg_catalog.uint4gt (
uint4,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4gt';
CREATE FUNCTION pg_catalog.uint4ge (
uint4,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4ge';
CREATE FUNCTION pg_catalog.uint4cmp (
uint4,uint4
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4cmp';
CREATE FUNCTION pg_catalog.uint48cmp (
uint4,uint8
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint48cmp';
CREATE FUNCTION pg_catalog.uint4_int4cmp (
uint4,int4
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int4cmp';
CREATE FUNCTION pg_catalog.uint4_int8cmp (
uint4,int8
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int8cmp';
CREATE FUNCTION pg_catalog.hashuint4 (
uint4
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'hashuint4';
CREATE OR REPLACE FUNCTION pg_catalog.NUMTODAY(uint4)
RETURNS INTERVAL
AS $$ SELECT NUMTODSINTERVAL(uint4_numeric($1),'DAY')$$
LANGUAGE SQL IMMUTABLE STRICT;
CREATE OR REPLACE FUNCTION pg_catalog.TO_TEXT(uint4)
RETURNS TEXT
AS $$ select CAST(uint4out($1) AS VARCHAR2)  $$
LANGUAGE SQL  STRICT IMMUTABLE;

DROP FUNCTION IF EXISTS pg_catalog.uint4pl(uint4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4pl (
uint4,uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4pl';
DROP FUNCTION IF EXISTS pg_catalog.uint4mi(uint4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4mi (
uint4,uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4mi';
DROP FUNCTION IF EXISTS pg_catalog.uint4mul(uint4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4mul (
uint4,uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4mul';
DROP FUNCTION IF EXISTS pg_catalog.uint4div(uint4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4div (
uint4,uint4
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4div';
DROP FUNCTION IF EXISTS pg_catalog.uint4abs(uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4abs (
uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4abs';
DROP FUNCTION IF EXISTS pg_catalog.uint4mod(uint4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4mod (
uint4,uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4mod';
DROP FUNCTION IF EXISTS pg_catalog.uint4and(uint4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4and (
uint4,uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4and';
DROP FUNCTION IF EXISTS pg_catalog.uint4or(uint4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4or (
uint4,uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4or';
DROP FUNCTION IF EXISTS pg_catalog.uint4xor(uint4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4xor (
uint4,uint4
) RETURNS uint4 LANGUAGE C STRICT IMMUTABLE  as '$libdir/dolphin',  'uint4xor';

DROP FUNCTION IF EXISTS pg_catalog.uint4inc(uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4up (
uint4
) RETURNS uint4 LANGUAGE C STRICT IMMUTABLE  as '$libdir/dolphin',  'uint4up';
DROP FUNCTION IF EXISTS pg_catalog.uint4um(uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4um (
uint4
) RETURNS int8 LANGUAGE C STRICT IMMUTABLE  as '$libdir/dolphin',  'uint4um';
DROP FUNCTION IF EXISTS pg_catalog.uint4not(uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint4not (
uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT  as '$libdir/dolphin',  'uint4not';

DROP FUNCTION IF EXISTS pg_catalog.uint4_avg_accum(bigint[], uint4) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint4_avg_accum(bigint[], uint4)
 RETURNS bigint[] LANGUAGE C IMMUTABLE STRICT AS  '$libdir/dolphin',  'uint4_avg_accum';

DROP FUNCTION IF EXISTS pg_catalog.uint4_accum(numeric[], uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint4_accum(numeric[], uint4)
 RETURNS numeric[] LANGUAGE C STRICT AS  '$libdir/dolphin',  'uint4_accum';

DROP FUNCTION IF EXISTS pg_catalog.uint4_sum(int8, uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint4_sum(int8, uint4)
RETURNS int8 LANGUAGE C AS  '$libdir/dolphin',  'uint4_sum';

DROP FUNCTION IF EXISTS pg_catalog.uint4_list_agg_transfn(internal, uint4, text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint4_list_agg_transfn(internal, uint4, text)
 RETURNS internal LANGUAGE C AS	'$libdir/dolphin',	'uint4_list_agg_transfn';

DROP FUNCTION IF EXISTS pg_catalog.uint4_list_agg_noarg2_transfn(internal, uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint4_list_agg_noarg2_transfn(internal, uint4)
 RETURNS internal LANGUAGE C  AS '$libdir/dolphin',	'uint4_list_agg_noarg2_transfn';

 
 DROP FUNCTION IF EXISTS pg_catalog.uint4_bool(uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint4_bool(uint4)
RETURNS bool LANGUAGE C STRICT AS  '$libdir/dolphin',  'uint4_bool';

DROP FUNCTION IF EXISTS pg_catalog.bool_uint4(bool) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bool_uint4(bool)
RETURNS uint4 LANGUAGE C STRICT  AS  '$libdir/dolphin',  'bool_uint4';
----------------------------------------------------------------
-- add cast
----------------------------------------------------------------

drop  CAST IF EXISTS(int4 AS  uint4) CASCADE;
drop  CAST IF EXISTS(int8 AS  uint4) CASCADE;
drop  CAST IF EXISTS(int2 AS  uint4) CASCADE;
drop  CAST IF EXISTS(int1 AS  uint4) CASCADE;
drop  CAST IF EXISTS(TEXT AS  uint4) CASCADE;
drop  CAST IF EXISTS(numeric AS  uint4) CASCADE;

drop  CAST IF EXISTS(uint8 AS  uint4) CASCADE;

drop  CAST IF EXISTS(uint4 AS  int4) CASCADE;
drop  CAST IF EXISTS(uint4 AS  int8) CASCADE;
drop  CAST IF EXISTS(uint4 AS  int2) CASCADE;
drop  CAST IF EXISTS(uint4 AS  int1) CASCADE;
drop  CAST IF EXISTS(uint4 AS  TEXT) CASCADE;
drop  CAST IF EXISTS(uint4 AS  numeric) CASCADE;
drop  CAST IF EXISTS(uint4 AS  INTERVAL) CASCADE;

drop  CAST IF EXISTS(uint4 AS  uint8) CASCADE;
drop  CAST  IF EXISTS (uint4 AS  bool) CASCADE;
drop  CAST  IF EXISTS (bool AS  uint4) CASCADE;

CREATE CAST (int4 AS uint4) WITH FUNCTION i4toui4(int4) AS IMPLICIT;
CREATE CAST (int8 AS uint4) WITH FUNCTION i8toui4(int8) AS IMPLICIT;
CREATE CAST (int2 AS uint4) WITH FUNCTION i2toui4(int2) AS IMPLICIT;
CREATE CAST (int1 AS uint4) WITH FUNCTION i1toui4(int1) AS IMPLICIT;
CREATE CAST (float4 AS uint4) WITH FUNCTION f4toui4(float4) AS IMPLICIT;
CREATE CAST (float8 AS uint4) WITH FUNCTION f8toui4(float8) AS IMPLICIT;
CREATE CAST (uint8 AS uint4) WITH FUNCTION ui8toui4(uint8) AS IMPLICIT;

CREATE CAST (uint4 AS int1) WITH FUNCTION ui4toi1(uint4) AS IMPLICIT;
CREATE CAST (uint4 AS int4) WITH FUNCTION ui4toi4(uint4) AS IMPLICIT;
CREATE CAST (uint4 AS int8) WITH FUNCTION ui4toi8(uint4) AS IMPLICIT;
CREATE CAST (uint4 AS int2) WITH FUNCTION ui4toi2(uint4) AS IMPLICIT;
CREATE CAST (uint4 AS float4) WITH FUNCTION ui4tof4(uint4) AS IMPLICIT;
CREATE CAST (uint4 AS float8) WITH FUNCTION ui4tof8(uint4) AS IMPLICIT;

CREATE CAST (uint4 AS uint8) WITH FUNCTION ui4toui8(uint4) AS IMPLICIT;

CREATE CAST (uint4 AS TEXT) WITH FUNCTION TO_TEXT(uint4) AS IMPLICIT;
CREATE CAST (uint4 AS numeric) WITH FUNCTION uint4_numeric(uint4) AS IMPLICIT;
CREATE CAST (numeric AS uint4) WITH FUNCTION numeric_uint4(Numeric) AS IMPLICIT;

CREATE CAST (uint4 AS INTERVAL) WITH FUNCTION NUMTODAY(uint4) AS IMPLICIT;

CREATE CAST (uint4 AS bool) WITH FUNCTION uint4_bool(uint4) AS IMPLICIT;
CREATE CAST (bool AS uint4) WITH FUNCTION bool_uint4(bool) AS IMPLICIT;

----------------------------------------------------------------
-- add  OPERATOR 
----------------------------------------------------------------

CREATE OPERATOR pg_catalog.=(
leftarg = uint4, rightarg = uint4, procedure = uint4eq,
commutator=operator(pg_catalog.=),
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint4, uint4) IS 'uint4eq';

CREATE OPERATOR pg_catalog.<>(
leftarg = uint4, rightarg = uint4, procedure = uint4ne,
restrict = neqsel, join = neqjoinsel
);
COMMENT ON OPERATOR pg_catalog.<>(uint4, uint4) IS 'uint4ne';

CREATE OPERATOR pg_catalog.<(
leftarg = uint4, rightarg = uint4, procedure = uint4lt,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<(uint4, uint4) IS 'uint4lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint4, rightarg = uint4, procedure = uint4le,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<=(uint4, uint4) IS 'uint4le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint4, rightarg = uint4, procedure = uint4gt,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>(uint4, uint4) IS 'uint4gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint4, rightarg = uint4, procedure = uint4ge,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>=(uint4, uint4) IS 'uint4ge';

CREATE OPERATOR pg_catalog.+(
leftarg = uint4, rightarg = uint4, procedure = uint4pl,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(uint4, uint4) IS 'uint4pl';

CREATE OPERATOR pg_catalog.-(
leftarg = uint4, rightarg = uint4, procedure = uint4mi,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(uint4, uint4) IS 'uint4mi';

CREATE OPERATOR pg_catalog.*(
leftarg = uint4, rightarg = uint4, procedure = uint4mul,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(uint4, uint4) IS 'uint4mul';

CREATE OPERATOR pg_catalog./(
leftarg = uint4, rightarg = uint4, procedure = uint4div,
commutator=operator(pg_catalog./)
);
COMMENT ON OPERATOR pg_catalog./(uint4, uint4) IS 'uint4div';

CREATE OPERATOR pg_catalog.@(
rightarg = uint4,  procedure = uint4abs

);

CREATE OPERATOR pg_catalog.%(
leftarg = uint4, rightarg = uint4, procedure = uint4mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(uint4, uint4) IS 'uint4mod';

CREATE OPERATOR pg_catalog.+(
rightarg = uint4, procedure = uint4up
);

CREATE OPERATOR pg_catalog.-(
rightarg = uint4, procedure = uint4um
);

CREATE OR REPLACE FUNCTION pg_catalog.uint4(text)
RETURNS uint4
LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_uint4';

CREATE CAST (TEXT AS uint4) WITH FUNCTION uint4(TEXT) AS IMPLICIT;

-------------------uint4 int4---------------
DROP FUNCTION IF EXISTS pg_catalog.uint4_pl_int4(uint4,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint4_pl_int4 (
uint4,int4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_pl_int4';

DROP FUNCTION IF EXISTS pg_catalog.uint4_mi_int4(uint4,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint4_mi_int4 (
uint4,int4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_mi_int4';
DROP FUNCTION IF EXISTS pg_catalog.uint4_mul_int4(uint4,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint4_mul_int4 (
uint4,int4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_mul_int4';

DROP FUNCTION IF EXISTS pg_catalog.uint4_div_int4(uint4,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint4_div_int4 (
uint4,int4
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_div_int4';

DROP FUNCTION IF EXISTS pg_catalog.uint4_int4_mod(uint4,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint4_int4_mod (
uint4,int4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int4_mod';

DROP FUNCTION IF EXISTS pg_catalog.uint4_int4_eq(uint4,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint4_int4_eq (
uint4,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int4_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint4_int4_ne(uint4,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint4_int4_ne (
uint4,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int4_ne';

DROP FUNCTION IF EXISTS pg_catalog.uint4_int4_lt(uint4,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint4_int4_lt (
uint4,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int4_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint4_int4_le(uint4,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint4_int4_le (
uint4,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int4_le';

DROP FUNCTION IF EXISTS pg_catalog.uint4_int4_gt(uint4,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint4_int4_gt (
uint4,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int4_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint4_int4_ge(uint4,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint4_int4_ge (
uint4,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int4_ge';

CREATE OPERATOR pg_catalog.+(
leftarg = uint4, rightarg = int4, procedure = uint4_pl_int4,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(uint4, int4) IS 'uint4_pl_int4';

CREATE OPERATOR pg_catalog.-(
leftarg = uint4, rightarg = int4, procedure = uint4_mi_int4,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(uint4, int4) IS 'uint4_mi_int4';

CREATE OPERATOR pg_catalog.*(
leftarg = uint4, rightarg = int4, procedure = uint4_mul_int4,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(uint4, int4) IS 'uint4_mul_int4';

CREATE OPERATOR pg_catalog./(
leftarg = uint4, rightarg = int4, procedure = uint4_div_int4,
commutator=operator(pg_catalog./)
);
COMMENT ON OPERATOR pg_catalog./(uint4, int4) IS 'uint4_div_int4';

CREATE OPERATOR pg_catalog.%(
leftarg = uint4, rightarg = int4, procedure = uint4_int4_mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(uint4, int4) IS 'uint4_int4_mod';

CREATE OPERATOR pg_catalog.=(
leftarg = uint4, rightarg = int4, procedure = uint4_int4_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint4, int4) IS 'uint4_int4_eq';

CREATE OPERATOR pg_catalog.<>(
leftarg = uint4, rightarg = int4, procedure = uint4_int4_ne
);
COMMENT ON OPERATOR pg_catalog.<>(uint4, int4) IS 'uint4_int4_ne';

CREATE OPERATOR pg_catalog.<(
leftarg = uint4, rightarg = int4, procedure = uint4_int4_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint4, int4) IS 'uint4_int4_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint4, rightarg = int4, procedure = uint4_int4_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint4, int4) IS 'uint4_int4_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint4, rightarg = int4, procedure = uint4_int4_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint4, int4) IS 'uint4_int4_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint4, rightarg = int4, procedure = uint4_int4_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint4, int4) IS 'uint4_int4_ge';

-------------------uint4 int4---------------

-------------------int4 uint4---------------
DROP FUNCTION IF EXISTS pg_catalog.int4_pl_uint4(int4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.int4_pl_uint4 (
int4,uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_pl_uint4';

DROP FUNCTION IF EXISTS pg_catalog.int4_mi_uint4(int4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.int4_mi_uint4 (
int4,uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_mi_uint4';
DROP FUNCTION IF EXISTS pg_catalog.int4_mul_uint4(int4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.int4_mul_uint4 (
int4,uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_mul_uint4';

DROP FUNCTION IF EXISTS pg_catalog.int4_div_uint4(int4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.int4_div_uint4 (
int4,uint4
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_div_uint4';

DROP FUNCTION IF EXISTS pg_catalog.int4_uint4_mod(int4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.int4_uint4_mod (
int4,uint4
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_uint4_mod';

DROP FUNCTION IF EXISTS pg_catalog.int4_uint4_eq(int4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.int4_uint4_eq (
int4,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_uint4_eq';

DROP FUNCTION IF EXISTS pg_catalog.int4_uint4_ne(int4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.int4_uint4_ne (
int4,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_uint4_ne';

DROP FUNCTION IF EXISTS pg_catalog.int4_uint4_lt(int4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.int4_uint4_lt (
int4,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_uint4_lt';

DROP FUNCTION IF EXISTS pg_catalog.int4_uint4_le(int4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.int4_uint4_le (
int4,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_uint4_le';

DROP FUNCTION IF EXISTS pg_catalog.int4_uint4_gt(int4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.int4_uint4_gt (
int4,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_uint4_gt';

DROP FUNCTION IF EXISTS pg_catalog.int4_uint4_ge(int4,uint4) CASCADE;
CREATE FUNCTION pg_catalog.int4_uint4_ge (
int4,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_uint4_ge';

CREATE OPERATOR pg_catalog.+(
leftarg = int4, rightarg = uint4, procedure = int4_pl_uint4,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(int4, uint4) IS 'int4_pl_uint4';

CREATE OPERATOR pg_catalog.-(
leftarg = int4, rightarg = uint4, procedure = int4_mi_uint4,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(int4, uint4) IS 'int4_mi_uint4';

CREATE OPERATOR pg_catalog.*(
leftarg = int4, rightarg = uint4, procedure = int4_mul_uint4,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(int4, uint4) IS 'int4_mul_uint4';

CREATE OPERATOR pg_catalog./(
leftarg = int4, rightarg = uint4, procedure = int4_div_uint4,
commutator=operator(pg_catalog./)
);
COMMENT ON OPERATOR pg_catalog./(int4, uint4) IS 'int4_div_uint4';

CREATE OPERATOR pg_catalog.%(
leftarg = int4, rightarg = uint4, procedure = int4_uint4_mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(int4, uint4) IS 'int4_uint4_mod';

CREATE OPERATOR pg_catalog.=(
leftarg = int4, rightarg = uint4, procedure = int4_uint4_eq,
commutator=operator(pg_catalog.=),
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(int4, uint4) IS 'int4_uint4_eq';

CREATE OPERATOR pg_catalog.<>(
leftarg = int4, rightarg = uint4, procedure = int4_uint4_ne
);
COMMENT ON OPERATOR pg_catalog.<>(int4, uint4) IS 'int4_uint4_ne';

CREATE OPERATOR pg_catalog.<(
leftarg = int4, rightarg = uint4, procedure = int4_uint4_lt
);
COMMENT ON OPERATOR pg_catalog.<(int4, uint4) IS 'int4_uint4_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = int4, rightarg = uint4, procedure = int4_uint4_le
);
COMMENT ON OPERATOR pg_catalog.<=(int4, uint4) IS 'int4_uint4_le';

CREATE OPERATOR pg_catalog.>(
leftarg = int4, rightarg = uint4, procedure = int4_uint4_gt
);
COMMENT ON OPERATOR pg_catalog.>(int4, uint4) IS 'int4_uint4_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = int4, rightarg = uint4, procedure = int4_uint4_ge
);
COMMENT ON OPERATOR pg_catalog.>=(int4, uint4) IS 'int4_uint4_ge';

-------------------int4 uint4---------------
----------------------------------------------------------------
-- add  agg 
----------------------------------------------------------------
drop aggregate if exists pg_catalog.avg(uint4);
create aggregate pg_catalog.avg(uint4) (SFUNC=uint4_avg_accum, cFUNC=int8_avg_collect, STYPE= bigint[], finalfunc = int8_avg, initcond = '{0,0}', initcollect = '{0,0}');
drop aggregate if exists pg_catalog.sum(uint4);
create aggregate pg_catalog.sum(uint4) (SFUNC=uint4_sum, cFUNC=int8_sum_to_int8, STYPE= int8 );
drop aggregate if exists pg_catalog.min(uint4);
create aggregate pg_catalog.min(uint4) (SFUNC=uint4smaller,cFUNC = uint4smaller,  STYPE= uint4,SORTOP = '<');
drop aggregate if exists pg_catalog.max(uint4);
create aggregate pg_catalog.max(uint4) (SFUNC=uint4larger, cFUNC=uint4larger, STYPE= uint4,SORTOP = '>');
drop aggregate if exists pg_catalog.var_samp(uint4);
create aggregate pg_catalog.var_samp(uint4) (SFUNC=uint4_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');
drop aggregate if exists pg_catalog.var_pop(uint4);
create aggregate pg_catalog.var_pop(uint4) (SFUNC=uint4_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');
drop aggregate if exists pg_catalog.variance(uint4);
create aggregate pg_catalog.variance(uint4) (SFUNC=uint4_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');
drop aggregate if exists pg_catalog.stddev_pop(uint4);
create aggregate pg_catalog.stddev_pop(uint4) (SFUNC=uint4_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');
drop aggregate if exists pg_catalog.stddev_samp(uint4);
create aggregate pg_catalog.stddev_samp(uint4) (SFUNC=uint4_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');
drop aggregate if exists pg_catalog.stddev(uint4);
create aggregate pg_catalog.stddev(uint4) (SFUNC=uint4_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');
drop aggregate if exists pg_catalog.std(uint4);
create aggregate pg_catalog.std(uint4) (SFUNC=uint4_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');
drop aggregate if exists pg_catalog.bit_and(uint4);
create aggregate pg_catalog.bit_and(uint4) (SFUNC=uint4and, cFUNC = uint4and, STYPE= uint4);
drop aggregate if exists pg_catalog.bit_or(uint4);
create aggregate pg_catalog.bit_or(uint4) (SFUNC=uint4or, cFUNC = uint4or,  STYPE= uint4);

drop aggregate if exists pg_catalog.bit_xor(uint4);
create aggregate pg_catalog.bit_xor(uint4) (SFUNC=uint4xor, cFUNC = uint4xor,  STYPE= uint4);

drop aggregate if exists pg_catalog.listagg(uint4,text);
create aggregate pg_catalog.listagg(uint4,text) (SFUNC=uint4_list_agg_transfn, finalfunc = list_agg_finalfn,  STYPE= internal);
drop aggregate if exists pg_catalog.listagg(uint4);
create aggregate pg_catalog.listagg(uint4) (SFUNC=uint4_list_agg_noarg2_transfn, finalfunc = list_agg_finalfn,  STYPE= internal);

------------------- uint8---------------
------------------- uint8
------------------- uint8---------------

------------------- uint8---------------
------------------- uint8
------------------- uint8---------------

----------------------------------------------------------------
-- add function
----------------------------------------------------------------

DROP FUNCTION IF EXISTS pg_catalog.i1toui8(int1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.i2toui8(int2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.i4toui8(int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.i8toui8(int8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.f4toui8(float4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.f8toui8(float8) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.numeric_uint8(numeric) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.ui8toi1(uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui8toi2(uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui8toi4(uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui8toi8(uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui8tof4(uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.ui8tof8(uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8_numeric(uint8) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint8smaller(uint8,uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8larger(uint8,uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8eq(uint8,uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8ne(uint8,uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8lt(uint8,uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8le(uint8,uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8gt(uint8,uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8ge(uint8,uint8) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint8cmp(uint8,uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8_int8cmp(uint8,int8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.hashuint8(uint8) CASCADE;

CREATE FUNCTION pg_catalog.i1toui8 (
int1
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1toui8';

CREATE FUNCTION pg_catalog.i2toui8 (
int2
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i2toui8';

CREATE FUNCTION pg_catalog.i4toui8 (
int4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i4toui8';

CREATE FUNCTION pg_catalog.i8toui8 (
int8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i8toui8';

CREATE FUNCTION pg_catalog.f4toui8 (
float4
) RETURNS  uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f4toui8';
CREATE FUNCTION pg_catalog.f8toui8 (
float8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f8toui8';

CREATE FUNCTION pg_catalog.numeric_uint8 (
Numeric
) RETURNS  uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'numeric_uint8';

CREATE FUNCTION pg_catalog.ui8toi1 (
uint8
) RETURNS int1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui8toi1';
CREATE FUNCTION pg_catalog.ui8toi2 (
uint8
) RETURNS int2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui8toi2';

CREATE FUNCTION pg_catalog.ui8toi4 (
uint8
) RETURNS  int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui8toi4';
CREATE FUNCTION pg_catalog.ui8toi8 (
uint8
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui8toi8';

CREATE FUNCTION pg_catalog.ui8tof4 (
uint8
) RETURNS  float4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui8tof4';
CREATE FUNCTION pg_catalog.ui8tof8 (
uint8
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui8tof8';

CREATE FUNCTION pg_catalog.uint8_numeric (
uint8
) RETURNS Numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_numeric';

CREATE FUNCTION pg_catalog.uint8smaller (
uint8,uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8smaller';

CREATE FUNCTION pg_catalog.uint8larger (
uint8,uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8larger';

CREATE FUNCTION pg_catalog.uint8eq (
uint8,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8eq';

CREATE FUNCTION pg_catalog.uint8ne (
uint8,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8ne';

CREATE FUNCTION pg_catalog.uint8lt (
uint8,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8lt';

CREATE FUNCTION pg_catalog.uint8le (
uint8,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8le';

CREATE FUNCTION pg_catalog.uint8gt (
uint8,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8gt';

CREATE FUNCTION pg_catalog.uint8ge (
uint8,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8ge';

CREATE FUNCTION pg_catalog.uint8cmp (
uint8,uint8
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8cmp';

CREATE FUNCTION pg_catalog.uint8_int8cmp (
uint8,int8
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_int8cmp';

CREATE FUNCTION pg_catalog.hashuint8 (
uint8
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'hashuint8';

CREATE OR REPLACE FUNCTION pg_catalog.TO_TEXT(uint8)
RETURNS TEXT
AS $$ select CAST(uint8out($1) AS VARCHAR2)  $$
LANGUAGE SQL  STRICT IMMUTABLE;

DROP FUNCTION IF EXISTS pg_catalog.uint8_bool(uint8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint8_bool(uint8)
RETURNS bool LANGUAGE C STRICT AS  '$libdir/dolphin',  'uint8_bool';

DROP FUNCTION IF EXISTS pg_catalog.bool_uint8(bool) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bool_uint8(bool)
RETURNS uint8 LANGUAGE C STRICT AS  '$libdir/dolphin',  'bool_uint8';

DROP FUNCTION IF EXISTS pg_catalog.uint8pl(uint8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8pl (
uint8,uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8pl';

DROP FUNCTION IF EXISTS pg_catalog.uint8mi(uint8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8mi (
uint8,uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8mi';

DROP FUNCTION IF EXISTS pg_catalog.uint8mul(uint8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8mul (
uint8,uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8mul';

DROP FUNCTION IF EXISTS pg_catalog.uint8div(uint8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8div (
uint8,uint8
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8div';

DROP FUNCTION IF EXISTS pg_catalog.uint8abs(uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8abs (
uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8abs';

DROP FUNCTION IF EXISTS pg_catalog.uint8mod(uint8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8mod (
uint8,uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8mod';

DROP FUNCTION IF EXISTS pg_catalog.uint8and(uint8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8and (
uint8,uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8and';

DROP FUNCTION IF EXISTS pg_catalog.uint8or(uint8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8or (
uint8,uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8or';

DROP FUNCTION IF EXISTS pg_catalog.uint8xor(uint8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8xor (
uint8,uint8
) RETURNS uint8 LANGUAGE C STRICT IMMUTABLE  as '$libdir/dolphin',  'uint8xor';

DROP FUNCTION IF EXISTS pg_catalog.uint8up(uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8up (
uint8
) RETURNS uint8 LANGUAGE C STRICT IMMUTABLE  as '$libdir/dolphin',  'uint8up';

DROP FUNCTION IF EXISTS pg_catalog.uint8um(uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8um (
uint8
) RETURNS int8 LANGUAGE C STRICT IMMUTABLE  as '$libdir/dolphin',  'uint8um';

DROP FUNCTION IF EXISTS pg_catalog.uint8not(uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint8not (
uint8
) RETURNS uint8 LANGUAGE C STRICT IMMUTABLE  as '$libdir/dolphin',  'uint8not';

DROP FUNCTION IF EXISTS pg_catalog.uint8_avg_accum(numeric[], uint8) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint8_avg_accum(numeric[], uint8)
 RETURNS numeric[] LANGUAGE C STRICT IMMUTABLE AS  '$libdir/dolphin',  'uint8_avg_accum';

DROP FUNCTION IF EXISTS pg_catalog.uint8_accum(numeric[], uint8) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint8_accum(numeric[], uint8)
 RETURNS numeric[] LANGUAGE C STRICT AS  '$libdir/dolphin',  'uint8_accum';

DROP FUNCTION IF EXISTS pg_catalog.uint8_sum(numeric, uint8) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint8_sum(numeric, uint8)
RETURNS numeric LANGUAGE C AS  '$libdir/dolphin',  'uint8_sum';

DROP FUNCTION IF EXISTS pg_catalog.uint8_list_agg_transfn(internal, uint8, text) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint8_list_agg_transfn(internal, uint8, text)
 RETURNS internal LANGUAGE C AS	'$libdir/dolphin',	'uint8_list_agg_transfn';

DROP FUNCTION IF EXISTS pg_catalog.uint8_list_agg_noarg2_transfn(internal, uint8) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint8_list_agg_noarg2_transfn(internal, uint8)
 RETURNS internal LANGUAGE C  AS '$libdir/dolphin',	'uint8_list_agg_noarg2_transfn';

----------------------------------------------------------------
-- add cast
----------------------------------------------------------------

drop  CAST IF EXISTS(int4 AS  uint8) CASCADE;
drop  CAST IF EXISTS(int8 AS  uint8) CASCADE;
drop  CAST IF EXISTS(int2 AS  uint8) CASCADE;
drop  CAST IF EXISTS(int1 AS  uint8) CASCADE;
drop  CAST IF EXISTS(TEXT AS  uint8) CASCADE;
drop  CAST IF EXISTS(numeric AS  uint8) CASCADE;

          
drop  CAST IF EXISTS(uint8 AS  int4) CASCADE;
drop  CAST IF EXISTS(uint8 AS  int8) CASCADE;
drop  CAST IF EXISTS(uint8 AS  int2) CASCADE;
drop  CAST IF EXISTS(uint8 AS  int1) CASCADE;
drop  CAST IF EXISTS(uint8 AS  TEXT) CASCADE;
drop  CAST IF EXISTS(uint8 AS  numeric) CASCADE;

drop  CAST  IF EXISTS (uint8 AS  bool) CASCADE;
drop  CAST  IF EXISTS (bool AS  uint8) CASCADE;

CREATE CAST (int4 AS uint8) WITH FUNCTION i4toui8(int4) AS IMPLICIT;
CREATE CAST (int8 AS uint8) WITH FUNCTION i8toui8(int8) AS IMPLICIT;
CREATE CAST (int2 AS uint8) WITH FUNCTION i2toui8(int2) AS IMPLICIT;
CREATE CAST (int1 AS uint8) WITH FUNCTION i1toui8(int1) AS IMPLICIT;
CREATE CAST (float4 AS uint8) WITH FUNCTION f4toui8(float4) AS IMPLICIT;
CREATE CAST (float8 AS uint8) WITH FUNCTION f8toui8(float8) AS IMPLICIT;

CREATE CAST (uint8 AS int1) WITH FUNCTION ui8toi1(uint8) AS IMPLICIT;
CREATE CAST (uint8 AS int2) WITH FUNCTION ui8toi2(uint8) AS IMPLICIT;
CREATE CAST (uint8 AS int4) WITH FUNCTION ui8toi4(uint8) AS IMPLICIT;
CREATE CAST (uint8 AS int8) WITH FUNCTION ui8toi8(uint8) AS IMPLICIT;

CREATE CAST (uint8 AS float4) WITH FUNCTION ui8tof4(uint8) AS IMPLICIT;
CREATE CAST (uint8 AS float8) WITH FUNCTION ui8tof8(uint8) AS IMPLICIT;

CREATE CAST (uint8 AS TEXT) WITH FUNCTION TO_TEXT(uint8) AS IMPLICIT;

CREATE CAST (uint8 AS numeric) WITH FUNCTION uint8_numeric(uint8) AS IMPLICIT;
CREATE CAST (numeric AS uint8) WITH FUNCTION numeric_uint8(Numeric) AS IMPLICIT;

CREATE CAST (uint8 AS bool) WITH FUNCTION uint8_bool(uint8) AS IMPLICIT;
CREATE CAST (bool AS uint8) WITH FUNCTION bool_uint8(bool) AS IMPLICIT;

----------------------------------------------------------------
-- add  OPERATOR 
----------------------------------------------------------------

CREATE OPERATOR pg_catalog.=(
leftarg = uint8, rightarg = uint8, procedure = uint8eq,
commutator=operator(pg_catalog.=),
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint8, uint8) IS 'uint8eq';

CREATE OPERATOR pg_catalog.<>(
leftarg = uint8, rightarg = uint8, procedure = uint8ne,
restrict = neqsel, join = neqjoinsel
);
COMMENT ON OPERATOR pg_catalog.<>(uint8, uint8) IS 'uint8ne';

CREATE OPERATOR pg_catalog.<(
leftarg = uint8, rightarg = uint8, procedure = uint8lt,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<(uint8, uint8) IS 'uint8lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint8, rightarg = uint8, procedure = uint8le,
restrict = scalarltsel, join = scalarltjoinsel
);
COMMENT ON OPERATOR pg_catalog.<=(uint8, uint8) IS 'uint8le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint8, rightarg = uint8, procedure = uint8gt,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>(uint8, uint8) IS 'uint8gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint8, rightarg = uint8, procedure = uint8ge,
restrict = scalargtsel, join = scalargtjoinsel
);
COMMENT ON OPERATOR pg_catalog.>=(uint8, uint8) IS 'uint8ge';

CREATE OPERATOR pg_catalog.+(
leftarg = uint8, rightarg = uint8, procedure = uint8pl,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(uint8, uint8) IS 'uint8pl';

CREATE OPERATOR pg_catalog.-(
leftarg = uint8, rightarg = uint8, procedure = uint8mi,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(uint8, uint8) IS 'uint8mi';

CREATE OPERATOR pg_catalog.*(
leftarg = uint8, rightarg = uint8, procedure = uint8mul,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(uint8, uint8) IS 'uint8mul';

CREATE OPERATOR pg_catalog./(
leftarg = uint8, rightarg = uint8, procedure = uint8div,
commutator=operator(pg_catalog./)
);
COMMENT ON OPERATOR pg_catalog./(uint8, uint8) IS 'uint8div';

CREATE OPERATOR pg_catalog.@(
rightarg = uint8,  procedure = uint8abs

);

CREATE OPERATOR pg_catalog.%(
leftarg = uint8, rightarg = uint8, procedure = uint8mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(uint8, uint8) IS 'uint8mod';

CREATE OPERATOR pg_catalog.+(
rightarg = uint8, procedure = uint8up
);

CREATE OPERATOR pg_catalog.-(
rightarg = uint8, procedure = uint8um
);

CREATE OR REPLACE FUNCTION pg_catalog.uint8(text)
RETURNS uint8
LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_uint8';
CREATE CAST (TEXT AS uint8) WITH FUNCTION uint8(TEXT) AS IMPLICIT;

-------------------uint8 int8---------------

DROP FUNCTION IF EXISTS pg_catalog.uint8_pl_int8(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint8_pl_int8 (
uint8,int8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_pl_int8';

DROP FUNCTION IF EXISTS pg_catalog.uint8_mi_int8(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint8_mi_int8 (
uint8,int8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_mi_int8';

DROP FUNCTION IF EXISTS pg_catalog.uint8_mul_int8(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint8_mul_int8 (
uint8,int8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_mul_int8';

DROP FUNCTION IF EXISTS pg_catalog.uint8_div_int8(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint8_div_int8 (
uint8,int8
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_div_int8';

DROP FUNCTION IF EXISTS pg_catalog.uint8_int8_mod(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint8_int8_mod (
uint8,int8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_int8_mod';

DROP FUNCTION IF EXISTS pg_catalog.uint8_int8_eq(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint8_int8_eq (
uint8,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_int8_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint8_int8_ne(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint8_int8_ne (
uint8,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_int8_ne';

DROP FUNCTION IF EXISTS pg_catalog.uint8_int8_lt(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint8_int8_lt (
uint8,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_int8_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint8_int8_le(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint8_int8_le (
uint8,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_int8_le';

DROP FUNCTION IF EXISTS pg_catalog.uint8_int8_gt(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint8_int8_gt (
uint8,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_int8_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint8_int8_ge(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint8_int8_ge (
uint8,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_int8_ge';

CREATE OPERATOR pg_catalog.+(
leftarg = uint8, rightarg = int8, procedure = uint8_pl_int8,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(uint8, int8) IS 'uint8_pl_int8';

CREATE OPERATOR pg_catalog.-(
leftarg = uint8, rightarg = int8, procedure = uint8_mi_int8,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(uint8, int8) IS 'uint8_mi_int8';

CREATE OPERATOR pg_catalog.*(
leftarg = uint8, rightarg = int8, procedure = uint8_mul_int8,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(uint8, int8) IS 'uint8_mul_int8';

CREATE OPERATOR pg_catalog./(
leftarg = uint8, rightarg = int8, procedure = uint8_div_int8,
commutator=operator(pg_catalog./)
);
COMMENT ON OPERATOR pg_catalog./(uint8, int8) IS 'uint8_div_int8';

CREATE OPERATOR pg_catalog.%(
leftarg = uint8, rightarg = int8, procedure = uint8_int8_mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(uint8, int8) IS 'uint8_int8_mod';

CREATE OPERATOR pg_catalog.=(
leftarg = uint8, rightarg = int8, procedure = uint8_int8_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint8, int8) IS 'uint8_int8_eq';

CREATE OPERATOR pg_catalog.<>(
leftarg = uint8, rightarg = int8, procedure = uint8_int8_ne
);
COMMENT ON OPERATOR pg_catalog.<>(uint8, int8) IS 'uint8_int8_ne';

CREATE OPERATOR pg_catalog.<(
leftarg = uint8, rightarg = int8, procedure = uint8_int8_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint8, int8) IS 'uint8_int8_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint8, rightarg = int8, procedure = uint8_int8_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint8, int8) IS 'uint8_int8_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint8, rightarg = int8, procedure = uint8_int8_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint8, int8) IS 'uint8_int8_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint8, rightarg = int8, procedure = uint8_int8_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint8, int8) IS 'uint8_int8_ge';

-------------------uint8 int8---------------

-------------------int8 uint8---------------
DROP FUNCTION IF EXISTS pg_catalog.int8_pl_uint8(int8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.int8_pl_uint8 (
int8,uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_pl_uint8';

DROP FUNCTION IF EXISTS pg_catalog.int8_mi_uint8(int8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.int8_mi_uint8 (
int8,uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_mi_uint8';
DROP FUNCTION IF EXISTS pg_catalog.int8_mul_uint8(int8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.int8_mul_uint8 (
int8,uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_mul_uint8';

DROP FUNCTION IF EXISTS pg_catalog.int8_div_uint8(int8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.int8_div_uint8 (
int8,uint8
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_div_uint8';

DROP FUNCTION IF EXISTS pg_catalog.int8_uint8_mod(int8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.int8_uint8_mod (
int8,uint8
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_uint8_mod';

DROP FUNCTION IF EXISTS pg_catalog.int8_uint8_eq(int8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.int8_uint8_eq (
int8,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_uint8_eq';

DROP FUNCTION IF EXISTS pg_catalog.int8_uint8_ne(int8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.int8_uint8_ne (
int8,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_uint8_ne';

DROP FUNCTION IF EXISTS pg_catalog.int8_uint8_lt(int8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.int8_uint8_lt (
int8,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_uint8_lt';

DROP FUNCTION IF EXISTS pg_catalog.int8_uint8_le(int8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.int8_uint8_le (
int8,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_uint8_le';

DROP FUNCTION IF EXISTS pg_catalog.int8_uint8_gt(int8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.int8_uint8_gt (
int8,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_uint8_gt';

DROP FUNCTION IF EXISTS pg_catalog.int8_uint8_ge(int8,uint8) CASCADE;
CREATE FUNCTION pg_catalog.int8_uint8_ge (
int8,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_uint8_ge';

CREATE OPERATOR pg_catalog.+(
leftarg = int8, rightarg = uint8, procedure = int8_pl_uint8,
commutator=operator(pg_catalog.+)
);
COMMENT ON OPERATOR pg_catalog.+(int8, uint8) IS 'int8_pl_uint8';

CREATE OPERATOR pg_catalog.-(
leftarg = int8, rightarg = uint8, procedure = int8_mi_uint8,
commutator=operator(pg_catalog.-)
);
COMMENT ON OPERATOR pg_catalog.-(int8, uint8) IS 'int8_mi_uint8';

CREATE OPERATOR pg_catalog.*(
leftarg = int8, rightarg = uint8, procedure = int8_mul_uint8,
commutator=operator(pg_catalog.*)
);
COMMENT ON OPERATOR pg_catalog.*(int8, uint8) IS 'int8_mul_uint8';

CREATE OPERATOR pg_catalog./(
leftarg = int8, rightarg = uint8, procedure = int8_div_uint8,
commutator=operator(pg_catalog./)
);
COMMENT ON OPERATOR pg_catalog./(int8, uint8) IS 'int8_div_uint8';

CREATE OPERATOR pg_catalog.%(
leftarg = int8, rightarg = uint8, procedure = int8_uint8_mod,
commutator=operator(pg_catalog.%)
);
COMMENT ON OPERATOR pg_catalog.%(int8, uint8) IS 'int8_uint8_mod';

CREATE OPERATOR pg_catalog.=(
leftarg = int8, rightarg = uint8, procedure = int8_uint8_eq,
commutator=operator(pg_catalog.=),
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(int8, uint8) IS 'int8_uint8_eq';

CREATE OPERATOR pg_catalog.<>(
leftarg = int8, rightarg = uint8, procedure = int8_uint8_ne
);
COMMENT ON OPERATOR pg_catalog.<>(int8, uint8) IS 'int8_uint8_ne';

CREATE OPERATOR pg_catalog.<(
leftarg = int8, rightarg = uint8, procedure = int8_uint8_lt
);
COMMENT ON OPERATOR pg_catalog.<(int8, uint8) IS 'int8_uint8_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = int8, rightarg = uint8, procedure = int8_uint8_le
);
COMMENT ON OPERATOR pg_catalog.<=(int8, uint8) IS 'int8_uint8_le';

CREATE OPERATOR pg_catalog.>(
leftarg = int8, rightarg = uint8, procedure = int8_uint8_gt
);
COMMENT ON OPERATOR pg_catalog.>(int8, uint8) IS 'int8_uint8_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = int8, rightarg = uint8, procedure = int8_uint8_ge
);
COMMENT ON OPERATOR pg_catalog.>=(int8, uint8) IS 'int8_uint8_ge';

-------------------int8 uint8---------------
----------------------------------------------------------------
-- add  agg 
----------------------------------------------------------------

drop aggregate if exists pg_catalog.avg(uint8);
create aggregate pg_catalog.avg(uint8) (SFUNC=uint8_avg_accum, cFUNC=numeric_avg_collect, STYPE= numeric[], finalfunc = numeric_avg, initcond = '{0,0}', initcollect = '{0,0}');

drop aggregate if exists pg_catalog.sum(uint8);
create aggregate pg_catalog.sum(uint8) (SFUNC=uint8_sum, cFUNC=numeric_add, STYPE= numeric );

drop aggregate if exists pg_catalog.min(uint8);
create aggregate pg_catalog.min(uint8) (SFUNC=uint8smaller,cFUNC = uint8smaller,  STYPE= uint8,SORTOP = '<');

drop aggregate if exists pg_catalog.max(uint8);
create aggregate pg_catalog.max(uint8) (SFUNC=uint8larger, cFUNC=uint8larger, STYPE= uint8,SORTOP = '>');

drop aggregate if exists pg_catalog.var_samp(uint8);
create aggregate pg_catalog.var_samp(uint8) (SFUNC=uint8_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.var_pop(uint8);
create aggregate pg_catalog.var_pop(uint8) (SFUNC=uint8_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.variance(uint8);
create aggregate pg_catalog.variance(uint8) (SFUNC=uint8_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.stddev_pop(uint8);
create aggregate pg_catalog.stddev_pop(uint8) (SFUNC=uint8_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.stddev_samp(uint8);
create aggregate pg_catalog.stddev_samp(uint8) (SFUNC=uint8_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.stddev(uint8);
create aggregate pg_catalog.stddev(uint8) (SFUNC=uint8_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.std(uint8);
create aggregate pg_catalog.std(uint8) (SFUNC=uint8_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

drop aggregate if exists pg_catalog.bit_and(uint8);
create aggregate pg_catalog.bit_and(uint8) (SFUNC=uint8and, cFUNC = uint8and, STYPE= uint8);

drop aggregate if exists pg_catalog.bit_or(uint8);
create aggregate pg_catalog.bit_or(uint8) (SFUNC=uint8or, cFUNC = uint8or,  STYPE= uint8);
drop aggregate if exists pg_catalog.bit_xor(uint8);
create aggregate pg_catalog.bit_xor(uint8) (SFUNC=uint8xor, cFUNC = uint8xor,  STYPE= uint8);

drop aggregate if exists pg_catalog.listagg(uint8,text);
create aggregate pg_catalog.listagg(uint8,text) (SFUNC=uint8_list_agg_transfn, finalfunc = list_agg_finalfn,  STYPE= internal);

drop aggregate if exists pg_catalog.listagg(uint8);
create aggregate pg_catalog.listagg(uint8) (SFUNC=uint8_list_agg_noarg2_transfn, finalfunc = list_agg_finalfn,  STYPE= internal);

----------------------------------------------------------------
-- add  opfamily_opclass 
----------------------------------------------------------------
DROP FUNCTION IF EXISTS pg_catalog.uint1_uint2_eq(uint1,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint2_eq (
uint1,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint2_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint2_lt(uint1,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint2_lt (
uint1,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint2_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint2_le(uint1,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint2_le (
uint1,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint2_le';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint2_gt(uint1,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint2_gt (
uint1,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint2_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint2_ge(uint1,uint2) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint2_ge (
uint1,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint2_ge';

CREATE OPERATOR pg_catalog.=(
leftarg = uint1, rightarg = uint2, procedure = uint1_uint2_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint1, uint2) IS 'uint1_uint2_eq';

CREATE OPERATOR pg_catalog.<(
leftarg = uint1, rightarg = uint2, procedure = uint1_uint2_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint1, uint2) IS 'uint1_uint2_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint1, rightarg = uint2, procedure = uint1_uint2_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint1, uint2) IS 'uint1_uint2_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint1, rightarg = uint2, procedure = uint1_uint2_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint1, uint2) IS 'uint1_uint2_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint1, rightarg = uint2, procedure = uint1_uint2_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint1, uint2) IS 'uint1_uint2_ge';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint4_eq(uint1,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint4_eq (
uint1,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint4_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint4_lt(uint1,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint4_lt (
uint1,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint4_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint4_le(uint1,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint4_le (
uint1,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint4_le';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint4_gt(uint1,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint4_gt (
uint1,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint4_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint4_ge(uint1,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint4_ge (
uint1,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint4_ge';

CREATE OPERATOR pg_catalog.=(
leftarg = uint1, rightarg = uint4, procedure = uint1_uint4_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint1, uint4) IS 'uint1_uint4_eq';

CREATE OPERATOR pg_catalog.<(
leftarg = uint1, rightarg = uint4, procedure = uint1_uint4_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint1, uint4) IS 'uint1_uint4_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint1, rightarg = uint4, procedure = uint1_uint4_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint1, uint4) IS 'uint1_uint4_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint1, rightarg = uint4, procedure = uint1_uint4_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint1, uint4) IS 'uint1_uint4_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint1, rightarg = uint4, procedure = uint1_uint4_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint1, uint4) IS 'uint1_uint4_ge';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint8_eq(uint1,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint8_eq (
uint1,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint8_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint8_lt(uint1,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint8_lt (
uint1,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint8_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint8_le(uint1,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint8_le (
uint1,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint8_le';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint8_gt(uint1,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint8_gt (
uint1,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint8_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_uint8_ge(uint1,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint1_uint8_ge (
uint1,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_uint8_ge';

CREATE OPERATOR pg_catalog.=(
leftarg = uint1, rightarg = uint8, procedure = uint1_uint8_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint1, uint8) IS 'uint1_uint8_eq';

CREATE OPERATOR pg_catalog.<(
leftarg = uint1, rightarg = uint8, procedure = uint1_uint8_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint1, uint8) IS 'uint1_uint8_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint1, rightarg = uint8, procedure = uint1_uint8_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint1, uint8) IS 'uint1_uint8_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint1, rightarg = uint8, procedure = uint1_uint8_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint1, uint8) IS 'uint1_uint8_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint1, rightarg = uint8, procedure = uint1_uint8_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint1, uint8) IS 'uint1_uint8_ge';

DROP FUNCTION IF EXISTS pg_catalog.uint2_uint4_eq(uint2,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint2_uint4_eq (
uint2,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_uint4_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint2_uint4_lt(uint2,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint2_uint4_lt (
uint2,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_uint4_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint2_uint4_le(uint2,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint2_uint4_le (
uint2,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_uint4_le';

DROP FUNCTION IF EXISTS pg_catalog.uint2_uint4_gt(uint2,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint2_uint4_gt (
uint2,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_uint4_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint2_uint4_ge(uint2,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint2_uint4_ge (
uint2,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_uint4_ge';

CREATE OPERATOR pg_catalog.=(
leftarg = uint2, rightarg = uint4, procedure = uint2_uint4_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint2, uint4) IS 'uint2_uint4_eq';

CREATE OPERATOR pg_catalog.<(
leftarg = uint2, rightarg = uint4, procedure = uint2_uint4_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint2, uint4) IS 'uint2_uint4_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint2, rightarg = uint4, procedure = uint2_uint4_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint2, uint4) IS 'uint2_uint4_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint2, rightarg = uint4, procedure = uint2_uint4_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint2, uint4) IS 'uint2_uint4_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint2, rightarg = uint4, procedure = uint2_uint4_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint2, uint4) IS 'uint2_uint4_ge';

DROP FUNCTION IF EXISTS pg_catalog.uint2_uint8_eq(uint2,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint2_uint8_eq (
uint2,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_uint8_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint2_uint8_lt(uint2,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint2_uint8_lt (
uint2,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_uint8_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint2_uint8_le(uint2,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint2_uint8_le (
uint2,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_uint8_le';

DROP FUNCTION IF EXISTS pg_catalog.uint2_uint8_gt(uint2,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint2_uint8_gt (
uint2,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_uint8_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint2_uint8_ge(uint2,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint2_uint8_ge (
uint2,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_uint8_ge';

CREATE OPERATOR pg_catalog.=(
leftarg = uint2, rightarg = uint8, procedure = uint2_uint8_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint2, uint8) IS 'uint2_uint8_eq';

CREATE OPERATOR pg_catalog.<(
leftarg = uint2, rightarg = uint8, procedure = uint2_uint8_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint2, uint8) IS 'uint2_uint8_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint2, rightarg = uint8, procedure = uint2_uint8_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint2, uint8) IS 'uint2_uint8_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint2, rightarg = uint8, procedure = uint2_uint8_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint2, uint8) IS 'uint2_uint8_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint2, rightarg = uint8, procedure = uint2_uint8_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint2, uint8) IS 'uint2_uint8_ge';

DROP FUNCTION IF EXISTS pg_catalog.uint4_uint8_eq(uint4,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint4_uint8_eq (
uint4,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_uint8_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint8_uint4_eq(uint8,uint4) CASCADE;
CREATE FUNCTION pg_catalog.uint8_uint4_eq (
uint8,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_uint4_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint4_uint8_lt(uint4,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint4_uint8_lt (
uint4,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_uint8_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint4_uint8_le(uint4,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint4_uint8_le (
uint4,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_uint8_le';

DROP FUNCTION IF EXISTS pg_catalog.uint4_uint8_gt(uint4,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint4_uint8_gt (
uint4,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_uint8_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint4_uint8_ge(uint4,uint8) CASCADE;
CREATE FUNCTION pg_catalog.uint4_uint8_ge (
uint4,uint8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_uint8_ge';

CREATE OPERATOR pg_catalog.=(
leftarg = uint4, rightarg = uint8, procedure = uint4_uint8_eq,
restrict = eqsel, join = eqjoinsel,
commutator=operator(pg_catalog.=),
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint4, uint8) IS 'uint4_uint8_eq';

CREATE OPERATOR pg_catalog.=(
leftarg = uint8, rightarg = uint4, procedure = uint8_uint4_eq,
restrict = eqsel, join = eqjoinsel,
commutator=operator(pg_catalog.=),
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint8, uint4) IS 'uint8_uint4_eq';

CREATE OPERATOR pg_catalog.<(
leftarg = uint4, rightarg = uint8, procedure = uint4_uint8_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint4, uint8) IS 'uint4_uint8_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint4, rightarg = uint8, procedure = uint4_uint8_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint4, uint8) IS 'uint4_uint8_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint4, rightarg = uint8, procedure = uint4_uint8_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint4, uint8) IS 'uint4_uint8_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint4, rightarg = uint8, procedure = uint4_uint8_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint4, uint8) IS 'uint4_uint8_ge';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int2_eq(uint1,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int2_eq (
uint1,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int2_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int2_lt(uint1,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int2_lt (
uint1,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int2_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int2_le(uint1,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int2_le (
uint1,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int2_le';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int2_gt(uint1,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int2_gt (
uint1,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int2_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int2_ge(uint1,int2) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int2_ge (
uint1,int2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int2_ge';

CREATE OPERATOR pg_catalog.=(
leftarg = uint1, rightarg = int2, procedure = uint1_int2_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint1, uint2) IS 'uint1_int2_eq';

CREATE OPERATOR pg_catalog.<(
leftarg = uint1, rightarg = int2, procedure = uint1_int2_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint1, uint2) IS 'uint1_int2_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint1, rightarg = int2, procedure = uint1_int2_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint1, uint2) IS 'uint1_int2_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint1, rightarg = int2, procedure = uint1_int2_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint1, uint2) IS 'uint1_int2_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint1, rightarg = int2, procedure = uint1_int2_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint1, uint2) IS 'uint1_int2_ge';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int4_eq(uint1,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int4_eq (
uint1,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int4_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int4_lt(uint1,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int4_lt (
uint1,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int4_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int4_le(uint1,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int4_le (
uint1,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int4_le';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int4_gt(uint1,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int4_gt (
uint1,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int4_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int4_ge(uint1,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int4_ge (
uint1,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int4_ge';

CREATE OPERATOR pg_catalog.=(
leftarg = uint1, rightarg = int4, procedure = uint1_int4_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint1, uint4) IS 'uint1_int4_eq';

CREATE OPERATOR pg_catalog.<(
leftarg = uint1, rightarg = int4, procedure = uint1_int4_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint1, uint4) IS 'uint1_int4_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint1, rightarg = int4, procedure = uint1_int4_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint1, uint4) IS 'uint1_int4_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint1, rightarg = int4, procedure = uint1_int4_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint1, uint4) IS 'uint1_int4_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint1, rightarg = int4, procedure = uint1_int4_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint1, uint4) IS 'uint1_int4_ge';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int8_eq(uint1,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int8_eq (
uint1,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int8_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int8_lt(uint1,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int8_lt (
uint1,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int8_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int8_le(uint1,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int8_le (
uint1,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int8_le';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int8_gt(uint1,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int8_gt (
uint1,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int8_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint1_int8_ge(uint1,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint1_int8_ge (
uint1,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_int8_ge';

CREATE OPERATOR pg_catalog.=(
leftarg = uint1, rightarg = int8, procedure = uint1_int8_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint1, uint8) IS 'uint1_int8_eq';

CREATE OPERATOR pg_catalog.<(
leftarg = uint1, rightarg = int8, procedure = uint1_int8_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint1, uint8) IS 'uint1_int8_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint1, rightarg = int8, procedure = uint1_int8_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint1, uint8) IS 'uint1_int8_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint1, rightarg = int8, procedure = uint1_int8_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint1, uint8) IS 'uint1_int8_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint1, rightarg = int8, procedure = uint1_int8_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint1, uint8) IS 'uint1_int8_ge';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int4_eq(uint2,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int4_eq (
uint2,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int4_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int4_lt(uint2,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int4_lt (
uint2,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int4_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int4_le(uint2,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int4_le (
uint2,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int4_le';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int4_gt(uint2,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int4_gt (
uint2,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int4_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int4_ge(uint2,int4) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int4_ge (
uint2,int4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int4_ge';

CREATE OPERATOR pg_catalog.=(
leftarg = uint2, rightarg = int4, procedure = uint2_int4_eq,
restrict = eqsel, join = eqjoinsel,
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint2, uint4) IS 'uint2_int4_eq';

CREATE OPERATOR pg_catalog.<(
leftarg = uint2, rightarg = int4, procedure = uint2_int4_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint2, uint4) IS 'uint2_int4_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint2, rightarg = int4, procedure = uint2_int4_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint2, uint4) IS 'uint2_int4_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint2, rightarg = int4, procedure = uint2_int4_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint2, uint4) IS 'uint2_int4_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint2, rightarg = int4, procedure = uint2_int4_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint2, uint4) IS 'uint2_int4_ge';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int8_eq(uint2,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int8_eq (
uint2,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int8_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int8_lt(uint2,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int8_lt (
uint2,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int8_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int8_le(uint2,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int8_le (
uint2,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int8_le';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int8_gt(uint2,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int8_gt (
uint2,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int8_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint2_int8_ge(uint2,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint2_int8_ge (
uint2,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_int8_ge';

CREATE OPERATOR pg_catalog.=(
leftarg = uint2, rightarg = int8, procedure = uint2_int8_eq,
restrict = eqsel, join = eqjoinsel, commutator = operator(pg_catalog.=),
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint2, uint8) IS 'uint2_int8_eq';

CREATE OPERATOR pg_catalog.<(
leftarg = uint2, rightarg = int8, procedure = uint2_int8_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint2, uint8) IS 'uint2_int8_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint2, rightarg = int8, procedure = uint2_int8_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint2, uint8) IS 'uint2_int8_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint2, rightarg = int8, procedure = uint2_int8_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint2, uint8) IS 'uint2_int8_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint2, rightarg = int8, procedure = uint2_int8_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint2, uint8) IS 'uint2_int8_ge';

DROP FUNCTION IF EXISTS pg_catalog.uint4_int8_eq(uint4,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint4_int8_eq (
uint4,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int8_eq';

DROP FUNCTION IF EXISTS pg_catalog.uint4_int8_lt(uint4,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint4_int8_lt (
uint4,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int8_lt';

DROP FUNCTION IF EXISTS pg_catalog.uint4_int8_le(uint4,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint4_int8_le (
uint4,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int8_le';

DROP FUNCTION IF EXISTS pg_catalog.uint4_int8_gt(uint4,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint4_int8_gt (
uint4,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int8_gt';

DROP FUNCTION IF EXISTS pg_catalog.uint4_int8_ge(uint4,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint4_int8_ge (
uint4,int8
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_int8_ge';

CREATE OPERATOR pg_catalog.=(
leftarg = uint4, rightarg = int8, procedure = uint4_int8_eq,
restrict = eqsel, join = eqjoinsel, commutator=operator(pg_catalog.=),
HASHES, MERGES
);
COMMENT ON OPERATOR pg_catalog.=(uint4, uint8) IS 'uint4_int8_eq';

CREATE OPERATOR pg_catalog.<(
leftarg = uint4, rightarg = int8, procedure = uint4_int8_lt
);
COMMENT ON OPERATOR pg_catalog.<(uint4, uint8) IS 'uint4_int8_lt';

CREATE OPERATOR pg_catalog.<=(
leftarg = uint4, rightarg = int8, procedure = uint4_int8_le
);
COMMENT ON OPERATOR pg_catalog.<=(uint4, uint8) IS 'uint4_int8_le';

CREATE OPERATOR pg_catalog.>(
leftarg = uint4, rightarg = int8, procedure = uint4_int8_gt
);
COMMENT ON OPERATOR pg_catalog.>(uint4, uint8) IS 'uint4_int8_gt';

CREATE OPERATOR pg_catalog.>=(
leftarg = uint4, rightarg = int8, procedure = uint4_int8_ge
);
COMMENT ON OPERATOR pg_catalog.>=(uint4, uint8) IS 'uint4_int8_ge';

CREATE OR REPLACE FUNCTION pg_catalog.uint1_sortsupport (internal) RETURNS void LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint1_sortsupport';

CREATE OR REPLACE FUNCTION pg_catalog.uint2_sortsupport (internal) RETURNS void LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint2_sortsupport';

CREATE OR REPLACE FUNCTION pg_catalog.uint4_sortsupport (internal) RETURNS void LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint4_sortsupport';

CREATE OR REPLACE FUNCTION pg_catalog.uint8_sortsupport (internal) RETURNS void LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint8_sortsupport';

CREATE OPERATOR CLASS uint_ops
    DEFAULT FOR TYPE uint1 USING btree family integer_ops AS
        OPERATOR        1       < ,
        OPERATOR        1       <(uint1, uint2),
        OPERATOR        1       <(uint1, uint4),
        OPERATOR        1       <(uint1, uint8),
        OPERATOR        1       <(uint1, int1),
        OPERATOR        1       <(uint1, int2),
        OPERATOR        1       <(uint1, int4),
        OPERATOR        1       <(uint1, int8),
        OPERATOR        2       <= ,
        OPERATOR        2       <=(uint1, uint2),
        OPERATOR        2       <=(uint1, uint4),
        OPERATOR        2       <=(uint1, uint8),
        OPERATOR        2       <=(uint1, int1),
        OPERATOR        2       <=(uint1, int2),
        OPERATOR        2       <=(uint1, int4),
        OPERATOR        2       <=(uint1, int8),
        OPERATOR        3       = ,
        OPERATOR        3       =(uint1, uint2),
        OPERATOR        3       =(uint1, uint4),
        OPERATOR        3       =(uint1, uint8),
        OPERATOR        3       =(uint1, int1),
        OPERATOR        3       =(uint1, int2),
        OPERATOR        3       =(uint1, int4),
        OPERATOR        3       =(uint1, int8),
        OPERATOR        4       >= ,
        OPERATOR        4       >=(uint1, uint2),
        OPERATOR        4       >=(uint1, uint4),
        OPERATOR        4       >=(uint1, uint8),
        OPERATOR        4       >=(uint1, int1),
        OPERATOR        4       >=(uint1, int2),
        OPERATOR        4       >=(uint1, int4),
        OPERATOR        4       >=(uint1, int8),
        OPERATOR        5       > ,
        OPERATOR        5       >(uint1, uint2),
        OPERATOR        5       >(uint1, uint4),
        OPERATOR        5       >(uint1, uint8),
        OPERATOR        5       >(uint1, int1),
        OPERATOR        5       >(uint1, int2),
        OPERATOR        5       >(uint1, int4),
        OPERATOR        5       >(uint1, int8),
        FUNCTION        1       uint1cmp(uint1, uint1),
        FUNCTION        1       uint12cmp(uint1, uint2),
        FUNCTION        1       uint14cmp(uint1, uint4),
        FUNCTION        1       uint18cmp(uint1, uint8),
        FUNCTION        1       uint1_int1cmp(uint1, int1),
        FUNCTION        1       uint1_int2cmp(uint1, int2),
        FUNCTION        1       uint1_int4cmp(uint1, int4),
        FUNCTION        1       uint1_int8cmp(uint1, int8),
        FUNCTION        2       uint1_sortsupport(internal);

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);

CREATE OPERATOR CLASS uint8_ops
    DEFAULT FOR TYPE uint8 USING btree family integer_ops AS
        OPERATOR        1       < ,
        OPERATOR        1       <(uint8, int8),
        OPERATOR        2       <= ,
        OPERATOR        2       <=(uint8, int8),
        OPERATOR        3       = ,
        OPERATOR        3       =(uint8, int8),
        OPERATOR        4       >= ,
        OPERATOR        4       >=(uint8, int8),
        OPERATOR        5       > ,
        OPERATOR        5       >(uint8, int8),
        FUNCTION        1       uint8cmp(uint8, uint8),
        FUNCTION        1       uint8_int8cmp(uint8, int8),
        FUNCTION        2       uint8_sortsupport(internal);

CREATE OPERATOR CLASS uint1_ops
    DEFAULT FOR TYPE uint1 USING hash family integer_ops AS
        OPERATOR        1       = ,
        OPERATOR        1       =(uint1, uint2),
        OPERATOR        1       =(uint1, uint4),
        OPERATOR        1       =(uint1, uint8),
        OPERATOR        1       =(uint1, int1),
        OPERATOR        1       =(uint1, int2),
        OPERATOR        1       =(uint1, int4),
        OPERATOR        1       =(uint1, int8),
        OPERATOR        1       =(int1, uint1),
        FUNCTION        1       hashint1(int1),
        FUNCTION        1       hashuint1(uint1);

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 uint8_ops
    DEFAULT FOR TYPE uint8 USING hash family integer_ops AS
        OPERATOR        1       = ,
        OPERATOR        1       =(uint8, int8),
        OPERATOR        1       =(int8, uint8),
        OPERATOR        1       =(uint8, uint4),
        FUNCTION        1       hashuint8(uint8);

-- << and >> operator
DROP FUNCTION IF EXISTS pg_catalog.uint1shr(uint1,int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1shr (
uint1,int4
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1shr';

CREATE OPERATOR pg_catalog.>>(
leftarg = uint1, rightarg = int4, procedure = uint1shr
);
COMMENT ON OPERATOR pg_catalog.>>(uint1, int4) IS 'uint1shr';

DROP FUNCTION IF EXISTS pg_catalog.uint1shl(uint1,int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1shl (
uint1,int4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1shl';

CREATE OPERATOR pg_catalog.<<(
leftarg = uint1, rightarg = int4, procedure = uint1shl
);
COMMENT ON OPERATOR pg_catalog.<<(uint1, int4) IS 'uint1shl';

DROP FUNCTION IF EXISTS pg_catalog.uint2shr(uint2,int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint2shr (
uint2,int4
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2shr';

CREATE OPERATOR pg_catalog.>>(
leftarg = uint2, rightarg = int4, procedure = uint2shr
);
COMMENT ON OPERATOR pg_catalog.>>(uint2, int4) IS 'uint2shr';

DROP FUNCTION IF EXISTS pg_catalog.uint2shl(uint2,int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint2shl (
uint2,int4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2shl';

CREATE OPERATOR pg_catalog.<<(
leftarg = uint2, rightarg = int4, procedure = uint2shl
);
COMMENT ON OPERATOR pg_catalog.<<(uint2, int4) IS 'uint2shl';

--uint4
DROP FUNCTION IF EXISTS pg_catalog.uint4shr(uint4,int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint4shr (
uint4,int4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4shr';

CREATE OPERATOR pg_catalog.>>(
leftarg = uint4, rightarg = int4, procedure = uint4shr
);
COMMENT ON OPERATOR pg_catalog.>>(uint4, int4) IS 'uint4shr';

DROP FUNCTION IF EXISTS pg_catalog.uint4shl(uint4,int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint4shl (
uint4,int4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4shl';

CREATE OPERATOR pg_catalog.<<(
leftarg = uint4, rightarg = int4, procedure = uint4shl
);
COMMENT ON OPERATOR pg_catalog.<<(uint4, int4) IS 'uint4shl';

--uint8
DROP FUNCTION IF EXISTS pg_catalog.uint8shr(uint8,int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint8shr (
uint8,int4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8shr';

CREATE OPERATOR pg_catalog.>>(
leftarg = uint8, rightarg = int4, procedure = uint8shr
);
COMMENT ON OPERATOR pg_catalog.>>(uint8, int4) IS 'uint8shr';

DROP FUNCTION IF EXISTS pg_catalog.uint8shl(uint8,int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint8shl (
uint8,int4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8shl';

CREATE OPERATOR pg_catalog.<<(
leftarg = uint8, rightarg = int4, procedure = uint8shl
);
COMMENT ON OPERATOR pg_catalog.<<(uint8, int4) IS 'uint8shl';

-- ~operator

CREATE OPERATOR pg_catalog.~(
rightarg = uint1, procedure = uint1not
);

CREATE OPERATOR pg_catalog.~(
rightarg = uint2, procedure = uint2not
);

CREATE OPERATOR pg_catalog.~(
rightarg = uint4, procedure = uint4not
);

CREATE OPERATOR pg_catalog.~(
rightarg = uint8, procedure = uint8not
);

--|

CREATE OPERATOR pg_catalog.|(
leftarg = uint1, rightarg = uint1, procedure = uint1or,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(uint1, uint1) IS 'uint1or';

CREATE OPERATOR pg_catalog.|(
leftarg = uint2, rightarg = uint2, procedure = uint2or,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(uint2, uint2) IS 'uint2or';

CREATE OPERATOR pg_catalog.|(
leftarg = uint4, rightarg = uint4, procedure = uint4or,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(uint4, uint4) IS 'uint4or';

CREATE OPERATOR pg_catalog.|(
leftarg = uint8, rightarg = uint8, procedure = uint8or,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(uint8, uint8) IS 'uint8or';

DROP FUNCTION IF EXISTS pg_catalog.uint1_or_int1(uint1, int1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1_or_int1 (
uint1, int1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_or_int1';

CREATE OPERATOR pg_catalog.|(
leftarg = uint1, rightarg = int1, procedure = uint1_or_int1,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(uint1, int1) IS 'uint1_or_int1';

DROP FUNCTION IF EXISTS pg_catalog.int1_or_uint1(int1, uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int1_or_uint1 (
int1, uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_or_uint1';

CREATE OPERATOR pg_catalog.|(
leftarg = int1, rightarg = uint1, procedure = int1_or_uint1,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(int1, uint1) IS 'int1_or_uint1';

DROP FUNCTION IF EXISTS pg_catalog.uint2_or_int2(uint2, int2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint2_or_int2 (
uint2, int2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_or_int2';

CREATE OPERATOR pg_catalog.|(
leftarg = uint2, rightarg = int2, procedure = uint2_or_int2,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(uint2, int2) IS 'uint2_or_int2';

DROP FUNCTION IF EXISTS pg_catalog.int2_or_uint2(int2, uint2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int2_or_uint2 (
int2, uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_or_uint2';

CREATE OPERATOR pg_catalog.|(
leftarg = int2, rightarg = uint2, procedure = int2_or_uint2,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(int2, uint2) IS 'int2_or_uint2';


DROP FUNCTION IF EXISTS pg_catalog.uint4_or_int4(uint4, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint4_or_int4 (
uint4, int4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_or_int4';

CREATE OPERATOR pg_catalog.|(
leftarg = uint4, rightarg = int4, procedure = uint4_or_int4,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(uint4, int4) IS 'uint4_or_int4';

DROP FUNCTION IF EXISTS pg_catalog.int4_or_uint4(int4, uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int4_or_uint4 (
int4, uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_or_uint4';

CREATE OPERATOR pg_catalog.|(
leftarg = int4, rightarg = uint4, procedure = int4_or_uint4,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(int4, uint4) IS 'int4_or_uint4';

DROP FUNCTION IF EXISTS pg_catalog.uint8_or_int8(uint8, int8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint8_or_int8 (
uint8, int8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_or_int8';

CREATE OPERATOR pg_catalog.|(
leftarg = uint8, rightarg = int8, procedure = uint8_or_int8,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(uint8, int8) IS 'uint8_or_int8';

DROP FUNCTION IF EXISTS pg_catalog.int8_or_uint8(int8, uint8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int8_or_uint8 (
int8, uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_or_uint8';

CREATE OPERATOR pg_catalog.|(
leftarg = int8, rightarg = uint8, procedure = int8_or_uint8,
commutator=operator(pg_catalog.|)
);
COMMENT ON OPERATOR pg_catalog.|(int8, uint8) IS 'int8_or_uint8';

--#

CREATE OPERATOR pg_catalog.#(
leftarg = uint1, rightarg = uint1, procedure = uint1xor,
commutator=operator(pg_catalog.#)
);
COMMENT ON OPERATOR pg_catalog.#(uint1, uint1) IS 'uint1xor';

CREATE OPERATOR pg_catalog.#(
leftarg = uint2, rightarg = uint2, procedure = uint2xor,
commutator=operator(pg_catalog.#)
);
COMMENT ON OPERATOR pg_catalog.#(uint2, uint2) IS 'uint2xor';

CREATE OPERATOR pg_catalog.#(
leftarg = uint4, rightarg = uint4, procedure = uint4xor,
commutator=operator(pg_catalog.#)
);
COMMENT ON OPERATOR pg_catalog.#(uint4, uint4) IS 'uint4xor';

CREATE OPERATOR pg_catalog.#(
leftarg = uint8, rightarg = uint8, procedure = uint8xor,
commutator=operator(pg_catalog.#)
);
COMMENT ON OPERATOR pg_catalog.#(uint8, uint8) IS 'uint8xor';

DROP FUNCTION IF EXISTS pg_catalog.uint1_xor_int1(uint1, int1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1_xor_int1 (
uint1, int1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_xor_int1';

CREATE OPERATOR pg_catalog.#(
leftarg = uint1, rightarg = int1, procedure = uint1_xor_int1
);
COMMENT ON OPERATOR pg_catalog.#(uint1, int1) IS 'uint1_xor_int1';

DROP FUNCTION IF EXISTS pg_catalog.int1_xor_uint1(int1, uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int1_xor_uint1 (
int1, uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_xor_uint1';

CREATE OPERATOR pg_catalog.#(
leftarg = int1, rightarg = uint1, procedure = int1_xor_uint1
);
COMMENT ON OPERATOR pg_catalog.#(int1, uint1) IS 'int1_xor_uint1';

DROP FUNCTION IF EXISTS pg_catalog.uint2_xor_int2(uint2, int2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint2_xor_int2 (
uint2, int2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_xor_int2';

CREATE OPERATOR pg_catalog.#(
leftarg = uint2, rightarg = int2, procedure = uint2_xor_int2,
commutator=operator(pg_catalog.#)
);
COMMENT ON OPERATOR pg_catalog.#(uint2, int2) IS 'uint2_xor_int2';

DROP FUNCTION IF EXISTS pg_catalog.int2_xor_uint2(int2, uint2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int2_xor_uint2 (
int2, uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_xor_uint2';

CREATE OPERATOR pg_catalog.#(
leftarg = int2, rightarg = uint2, procedure = int2_xor_uint2,
commutator=operator(pg_catalog.#)
);
COMMENT ON OPERATOR pg_catalog.#(int2, uint2) IS 'int2_xor_uint2';

DROP FUNCTION IF EXISTS pg_catalog.uint4_xor_int4(uint4, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint4_xor_int4 (
uint4, int4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_xor_int4';

CREATE OPERATOR pg_catalog.#(
leftarg = uint4, rightarg = int4, procedure = uint4_xor_int4,
commutator=operator(pg_catalog.#)
);
COMMENT ON OPERATOR pg_catalog.#(uint4, int4) IS 'uint4_xor_int4';

DROP FUNCTION IF EXISTS pg_catalog.int4_xor_uint4(int4, uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int4_xor_uint4 (
int4, uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_xor_uint4';

CREATE OPERATOR pg_catalog.#(
leftarg = int4, rightarg = uint4, procedure = int4_xor_uint4,
commutator=operator(pg_catalog.#)
);
COMMENT ON OPERATOR pg_catalog.#(int4, uint4) IS 'int4_xor_uint4';

DROP FUNCTION IF EXISTS pg_catalog.uint8_xor_int8(uint8, int8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint8_xor_int8 (
uint8, int8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_xor_int8';

CREATE OPERATOR pg_catalog.#(
leftarg = uint8, rightarg = int8, procedure = uint8_xor_int8,
commutator=operator(pg_catalog.#)
);
COMMENT ON OPERATOR pg_catalog.#(uint8, int8) IS 'uint8_xor_int8';

DROP FUNCTION IF EXISTS pg_catalog.int8_xor_uint8(int8, uint8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int8_xor_uint8 (
int8, uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_xor_uint8';

CREATE OPERATOR pg_catalog.#(
leftarg = int8, rightarg = uint8, procedure = int8_xor_uint8,
commutator=operator(pg_catalog.#)
);
COMMENT ON OPERATOR pg_catalog.#(int8, uint8) IS 'int8_xor_uint8';

-- & operator

CREATE OPERATOR pg_catalog.&(
leftarg = uint1, rightarg = uint1, procedure = uint1and,
commutator=operator(pg_catalog.&)
);
COMMENT ON OPERATOR pg_catalog.&(uint1, uint1) IS 'uint1and';

CREATE OPERATOR pg_catalog.&(
leftarg = uint2, rightarg = uint2, procedure = uint2and,
commutator=operator(pg_catalog.&)
);
COMMENT ON OPERATOR pg_catalog.&(uint2, uint2) IS 'uint2and';

CREATE OPERATOR pg_catalog.&(
leftarg = uint4, rightarg = uint4, procedure = uint4and,
commutator=operator(pg_catalog.&)
);
COMMENT ON OPERATOR pg_catalog.&(uint4, uint4) IS 'uint4and';

CREATE OPERATOR pg_catalog.&(
leftarg = uint8, rightarg = uint8, procedure = uint8and,
commutator=operator(pg_catalog.&)
);
COMMENT ON OPERATOR pg_catalog.&(uint8, uint8) IS 'uint8and';

DROP FUNCTION IF EXISTS pg_catalog.uint1_and_int1(uint1, int1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1_and_int1 (
uint1, int1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_and_int1';

CREATE OPERATOR pg_catalog.&(
leftarg = uint1, rightarg = int1, procedure = uint1_and_int1
);
COMMENT ON OPERATOR pg_catalog.&(uint1, int1) IS 'uint1_and_int1';

DROP FUNCTION IF EXISTS pg_catalog.int1_and_uint1(int1, uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int1_and_uint1 (
int1, uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_and_uint1';

CREATE OPERATOR pg_catalog.&(
leftarg = int1, rightarg = uint1, procedure = int1_and_uint1
);
COMMENT ON OPERATOR pg_catalog.&(int1, uint1) IS 'int1_and_uint1';

DROP FUNCTION IF EXISTS pg_catalog.uint2_and_int2(uint2, int2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint2_and_int2 (
uint2, int2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_and_int2';

CREATE OPERATOR pg_catalog.&(
leftarg = uint2, rightarg = int2, procedure = uint2_and_int2,
commutator=operator(pg_catalog.&)
);
COMMENT ON OPERATOR pg_catalog.&(uint2, int2) IS 'uint2_and_int2';

DROP FUNCTION IF EXISTS pg_catalog.int2_and_uint2(int2, uint2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int2_and_uint2 (
int2, uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_and_uint2';

CREATE OPERATOR pg_catalog.&(
leftarg = int2, rightarg = uint2, procedure = int2_and_uint2,
commutator=operator(pg_catalog.&)
);
COMMENT ON OPERATOR pg_catalog.&(int2, uint2) IS 'int2_and_uint2';

DROP FUNCTION IF EXISTS pg_catalog.uint4_and_int4(uint4, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint4_and_int4 (
uint4, int4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_and_int4';

CREATE OPERATOR pg_catalog.&(
leftarg = uint4, rightarg = int4, procedure = uint4_and_int4,
commutator=operator(pg_catalog.&)
);
COMMENT ON OPERATOR pg_catalog.&(uint4, int4) IS 'uint4_and_int4';

DROP FUNCTION IF EXISTS pg_catalog.int4_and_uint4(int4, uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int4_and_uint4 (
int4, uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_and_uint4';

CREATE OPERATOR pg_catalog.&(
leftarg = int4, rightarg = uint4, procedure = int4_and_uint4,
commutator=operator(pg_catalog.&)
);
COMMENT ON OPERATOR pg_catalog.&(int4, uint4) IS 'int4_and_uint4';

DROP FUNCTION IF EXISTS pg_catalog.uint8_and_int8(uint8, int8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint8_and_int8 (
uint8, int8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_and_int8';

CREATE OPERATOR pg_catalog.&(
leftarg = uint8, rightarg = int8, procedure = uint8_and_int8,
commutator=operator(pg_catalog.&)
);
COMMENT ON OPERATOR pg_catalog.&(uint8, int8) IS 'uint8_and_int8';

DROP FUNCTION IF EXISTS pg_catalog.int8_and_uint8(int8, uint8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int8_and_uint8 (
int8, uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_and_uint8';

CREATE OPERATOR pg_catalog.&(
leftarg = int8, rightarg = uint8, procedure = int8_and_uint8,
commutator=operator(pg_catalog.&)
);
COMMENT ON OPERATOR pg_catalog.&(int8, uint8) IS 'int8_and_uint8';

-- cast
DROP FUNCTION IF EXISTS pg_catalog.i1_cast_ui1(int1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i1_cast_ui1 (
int1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1_cast_ui1';

DROP FUNCTION IF EXISTS pg_catalog.i2_cast_ui1(int2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i2_cast_ui1 (
int2
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i2_cast_ui1';

DROP FUNCTION IF EXISTS pg_catalog.i4_cast_ui1(int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i4_cast_ui1 (
int4
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i4_cast_ui1';

DROP FUNCTION IF EXISTS pg_catalog.i8_cast_ui1(int8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i8_cast_ui1 (
int8
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i8_cast_ui1';

DROP FUNCTION IF EXISTS pg_catalog.i1_cast_ui2(int1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i1_cast_ui2 (
int1
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1_cast_ui2';

DROP FUNCTION IF EXISTS pg_catalog.i2_cast_ui2(int2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i2_cast_ui2 (
int2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i2_cast_ui2';

DROP FUNCTION IF EXISTS pg_catalog.i4_cast_ui2(int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i4_cast_ui2 (
int4
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i4_cast_ui2';

DROP FUNCTION IF EXISTS pg_catalog.i8_cast_ui2(int8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i8_cast_ui2 (
int8
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i8_cast_ui2';

DROP FUNCTION IF EXISTS pg_catalog.i1_cast_ui4(int1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i1_cast_ui4 (
int1
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1_cast_ui4';

DROP FUNCTION IF EXISTS pg_catalog.i2_cast_ui4(int2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i2_cast_ui4 (
int2
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i2_cast_ui4';

DROP FUNCTION IF EXISTS pg_catalog.i4_cast_ui4(int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i4_cast_ui4 (
int4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i4_cast_ui4';

DROP FUNCTION IF EXISTS pg_catalog.i8_cast_ui4(int8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i8_cast_ui4 (
int8
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i8_cast_ui4';

DROP FUNCTION IF EXISTS pg_catalog.i1_cast_ui8(int1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i1_cast_ui8 (
int1
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1_cast_ui8';

DROP FUNCTION IF EXISTS pg_catalog.i2_cast_ui8(int2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i2_cast_ui8 (
int2
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i2_cast_ui8';

DROP FUNCTION IF EXISTS pg_catalog.i4_cast_ui8(int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i4_cast_ui8 (
int4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i4_cast_ui8';

DROP FUNCTION IF EXISTS pg_catalog.i8_cast_ui8(int8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.i8_cast_ui8 (
int8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i8_cast_ui8';

DROP FUNCTION IF EXISTS pg_catalog.f4_cast_ui1(float4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.f4_cast_ui1 (
float4
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f4_cast_ui1';

DROP FUNCTION IF EXISTS pg_catalog.f8_cast_ui1(float8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.f8_cast_ui1 (
float8
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f8_cast_ui1';

DROP FUNCTION IF EXISTS pg_catalog.f4_cast_ui2(float4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.f4_cast_ui2 (
float4
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f4_cast_ui2';

DROP FUNCTION IF EXISTS pg_catalog.f8_cast_ui2(float8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.f8_cast_ui2 (
float8
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f8_cast_ui2';

DROP FUNCTION IF EXISTS pg_catalog.f4_cast_ui4(float4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.f4_cast_ui4 (
float4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f4_cast_ui4';

DROP FUNCTION IF EXISTS pg_catalog.f8_cast_ui4(float8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.f8_cast_ui4 (
float8
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f8_cast_ui4';

DROP FUNCTION IF EXISTS pg_catalog.f4_cast_ui8(float4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.f4_cast_ui8 (
float4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f4_cast_ui8';

DROP FUNCTION IF EXISTS pg_catalog.f8_cast_ui8(float8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.f8_cast_ui8 (
float8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'f8_cast_ui8';

-- uint -> cash
DROP FUNCTION IF EXISTS pg_catalog.uint_cash(uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint_cash (
uint1
) RETURNS money LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint_cash';
DROP FUNCTION IF EXISTS pg_catalog.uint_cash(uint2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint_cash (
uint2
) RETURNS money LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint_cash';
DROP FUNCTION IF EXISTS pg_catalog.uint_cash(uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint_cash (
uint4
) RETURNS money LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint_cash';
DROP FUNCTION IF EXISTS pg_catalog.uint_cash(uint8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint_cash (
uint8
) RETURNS money LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint_cash';
drop CAST IF EXISTS (uint1 AS money) CASCADE;
CREATE CAST (uint1 AS money) WITH FUNCTION uint_cash(uint1) AS ASSIGNMENT;
drop CAST IF EXISTS (uint2 AS money) CASCADE;
CREATE CAST (uint2 AS money) WITH FUNCTION uint_cash(uint2) AS ASSIGNMENT;
drop CAST IF EXISTS (uint4 AS money) CASCADE;
CREATE CAST (uint4 AS money) WITH FUNCTION uint_cash(uint4) AS ASSIGNMENT;
drop CAST IF EXISTS (uint8 AS money) CASCADE;
CREATE CAST (uint8 AS money) WITH FUNCTION uint_cash(uint8) AS ASSIGNMENT;

-- uint4 <-> time
drop CAST IF EXISTS (uint4 AS abstime) CASCADE;
CREATE CAST (uint4 AS abstime) WITHOUT FUNCTION;
drop CAST IF EXISTS (abstime AS uint4) CASCADE;
CREATE CAST (abstime as uint4) WITHOUT FUNCTION;
drop CAST IF EXISTS (uint4 AS reltime) CASCADE;
CREATE CAST (uint4 AS reltime) WITHOUT FUNCTION;
drop CAST IF EXISTS (reltime AS uint4) CASCADE;
CREATE CAST (reltime as uint4) WITHOUT FUNCTION;

DROP FUNCTION IF EXISTS pg_catalog.int32_b_format_date(uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_date (
uint4
) RETURNS date LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int32_b_format_date';
drop CAST IF EXISTS (uint4 AS date) CASCADE;
CREATE CAST (uint4 AS date) WITH FUNCTION int32_b_format_date(uint4);

DROP FUNCTION IF EXISTS pg_catalog.int32_b_format_time(uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_time (
uint4
) RETURNS time LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int32_b_format_time';
drop CAST IF EXISTS (uint4 AS time) CASCADE;
CREATE CAST (uint4 AS time) WITH FUNCTION int32_b_format_time(uint4);

DROP FUNCTION IF EXISTS pg_catalog.int32_b_format_datetime(uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_datetime (
uint4
) RETURNS timestamp(0) without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int32_b_format_datetime';
drop CAST IF EXISTS (uint4 AS timestamp(0) without time zone) CASCADE;
CREATE CAST (uint4 AS timestamp(0) without time zone) WITH FUNCTION int32_b_format_datetime(uint4);

DROP FUNCTION IF EXISTS pg_catalog.int64_b_format_datetime(uint8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_datetime (
uint8
) RETURNS timestamp(0) without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int64_b_format_datetime';
drop CAST IF EXISTS (uint8 AS timestamp(0) without time zone) CASCADE;
CREATE CAST (uint8 AS timestamp(0) without time zone) WITH FUNCTION int64_b_format_datetime(uint8);

DROP FUNCTION IF EXISTS pg_catalog.int32_b_format_timestamp(uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_timestamp (
uint4
) RETURNS timestamptz LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int32_b_format_timestamp';
drop CAST IF EXISTS (uint4 AS timestamptz) CASCADE;
CREATE CAST (uint4 AS timestamptz) WITH FUNCTION int32_b_format_timestamp(uint4);

DROP FUNCTION IF EXISTS pg_catalog.int64_b_format_timestamp(uint8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_timestamp (
uint8
) RETURNS timestamptz LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int64_b_format_timestamp';
drop CAST IF EXISTS (uint8 AS timestamptz) CASCADE;
CREATE CAST (uint8 AS timestamptz) WITH FUNCTION int64_b_format_timestamp(uint8);

DROP FUNCTION IF EXISTS pg_catalog.int32_year(uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int32_year (
uint4
) RETURNS year LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int32_year';
drop CAST IF EXISTS (uint4 AS year) CASCADE;
CREATE CAST (uint4 AS year) WITH FUNCTION int32_year(uint4);

DROP FUNCTION IF EXISTS pg_catalog.year_uint4(year) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.year_uint4 (
year
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'year_integer';
drop CAST IF EXISTS (uint4 AS year) CASCADE;
CREATE CAST (uint4 AS year) WITH FUNCTION int32_year(uint4);

drop CAST IF EXISTS (year AS uint4) CASCADE;
CREATE CAST (year AS uint4) WITH FUNCTION year_uint4(year);

DROP FUNCTION IF EXISTS pg_catalog.year_uint8("year") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.year_uint8("year") RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_uint8';;
drop CAST IF EXISTS (year AS uint8) CASCADE;
CREATE CAST ("year" as uint8) with function pg_catalog.year_uint8("year");

-- uint <-> bit
DROP FUNCTION IF EXISTS pg_catalog.bittouint4(bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bittouint4 (
bit
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittouint4';
DROP FUNCTION IF EXISTS pg_catalog.bittouint8(bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bittouint8 (
bit
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittouint8';
DROP FUNCTION IF EXISTS pg_catalog.bitfromuint4(uint4, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bitfromuint4 (
uint4, int4
) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromuint4';
DROP FUNCTION IF EXISTS pg_catalog.bitfromuint8(uint8, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bitfromuint8 (
uint8, int4
) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromuint8';

drop CAST IF EXISTS (bit AS uint4) CASCADE;
drop CAST IF EXISTS (bit AS uint8) CASCADE;
drop CAST IF EXISTS (uint4 AS bit) CASCADE;
drop CAST IF EXISTS (uint8 AS bit) CASCADE;

CREATE CAST (bit AS uint4) WITH FUNCTION bittouint4(bit) AS IMPLICIT;
CREATE CAST (bit AS uint8) WITH FUNCTION bittouint8(bit) AS IMPLICIT;
CREATE CAST (uint4 AS bit) WITH FUNCTION bitfromuint4(uint4, int4);
CREATE CAST (uint8 AS bit) WITH FUNCTION bitfromuint8(uint8, int4);

-- uint <-> int16
DROP FUNCTION IF EXISTS pg_catalog.uint_16(uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint_16 (
uint1
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint_16';
DROP FUNCTION IF EXISTS pg_catalog.uint_16(uint2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint_16 (
uint2
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint_16';
DROP FUNCTION IF EXISTS pg_catalog.uint_16(uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint_16 (
uint4
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint_16';
DROP FUNCTION IF EXISTS pg_catalog.uint_16(uint8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint_16 (
uint8
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint_16';

DROP FUNCTION IF EXISTS pg_catalog.int16_u1(int16) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int16_u1 (
int16
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int16_u1';

DROP FUNCTION IF EXISTS pg_catalog.int16_u2(int16) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int16_u2 (
int16
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int16_u2';

DROP FUNCTION IF EXISTS pg_catalog.int16_u4(int16) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int16_u4 (
int16
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int16_u4';

DROP FUNCTION IF EXISTS pg_catalog.int16_u8(int16) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.int16_u8 (
int16
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int16_u8';

drop CAST IF EXISTS (uint1 AS int16) CASCADE;
CREATE CAST (uint1 AS int16) WITH FUNCTION uint_16(uint1) AS ASSIGNMENT;
drop CAST IF EXISTS (uint2 AS int16) CASCADE;
CREATE CAST (uint2 AS int16) WITH FUNCTION uint_16(uint2) AS ASSIGNMENT;
drop CAST IF EXISTS (uint4 AS int16) CASCADE;
CREATE CAST (uint4 AS int16) WITH FUNCTION uint_16(uint4) AS ASSIGNMENT;
drop CAST IF EXISTS (uint8 AS int16) CASCADE;
CREATE CAST (uint8 AS int16) WITH FUNCTION uint_16(uint8) AS ASSIGNMENT;

drop CAST IF EXISTS (int16 AS uint1) CASCADE;
CREATE CAST (int16 AS uint1) WITH FUNCTION int16_u1(int16) AS ASSIGNMENT;
drop CAST IF EXISTS (int16 AS uint2) CASCADE;
CREATE CAST (int16 AS uint2) WITH FUNCTION int16_u2(int16) AS ASSIGNMENT;
drop CAST IF EXISTS (int16 AS uint4) CASCADE;
CREATE CAST (int16 AS uint4) WITH FUNCTION int16_u4(int16) AS ASSIGNMENT;
drop CAST IF EXISTS (int16 AS uint8) CASCADE;
CREATE CAST (int16 AS uint8) WITH FUNCTION int16_u8(int16) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.text_cast_uint1(text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.text_cast_uint1 (
text
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_cast_uint1';

DROP FUNCTION IF EXISTS pg_catalog.text_cast_uint2(text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.text_cast_uint2 (
text
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_cast_uint2';

DROP FUNCTION IF EXISTS pg_catalog.text_cast_uint4(text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.text_cast_uint4 (
text
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_cast_uint4';

DROP FUNCTION IF EXISTS pg_catalog.text_cast_uint8(text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.text_cast_uint8 (
text
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_cast_uint8';

-- ^ operator

CREATE FUNCTION pg_catalog.op_uint1xor(uint1, uint1) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint1xor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_uint2xor(uint2, uint2) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint2xor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_uint4xor(uint4, uint4) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint4xor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_uint8xor(uint8, uint8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint8xor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_uint1_xor_int1(uint1, int1) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint1_xor_int1($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_int1_xor_uint1(int1, uint1) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int1_xor_uint1($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_uint2_xor_int2(uint2, int2) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint2_xor_int2($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_int2_xor_uint2(int2, uint2) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int2_xor_uint2($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_uint4_xor_int4(uint4, int4) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint4_xor_int4($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_int4_xor_uint4(int4, uint4) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int4_xor_uint4($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_uint8_xor_int8(uint8, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint8_xor_int8($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_int8_xor_uint8(int8, uint8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_xor_uint8($1, $2)::uint8';

CREATE OPERATOR pg_catalog.^(
leftarg = uint1, rightarg = uint1, procedure = op_uint1xor,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(uint1, uint1) IS 'op_uint1xor';


CREATE OPERATOR pg_catalog.^(
leftarg = uint2, rightarg = uint2, procedure = op_uint2xor,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(uint2, uint2) IS 'op_uint2xor';


CREATE OPERATOR pg_catalog.^(
leftarg = uint4, rightarg = uint4, procedure = op_uint4xor,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(uint4, uint4) IS 'op_uint4xor';


CREATE OPERATOR pg_catalog.^(
leftarg = uint8, rightarg = uint8, procedure = op_uint8xor,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(uint8, uint8) IS 'op_uint8xor';


CREATE OPERATOR pg_catalog.^(
leftarg = uint1, rightarg = int1, procedure = op_uint1_xor_int1
);
COMMENT ON OPERATOR pg_catalog.^(uint1, int1) IS 'op_uint1_xor_int1';


CREATE OPERATOR pg_catalog.^(
leftarg = int1, rightarg = uint1, procedure = op_int1_xor_uint1
);
COMMENT ON OPERATOR pg_catalog.^(int1, uint1) IS 'op_int1_xor_uint1';


CREATE OPERATOR pg_catalog.^(
leftarg = uint2, rightarg = int2, procedure = op_uint2_xor_int2,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(uint2, int2) IS 'op_uint2_xor_int2';


CREATE OPERATOR pg_catalog.^(
leftarg = int2, rightarg = uint2, procedure = op_int2_xor_uint2,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(int2, uint2) IS 'op_int2_xor_uint2';


CREATE OPERATOR pg_catalog.^(
leftarg = uint4, rightarg = int4, procedure = op_uint4_xor_int4,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(uint4, int4) IS 'op_uint4_xor_int4';


CREATE OPERATOR pg_catalog.^(
leftarg = int4, rightarg = uint4, procedure = op_int4_xor_uint4,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(int4, uint4) IS 'op_int4_xor_uint4';


CREATE OPERATOR pg_catalog.^(
leftarg = uint8, rightarg = int8, procedure = op_uint8_xor_int8,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(uint8, int8) IS 'op_uint8_xor_int8';


CREATE OPERATOR pg_catalog.^(
leftarg = int8, rightarg = uint8, procedure = op_int8_xor_uint8,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(int8, uint8) IS 'op_int8_xor_uint8';

DROP FUNCTION IF EXISTS pg_catalog.uint2_xor_bool(uint2, boolean) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint2_xor_bool (
uint2, boolean
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_xor_bool';

DROP FUNCTION IF EXISTS pg_catalog.uint1_xor_bool(uint1, boolean) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint1_xor_bool (
uint1, boolean
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_xor_bool';

DROP FUNCTION IF EXISTS pg_catalog.uint4_xor_bool(uint4, boolean) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint4_xor_bool (
uint4, boolean
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_xor_bool';

DROP FUNCTION IF EXISTS pg_catalog.uint8_xor_bool(uint8, boolean) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint8_xor_bool (
uint8, boolean
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_xor_bool';

DROP FUNCTION IF EXISTS pg_catalog.bool_xor_uint1(boolean, uint1) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bool_xor_uint1 (
boolean, uint1
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bool_xor_uint1';

DROP FUNCTION IF EXISTS pg_catalog.bool_xor_uint2(boolean, uint2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bool_xor_uint2 (
boolean, uint2
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bool_xor_uint2';

DROP FUNCTION IF EXISTS pg_catalog.bool_xor_uint4(boolean, uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bool_xor_uint4 (
boolean, uint4
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bool_xor_uint4';

DROP FUNCTION IF EXISTS pg_catalog.bool_xor_uint8(boolean, uint8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bool_xor_uint8 (
boolean, uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bool_xor_uint8';

CREATE FUNCTION pg_catalog.op_uint8_xor_bool(uint8, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint8xor($1, $2::uint8)::uint8';
CREATE OPERATOR pg_catalog.^(
leftarg = uint8, rightarg = boolean, procedure = op_uint8_xor_bool,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(uint8, boolean) IS 'op_uint8_xor_bool';
CREATE FUNCTION pg_catalog.op_uint4_xor_bool(uint4, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint4xor($1, $2::uint8)::uint8';
CREATE OPERATOR pg_catalog.^(
leftarg = uint4, rightarg = boolean, procedure = op_uint4_xor_bool,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(uint4, boolean) IS 'op_uint4_xor_bool';
CREATE FUNCTION pg_catalog.op_uint2_xor_bool(uint2, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint2xor($1, $2::uint8)::uint8';
CREATE OPERATOR pg_catalog.^(
leftarg = uint2, rightarg = boolean, procedure = op_uint2_xor_bool,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(uint2, boolean) IS 'op_uint2_xor_bool';
CREATE FUNCTION pg_catalog.op_uint1_xor_bool(uint1, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint1xor($1, $2::uint8)::uint8';
CREATE OPERATOR pg_catalog.^(
leftarg = uint1, rightarg = boolean, procedure = op_uint1_xor_bool,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(uint1, boolean) IS 'op_uint1_xor_bool';
CREATE FUNCTION pg_catalog.op_bool_xor_uint1(boolean, uint1) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint1xor($1::uint8, $2)::uint8';
CREATE OPERATOR pg_catalog.^(
leftarg = boolean, rightarg = uint1, procedure = op_bool_xor_uint1,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(boolean, uint1) IS 'op_bool_xor_uint1';
CREATE FUNCTION pg_catalog.op_bool_xor_uint2(boolean, uint2) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint2xor($1::uint8, $2)::uint8';
CREATE OPERATOR pg_catalog.^(
leftarg = boolean, rightarg = uint2, procedure = op_bool_xor_uint2,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(boolean, uint2) IS 'op_bool_xor_uint2';
CREATE FUNCTION pg_catalog.op_bool_xor_uint4(boolean, uint4) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint4xor($1::uint8, $2)::uint8';
CREATE OPERATOR pg_catalog.^(
leftarg = boolean, rightarg = uint4, procedure = op_bool_xor_uint4,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(boolean, uint4) IS 'op_bool_xor_uint4';
CREATE FUNCTION pg_catalog.op_bool_xor_uint8(boolean, uint8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint8xor($1::uint8, $2)::uint8';
CREATE OPERATOR pg_catalog.^(
leftarg = boolean, rightarg = uint8, procedure = op_bool_xor_uint8,
commutator=operator(pg_catalog.^)
);
COMMENT ON OPERATOR pg_catalog.^(boolean, uint8) IS 'op_bool_xor_uint8';

DROP FUNCTION IF EXISTS pg_catalog.timestamp_uint8(timestamp(0) with time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_uint8(timestamp(0) with time zone)
RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamp_uint8';
drop CAST IF EXISTS (timestamp(0) with time zone AS uint8) CASCADE;
CREATE CAST (timestamp(0) with time zone AS uint8) WITH FUNCTION timestamp_uint8(timestamp(0) with time zone);

DROP FUNCTION IF EXISTS pg_catalog.cash_uint(money) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.cash_uint(money)
RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'cash_uint';
drop CAST IF EXISTS (money AS uint8) CASCADE;
CREATE CAST (money AS uint8) WITH FUNCTION cash_uint(money) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.int8_xor(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.int8_xor (
uint8,int8
) RETURNS uint8 LANGUAGE C as '$libdir/dolphin',  'uint8_xor_int8';
drop aggregate if exists pg_catalog.bit_xor(int8);
create aggregate pg_catalog.bit_xor(int8) (SFUNC=int8_xor, STYPE= uint8);

DROP FUNCTION IF EXISTS pg_catalog.uint8_xor(uint8,int8) CASCADE;
CREATE FUNCTION pg_catalog.uint8_xor (
uint8,int8
) RETURNS uint8 LANGUAGE C as '$libdir/dolphin',  'uint8xor';

DROP FUNCTION IF EXISTS pg_catalog.text_xor(uint8,text) CASCADE;
CREATE FUNCTION pg_catalog.text_xor (t1 uint8,t2 text) RETURNS uint8 AS
$$
DECLARE num NUMBER := to_number(t2);
BEGIN
    IF num > 9223372036854775807 then
        num = 9223372036854775807;
    ELSEIF num < -9223372036854775808 then
        num = 9223372036854775808;
    END IF;
    RETURN (SELECT uint8_xor(t1, num));
END;
$$
LANGUAGE plpgsql;
drop aggregate if exists pg_catalog.bit_xor(text);
create aggregate pg_catalog.bit_xor(text) (SFUNC=text_xor, STYPE= uint8);

DROP FUNCTION IF EXISTS pg_catalog.uint_any_value (uint8, uint8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint_any_value (uint8, uint8) RETURNS uint8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint_any_value';
drop aggregate if exists pg_catalog.any_value(uint8);
CREATE AGGREGATE pg_catalog.any_value(uint8) (
        sfunc = uint_any_value,
        stype = uint8
);

CREATE OR REPLACE FUNCTION pg_catalog.op_bool_xor_int1(boolean, int1) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int1xor($1::int1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_xor_int2(boolean, int2) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int2xor($1::int2, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_xor_int4(boolean, int4) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int4xor($1::int4, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_xor_int8(boolean, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8xor($1::int8, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int1_xor_bool(int1, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int1xor($1, $2::int1)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int2_xor_bool(int2, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int2xor($1, $2::int2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int4_xor_bool(int4, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int4xor($1, $2::int4)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int8_xor_bool(int8, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8xor($1, $2::int8)::uint8';
CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = int1, procedure = pg_catalog.op_bool_xor_int1, commutator=operator(pg_catalog.^));
CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = int2, procedure = pg_catalog.op_bool_xor_int2, commutator=operator(pg_catalog.^));
CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = int4, procedure = pg_catalog.op_bool_xor_int4, commutator=operator(pg_catalog.^));
CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = int8, procedure = pg_catalog.op_bool_xor_int8, commutator=operator(pg_catalog.^));
CREATE OPERATOR pg_catalog.^(leftarg = int8, rightarg = boolean, procedure = pg_catalog.op_int8_xor_bool, commutator=operator(pg_catalog.^));
CREATE OPERATOR pg_catalog.^(leftarg = int4, rightarg = boolean, procedure = pg_catalog.op_int4_xor_bool, commutator=operator(pg_catalog.^));
CREATE OPERATOR pg_catalog.^(leftarg = int2, rightarg = boolean, procedure = pg_catalog.op_int2_xor_bool, commutator=operator(pg_catalog.^));
CREATE OPERATOR pg_catalog.^(leftarg = int1, rightarg = boolean, procedure = pg_catalog.op_int1_xor_bool, commutator=operator(pg_catalog.^));/* binary */
DROP TYPE IF EXISTS pg_catalog.binary CASCADE;
DROP TYPE IF EXISTS pg_catalog."_binary" CASCADE;

CREATE TYPE pg_catalog.binary;

DROP FUNCTION IF EXISTS pg_catalog.binary_in(cstring) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.binary_in (
cstring
) RETURNS binary  LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_binaryin';

DROP FUNCTION IF EXISTS pg_catalog.binary_out(binary) CASCADE;

CREATE FUNCTION pg_catalog.binary_out (
binary
) RETURNS cstring LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteaout';

DROP FUNCTION IF EXISTS pg_catalog.binary_recv(internal) CASCADE;

CREATE FUNCTION pg_catalog.binary_recv (
internal
) RETURNS binary LANGUAGE INTERNAL IMMUTABLE STRICT as 'bytearecv';

DROP FUNCTION IF EXISTS pg_catalog.binary_send(binary) CASCADE;

CREATE FUNCTION pg_catalog.binary_send (
binary
) RETURNS bytea LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteasend';

DROP FUNCTION IF EXISTS pg_catalog.binary_typmodin(_cstring) CASCADE;

CREATE FUNCTION pg_catalog.binary_typmodin (
_cstring
) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'binary_typmodin';

DROP FUNCTION IF EXISTS pg_catalog.binary_typmodout(int) CASCADE;

CREATE FUNCTION pg_catalog.binary_typmodout (
int
) RETURNS cstring LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'binary_typmodout';

CREATE TYPE pg_catalog.binary (input=binary_in, output=binary_out,
                                typmod_in = binary_typmodin, typmod_out = binary_typmodout,
                                receive = binary_recv, send = binary_send,
                                STORAGE=EXTENDED, category='S');

CREATE OR REPLACE FUNCTION pg_catalog.binary_in (
text
) RETURNS binary   AS
$$
BEGIN
    RETURN (SELECT binary_in($1::cstring));
END;
$$
LANGUAGE plpgsql;

CREATE FUNCTION pg_catalog.binarytextlike(
binary,
text
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT bytealike($1::bytea,$2::binary::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.~~(leftarg = binary, rightarg = text, procedure = pg_catalog.binarytextlike);
CREATE OPERATOR pg_catalog.~~*(leftarg = binary, rightarg = text, procedure = pg_catalog.binarytextlike);

CREATE FUNCTION pg_catalog.textbinarylike(
text,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT bytealike($1::binary::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.~~(leftarg = text, rightarg = binary, procedure = pg_catalog.textbinarylike);
CREATE OPERATOR pg_catalog.~~*(leftarg = text, rightarg = binary, procedure = pg_catalog.textbinarylike);

CREATE FUNCTION pg_catalog.binarytextnlike(
binary,
text
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteanlike($1::bytea,$2::binary::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.!~~(leftarg = binary, rightarg = text, procedure = pg_catalog.binarytextnlike);
CREATE OPERATOR pg_catalog.!~~*(leftarg = binary, rightarg = text, procedure = pg_catalog.binarytextnlike);

CREATE FUNCTION pg_catalog.textbinarynlike(
text,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteanlike($1::binary::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.!~~(leftarg = text, rightarg = binary, procedure = pg_catalog.textbinarynlike);
CREATE OPERATOR pg_catalog.!~~*(leftarg = text, rightarg = binary, procedure = pg_catalog.textbinarynlike);

CREATE FUNCTION pg_catalog.like_escape(
binary,
text
) RETURNS bytea AS
$$
BEGIN
    RETURN (SELECT like_escape($1::bytea,$2::binary::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OR REPLACE FUNCTION pg_catalog.binaryeq(
binary,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteaeq($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.=(leftarg = binary, rightarg = binary, procedure = pg_catalog.binaryeq,restrict = eqsel, join = eqjoinsel,
HASHES, MERGES);

CREATE OR REPLACE FUNCTION pg_catalog.binaryne(
binary,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteane($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<>(leftarg = binary, rightarg = binary, procedure = pg_catalog.binaryne,restrict = neqsel, join = neqjoinsel);


CREATE OR REPLACE FUNCTION pg_catalog.binarygt(
binary,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteagt($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = binary, procedure = pg_catalog.binarygt,restrict = scalargtsel, join = scalargtjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.binarylt(
binary,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT bytealt($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = binary, procedure = pg_catalog.binarylt,restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.binaryge(
binary,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteage($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = binary, procedure = pg_catalog.binaryge,restrict = scalargtsel, join = scalargtjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.binaryle(
binary,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteale($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = binary, procedure = pg_catalog.binaryle,restrict = scalarltsel, join = scalarltjoinsel);
/* varbinary */
DROP TYPE IF EXISTS pg_catalog.varbinary CASCADE;
DROP TYPE IF EXISTS pg_catalog._varbinary CASCADE;

CREATE TYPE pg_catalog.varbinary;

DROP FUNCTION IF EXISTS pg_catalog.varbinary_in(cstring) CASCADE;

CREATE FUNCTION pg_catalog.varbinary_in (
cstring
) RETURNS varbinary LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteain';

DROP FUNCTION IF EXISTS pg_catalog.varbinary_out(varbinary) CASCADE;

CREATE FUNCTION pg_catalog.varbinary_out (
varbinary
) RETURNS cstring LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteaout';

DROP FUNCTION IF EXISTS pg_catalog.varbinary_recv(internal, oid, int) CASCADE;

CREATE FUNCTION pg_catalog.varbinary_recv (
internal
) RETURNS varbinary LANGUAGE INTERNAL IMMUTABLE STRICT as 'bytearecv';

DROP FUNCTION IF EXISTS pg_catalog.varbinary_send(varbinary) CASCADE;

CREATE FUNCTION pg_catalog.varbinary_send (
varbinary
) RETURNS bytea LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteasend';

DROP FUNCTION IF EXISTS pg_catalog.varbinary_typmodin(_cstring) CASCADE;

CREATE FUNCTION pg_catalog.varbinary_typmodin (
_cstring
) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varbinary_typmodin';

CREATE TYPE pg_catalog.varbinary (input=varbinary_in, output=varbinary_out,
                                typmod_in = varbinary_typmodin, typmod_out = binary_typmodout,
                                receive = varbinary_recv, send = varbinary_send,
                                STORAGE=EXTENDED, category='S');

CREATE OR REPLACE FUNCTION pg_catalog.text_varbinary_eq(
text,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteaeq($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.=(leftarg = text, rightarg = varbinary, procedure = pg_catalog.text_varbinary_eq,restrict = eqsel, join = eqjoinsel,
HASHES, MERGES);

CREATE OR REPLACE FUNCTION pg_catalog.text_varbinary_ne(
text,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteane($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<>(leftarg = text, rightarg = varbinary, procedure = pg_catalog.text_varbinary_ne,restrict = neqsel, join = neqjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.text_varbinary_gt(
text,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteagt($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.>(leftarg = text, rightarg = varbinary, procedure = pg_catalog.text_varbinary_gt,restrict = scalargtsel, join = scalargtjoinsel);


CREATE OR REPLACE FUNCTION pg_catalog.text_varbinary_lt(
text,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT bytealt($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<(leftarg = text, rightarg = varbinary, procedure = pg_catalog.text_varbinary_lt,restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.text_varbinary_ge(
text,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteage($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.>=(leftarg = text, rightarg = varbinary, procedure = pg_catalog.text_varbinary_ge,restrict = scalargtsel, join = scalargtjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.text_varbinary_le(
text,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteale($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<=(leftarg = text, rightarg = varbinary, procedure = pg_catalog.text_varbinary_le,restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_text_eq(
varbinary,
text
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteaeq($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.=(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinary_text_eq,restrict = eqsel, join = eqjoinsel,
HASHES, MERGES);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_text_ne(
varbinary,
text
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteane($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<>(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinary_text_ne,restrict = neqsel, join = neqjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_text_gt(
varbinary,
text
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteagt($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.>(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinary_text_gt,restrict = scalargtsel, join = scalargtjoinsel);


CREATE OR REPLACE FUNCTION pg_catalog.varbinary_text_lt(
varbinary,
text
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT bytealt($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinary_text_lt,restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_text_ge(
varbinary,
text
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteage($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.>=(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinary_text_ge,restrict = scalargtsel, join = scalargtjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_text_le(
varbinary,
text
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteale($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<=(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinary_text_le,restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary_eq(
binary,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteaeq($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.=(leftarg = binary, rightarg = varbinary, procedure = pg_catalog.binary_varbinary_eq,restrict = eqsel, join = eqjoinsel,
HASHES, MERGES);

CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary_ne(
binary,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteane($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<>(leftarg = binary, rightarg = varbinary, procedure = pg_catalog.binary_varbinary_ne,restrict = neqsel, join = neqjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary_gt(
binary,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteagt($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = varbinary, procedure = pg_catalog.binary_varbinary_gt,restrict = scalargtsel, join = scalargtjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary_lt(
binary,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT bytealt($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = varbinary, procedure = pg_catalog.binary_varbinary_lt,restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary_ge(
binary,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteage($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = varbinary, procedure = pg_catalog.binary_varbinary_ge,restrict = scalargtsel, join = scalargtjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary_le(
binary,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteale($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = varbinary, procedure = pg_catalog.binary_varbinary_le,restrict = scalarltsel, join = scalarltjoinsel);



CREATE OR REPLACE FUNCTION pg_catalog.varbinary_binary_eq(
varbinary,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteaeq($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.=(leftarg = varbinary, rightarg = binary, procedure = pg_catalog.varbinary_binary_eq,restrict = eqsel, join = eqjoinsel,
HASHES, MERGES);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_binary_ne(
varbinary,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteane($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<>(leftarg = varbinary, rightarg = binary, procedure = pg_catalog.varbinary_binary_ne,restrict = neqsel, join = neqjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_binary_gt(
varbinary,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteagt($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.>(leftarg = varbinary, rightarg = binary, procedure = pg_catalog.varbinary_binary_gt,restrict = scalargtsel, join = scalargtjoinsel);


CREATE OR REPLACE FUNCTION pg_catalog.varbinary_binary_lt(
varbinary,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT bytealt($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<(leftarg = varbinary, rightarg = binary, procedure = pg_catalog.varbinary_binary_lt,restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_binary_ge(
varbinary,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteage($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.>=(leftarg = varbinary, rightarg = binary, procedure = pg_catalog.varbinary_binary_ge,restrict = scalargtsel, join = scalargtjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_binary_le(
varbinary,
binary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteale($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<=(leftarg = varbinary, rightarg = binary, procedure = pg_catalog.varbinary_binary_le,restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_varbinary_eq(
varbinary,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteaeq($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.=(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_varbinary_eq,restrict = eqsel, join = eqjoinsel,
HASHES, MERGES);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_varbinary_ne(
varbinary,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteane($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<>(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_varbinary_ne,restrict = neqsel, join = neqjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_varbinary_gt(
varbinary,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteagt($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.>(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_varbinary_gt,restrict = scalargtsel, join = scalargtjoinsel);


CREATE OR REPLACE FUNCTION pg_catalog.varbinary_varbinary_lt(
varbinary,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT bytealt($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_varbinary_lt,restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_varbinary_ge(
varbinary,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteage($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.>=(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_varbinary_ge,restrict = scalargtsel, join = scalargtjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_varbinary_le(
varbinary,
varbinary
) RETURNS bool AS
$$
BEGIN
    RETURN (SELECT byteale($1::bytea,$2::bytea));
END;
$$
LANGUAGE plpgsql;

CREATE OPERATOR pg_catalog.<=(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_varbinary_le,restrict = scalarltsel, join = scalarltjoinsel);


-- to_binary
DROP FUNCTION IF EXISTS pg_catalog.to_binary(bytea, int) CASCADE;

CREATE FUNCTION pg_catalog.to_binary (
bytea,
int
) RETURNS binary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bytea2binary';
-- to_varbinary
DROP FUNCTION IF EXISTS pg_catalog.to_varbinary(bytea, int) CASCADE;

CREATE FUNCTION pg_catalog.to_varbinary (
bytea,
int
) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bytea2var';


CREATE CAST (binary AS bytea) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (varbinary AS bytea) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (bytea AS binary) WITH FUNCTION to_binary(bytea, int) AS IMPLICIT;
CREATE CAST (bytea AS varbinary) WITH FUNCTION to_varbinary(bytea, int) AS IMPLICIT;

CREATE CAST (varbinary AS binary) WITH FUNCTION to_binary(bytea, int) AS IMPLICIT;
CREATE CAST (binary AS varbinary) WITH FUNCTION to_varbinary(bytea, int) AS IMPLICIT;
CREATE CAST (binary AS binary) WITH FUNCTION to_binary(bytea, int) AS IMPLICIT;
CREATE CAST (varbinary AS varbinary) WITH FUNCTION to_varbinary(bytea, int) AS IMPLICIT;

DROP FUNCTION IF EXISTS pg_catalog.bit2float4(bit) CASCADE;

CREATE FUNCTION pg_catalog.bit2float4 (bit) RETURNS float4 AS
$$
BEGIN
    RETURN (SELECT int4($1));
END;
$$
LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.bit2float8(bit) CASCADE;

CREATE FUNCTION pg_catalog.bit2float8 (bit) RETURNS float8 AS
$$
BEGIN
    RETURN (SELECT int8($1));
END;
$$
LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.bit2numeric(bit) CASCADE;

CREATE FUNCTION pg_catalog.bit2numeric (bit) RETURNS numeric AS
$$
BEGIN
    RETURN (SELECT bittouint8($1));
END;
$$
LANGUAGE plpgsql;

CREATE CAST (bit AS float4) WITH FUNCTION bit2float4(bit) AS IMPLICIT;
CREATE CAST (bit AS float8) WITH FUNCTION bit2float8(bit) AS IMPLICIT;
CREATE CAST (bit AS numeric) WITH FUNCTION bit2numeric(bit) AS IMPLICIT;

-- tinyblob
DROP TYPE IF EXISTS pg_catalog.tinyblob CASCADE;
DROP TYPE IF EXISTS pg_catalog._tinyblob CASCADE;

CREATE TYPE pg_catalog.tinyblob;

DROP FUNCTION IF EXISTS pg_catalog.tinyblob_rawin(cstring) CASCADE;

CREATE FUNCTION pg_catalog.tinyblob_rawin (
cstring
) RETURNS tinyblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'tinyblob_rawin';

DROP FUNCTION IF EXISTS pg_catalog.tinyblob_rawout(tinyblob) CASCADE;

CREATE FUNCTION pg_catalog.tinyblob_rawout (
tinyblob
) RETURNS cstring LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteaout';

DROP FUNCTION IF EXISTS pg_catalog.tinyblob_recv(internal) CASCADE;

CREATE FUNCTION pg_catalog.tinyblob_recv (
internal
) RETURNS tinyblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'tinyblob_recv';

DROP FUNCTION IF EXISTS pg_catalog.tinyblob_send(tinyblob) CASCADE;

CREATE FUNCTION pg_catalog.tinyblob_send (
tinyblob
) RETURNS bytea LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteasend';

CREATE TYPE pg_catalog.tinyblob (input=tinyblob_rawin, output=tinyblob_rawout, RECEIVE = tinyblob_recv, SEND = tinyblob_send, STORAGE=EXTENDED, category='S');


--mediumblob
DROP TYPE IF EXISTS pg_catalog.mediumblob CASCADE;
DROP TYPE IF EXISTS pg_catalog._mediumblob CASCADE;

CREATE TYPE pg_catalog.mediumblob;

DROP FUNCTION IF EXISTS pg_catalog.mediumblob_rawin(cstring) CASCADE;

CREATE FUNCTION pg_catalog.mediumblob_rawin (
cstring
) RETURNS mediumblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'mediumblob_rawin';

DROP FUNCTION IF EXISTS pg_catalog.mediumblob_rawout(mediumblob) CASCADE;

CREATE FUNCTION pg_catalog.mediumblob_rawout (
mediumblob
) RETURNS cstring LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteaout';

DROP FUNCTION IF EXISTS pg_catalog.mediumblob_recv(internal) CASCADE;

CREATE FUNCTION pg_catalog.mediumblob_recv (
internal
) RETURNS mediumblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'mediumblob_recv';

DROP FUNCTION IF EXISTS pg_catalog.mediumblob_send(mediumblob) CASCADE;

CREATE FUNCTION pg_catalog.mediumblob_send (
mediumblob
) RETURNS bytea LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteasend';

CREATE TYPE pg_catalog.mediumblob (input=mediumblob_rawin, output=mediumblob_rawout, RECEIVE = mediumblob_recv, SEND = mediumblob_send, STORAGE=EXTENDED, category='S');

-- longblob
DROP TYPE IF EXISTS pg_catalog.longblob CASCADE;
DROP TYPE IF EXISTS pg_catalog._longblob CASCADE;

CREATE TYPE pg_catalog.longblob;

DROP FUNCTION IF EXISTS pg_catalog.longblob_rawin(cstring) CASCADE;

CREATE FUNCTION pg_catalog.longblob_rawin (
cstring
) RETURNS longblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'longblob_rawin';

DROP FUNCTION IF EXISTS pg_catalog.longblob_rawout(longblob) CASCADE;

CREATE FUNCTION pg_catalog.longblob_rawout (
longblob
) RETURNS cstring LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteaout';

DROP FUNCTION IF EXISTS pg_catalog.longblob_recv(internal) CASCADE;

CREATE FUNCTION pg_catalog.longblob_recv (
internal
) RETURNS longblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'longblob_recv';

DROP FUNCTION IF EXISTS pg_catalog.longblob_send(longblob) CASCADE;

CREATE FUNCTION pg_catalog.longblob_send (
longblob
) RETURNS bytea LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteasend';

CREATE TYPE pg_catalog.longblob (input=longblob_rawin, output=longblob_rawout, RECEIVE = longblob_recv, SEND = longblob_send, STORAGE=EXTENDED, category='S');

-- to_tinyblob
DROP FUNCTION IF EXISTS pg_catalog.to_tinyblob(longblob) CASCADE;

CREATE FUNCTION pg_catalog.to_tinyblob (
longblob
) RETURNS tinyblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'longblob2tinyblob';

-- to_mediumblob
DROP FUNCTION IF EXISTS pg_catalog.to_mediumblob(longblob) CASCADE;

CREATE FUNCTION pg_catalog.to_mediumblob (
longblob
) RETURNS mediumblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'longblob2mediumblob';

CREATE CAST (tinyblob AS longblob) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (mediumblob AS longblob) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (blob AS longblob) WITHOUT FUNCTION AS IMPLICIT;

CREATE CAST (blob AS tinyblob) WITH FUNCTION to_tinyblob(longblob) AS IMPLICIT;
CREATE CAST (mediumblob AS tinyblob) WITH FUNCTION to_tinyblob(longblob) AS IMPLICIT;
CREATE CAST (longblob AS tinyblob) WITH FUNCTION to_tinyblob(longblob) AS IMPLICIT;

CREATE CAST (tinyblob AS blob) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (mediumblob AS blob) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (longblob AS blob) WITHOUT FUNCTION AS IMPLICIT;

CREATE CAST (tinyblob AS mediumblob) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (blob AS mediumblob) WITH FUNCTION to_mediumblob(longblob) AS IMPLICIT;
CREATE CAST (longblob AS mediumblob) WITH FUNCTION to_mediumblob(longblob) AS IMPLICIT;

CREATE CAST (tinyblob AS raw) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (mediumblob AS raw) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (longblob AS raw) WITHOUT FUNCTION AS IMPLICIT;

CREATE CAST (raw AS longblob) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (raw AS tinyblob) WITH FUNCTION to_tinyblob(longblob) AS IMPLICIT;
CREATE CAST (raw AS mediumblob) WITH FUNCTION to_mediumblob(longblob) AS IMPLICIT;

CREATE FUNCTION pg_catalog.numeric_xor(numeric, numeric) returns int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'numeric_xor';
CREATE FUNCTION pg_catalog.op_int1xor(int1, int1) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int1xor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_int2xor(int2, int2) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int2xor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_int4xor(int4, int4) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int4xor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_int8xor(int8, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8xor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_bitxor(bit, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.bitxor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_num_xor_bit(numeric, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.numeric_xor($1, $2::numeric)::uint8';
CREATE FUNCTION pg_catalog.op_bit_xor_num(bit, numeric) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.numeric_xor($1::numeric, $2)::uint8';
CREATE FUNCTION pg_catalog.op_uint8_xor_bit(uint8, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.numeric_xor($1::numeric, $2::numeric)::uint8';
CREATE FUNCTION pg_catalog.op_bit_xor_uint8(bit, uint8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.numeric_xor($1::numeric, $2::numeric)::uint8';
CREATE FUNCTION pg_catalog.op_date_bit_xor(date, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_int8_xor($1, $2::int8)::uint8';
CREATE FUNCTION pg_catalog.op_bit_date_xor(bit, date) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_date_xor($1::int8, $2)::uint8';
CREATE FUNCTION pg_catalog.op_timestamp_bit_xor(timestamp without time zone, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamp_int8_xor($1, $2::int8)::uint8';
CREATE FUNCTION pg_catalog.op_bit_timestamp_xor(bit, timestamp without time zone) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_timestamp_xor($1::int8, $2)::uint8';
CREATE FUNCTION pg_catalog.op_timestamptz_bit_xor(timestampTz, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamptz_int8_xor($1, $2::int8)::uint8';
CREATE FUNCTION pg_catalog.op_bit_timestamptz_xor(bit, timestampTz) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_timestamptz_xor($1::int8, $2)::uint8';
create operator pg_catalog.^(leftarg = int1, rightarg = int1, procedure = pg_catalog.op_int1xor);
create operator pg_catalog.^(leftarg = int2, rightarg = int2, procedure = pg_catalog.op_int2xor);
create operator pg_catalog.^(leftarg = int4, rightarg = int4, procedure = pg_catalog.op_int4xor);
create operator pg_catalog.^(leftarg = int8, rightarg = int8, procedure = pg_catalog.op_int8xor);
create operator pg_catalog.^(leftarg = bit, rightarg = bit, procedure = pg_catalog.op_bitxor);
create operator pg_catalog.^(leftarg = numeric, rightarg = bit, procedure = pg_catalog.op_num_xor_bit);
create operator pg_catalog.^(leftarg = bit, rightarg = numeric, procedure = pg_catalog.op_bit_xor_num);
create operator pg_catalog.^(leftarg = uint8, rightarg = bit, procedure = pg_catalog.op_uint8_xor_bit);
create operator pg_catalog.^(leftarg = bit, rightarg = uint8, procedure = pg_catalog.op_bit_xor_uint8);
CREATE OPERATOR pg_catalog.^(leftarg = date, rightarg = bit, procedure = pg_catalog.op_date_bit_xor);
CREATE OPERATOR pg_catalog.^(leftarg = bit, rightarg = date, procedure = pg_catalog.op_bit_date_xor);
CREATE OPERATOR pg_catalog.^(leftarg = timestamp without time zone, rightarg = bit, procedure = pg_catalog.op_timestamp_bit_xor);
CREATE OPERATOR pg_catalog.^(leftarg = bit, rightarg = timestamp without time zone, procedure = pg_catalog.op_bit_timestamp_xor);
CREATE OPERATOR pg_catalog.^(leftarg = timestampTz, rightarg = bit, procedure = pg_catalog.op_timestamptz_bit_xor);
CREATE OPERATOR pg_catalog.^(leftarg = bit, rightarg = timestampTz, procedure = pg_catalog.op_bit_timestamptz_xor);


create function pg_catalog.blobxor(
blob,
blob
)RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
create function pg_catalog.blobxor(
blob,
int
)RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
create function pg_catalog.blobxor(
int,
blob
)RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
create function pg_catalog.blobxor(
int8,
blob
)RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
create function pg_catalog.blobxor(
blob,
int8
)RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
create function pg_catalog.blobxor(
float8,
blob
)RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
create function pg_catalog.blobxor(
blob,
float8
)RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
CREATE FUNCTION pg_catalog.blob_xor_blob(blob, blob) returns blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blob_xor_blob';
CREATE FUNCTION pg_catalog.mblob_xor_mblob(mediumblob, mediumblob) returns mediumblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blob_xor_blob';
CREATE FUNCTION pg_catalog.lblob_xor_lblob(longblob, longblob) returns longblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blob_xor_blob';
CREATE FUNCTION pg_catalog.binary_xor_binary(binary, binary) returns varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blob_xor_blob';
CREATE FUNCTION pg_catalog.varbinary_xor_varbinary(varbinary, varbinary) returns varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blob_xor_blob';
CREATE FUNCTION pg_catalog.tinyblob_xor_tinyblob(tinyblob, tinyblob) returns varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blob_xor_blob';
CREATE FUNCTION pg_catalog.op_blob_int_xor(blob, integer) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.blobxor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_int_blob_xor(integer, blob) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.blobxor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_int8_blob_xor(int8, blob) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.blobxor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_blob_int8_xor(blob, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.blobxor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_float8_blob_xor(float8, blob) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.blobxor($1, $2)::uint8';
CREATE FUNCTION pg_catalog.op_blob_float8_xor(blob, float8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.blobxor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = blob, rightarg = blob, procedure = pg_catalog.blob_xor_blob);
CREATE OPERATOR pg_catalog.^(leftarg = mediumblob, rightarg = mediumblob, procedure = pg_catalog.mblob_xor_mblob);
CREATE OPERATOR pg_catalog.^(leftarg = longblob, rightarg = longblob, procedure = pg_catalog.lblob_xor_lblob);
CREATE OPERATOR pg_catalog.^(leftarg = binary, rightarg = binary, procedure = pg_catalog.binary_xor_binary);
CREATE OPERATOR pg_catalog.^(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_xor_varbinary);
CREATE OPERATOR pg_catalog.^(leftarg = tinyblob, rightarg = tinyblob, procedure = pg_catalog.tinyblob_xor_tinyblob);
create operator pg_catalog.^(leftarg = blob, rightarg = integer, procedure = pg_catalog.op_blob_int_xor);
create operator pg_catalog.^(leftarg = integer, rightarg = blob, procedure = pg_catalog.op_int_blob_xor);
create operator pg_catalog.^(leftarg = int8, rightarg = blob, procedure = pg_catalog.op_int8_blob_xor);
create operator pg_catalog.^(leftarg = blob, rightarg = int8, procedure = pg_catalog.op_blob_int8_xor);
create operator pg_catalog.^(leftarg = float8, rightarg = blob, procedure = pg_catalog.op_float8_blob_xor);
create operator pg_catalog.^(leftarg = blob, rightarg = float8, procedure = pg_catalog.op_blob_float8_xor);


DROP FUNCTION IF EXISTS pg_catalog.bit_longblob(uint8,longblob) CASCADE;
CREATE FUNCTION pg_catalog.bit_longblob (t1 uint8, t2 longblob) RETURNS uint8  AS
$$
DECLARE num NUMBER := to_number(unhex(substring(cast(t2 as text), 3)));
BEGIN
    IF num > 9223372036854775807 then
        num = 9223372036854775807;
    ELSEIF num < -9223372036854775808 then
        num = 9223372036854775808;
    END IF;
    RETURN (SELECT uint8_xor(t1, num));
END;
$$
LANGUAGE plpgsql;
drop aggregate if exists pg_catalog.bit_xor(longblob);
create aggregate pg_catalog.bit_xor(longblob) (SFUNC=bit_longblob, STYPE= uint8);

DROP FUNCTION IF EXISTS pg_catalog.bit_blob(uint8,blob) CASCADE;
CREATE FUNCTION pg_catalog.bit_blob (t1 uint8, t2 blob) RETURNS uint8  AS
$$
DECLARE num NUMBER := to_number((cast(t2 as text)));
BEGIN
    IF num > 9223372036854775807 then
        num = 9223372036854775807;
    ELSEIF num < -9223372036854775808 then
        num = 9223372036854775808;
    END IF;
    RETURN (SELECT uint8_xor(t1, num));
END;
$$
LANGUAGE plpgsql;
drop aggregate if exists pg_catalog.bit_xor(blob);
create aggregate pg_catalog.bit_xor(blob) (SFUNC=bit_blob, STYPE= uint8);

DROP FUNCTION IF EXISTS pg_catalog.varlena2float8(anyelement) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.varlena2float8(anyelement) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'Varlena2Float8';

CREATE CAST (bytea AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
CREATE CAST ("binary" AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
CREATE CAST ("varbinary" AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
CREATE CAST (blob AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
CREATE CAST (tinyblob AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
CREATE CAST (mediumblob AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
CREATE CAST (longblob AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
CREATE CAST (json AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement);

DROP FUNCTION IF EXISTS pg_catalog.blob_eq(blob, blob) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.blob_eq(arg1 blob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
DROP FUNCTION IF EXISTS pg_catalog.blob_ne(blob, blob) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.blob_ne(arg1 blob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
DROP FUNCTION IF EXISTS pg_catalog.blob_lt(blob, blob) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.blob_lt(arg1 blob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
DROP FUNCTION IF EXISTS pg_catalog.blob_le(blob, blob) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.blob_le(arg1 blob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
DROP FUNCTION IF EXISTS pg_catalog.blob_gt(blob, blob) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.blob_gt(arg1 blob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
DROP FUNCTION IF EXISTS pg_catalog.blob_ge(blob, blob) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.blob_ge(arg1 blob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';

DROP FUNCTION IF EXISTS pg_catalog.blob_eq_text(blob, text) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.blob_eq_text(arg1 blob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_eq($1, $2::blob) $$;
DROP FUNCTION IF EXISTS pg_catalog.blob_ne_text(blob, text) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.blob_ne_text(arg1 blob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_ne($1, $2::blob) $$;
DROP FUNCTION IF EXISTS pg_catalog.blob_lt_text(blob, text) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.blob_lt_text(arg1 blob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_lt($1, $2::blob) $$;
DROP FUNCTION IF EXISTS pg_catalog.blob_le_text(blob, text) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.blob_le_text(arg1 blob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_le($1, $2::blob) $$;
DROP FUNCTION IF EXISTS pg_catalog.blob_gt_text(blob, text) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.blob_gt_text(arg1 blob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_gt($1, $2::blob) $$;
DROP FUNCTION IF EXISTS pg_catalog.blob_ge_text(blob, text) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.blob_ge_text(arg1 blob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_ge($1, $2::blob) $$;

DROP FUNCTION IF EXISTS pg_catalog.text_eq_blob(text, blob) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.text_eq_blob(arg1 text, arg2 blob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_eq($1::blob, $2) $$;
DROP FUNCTION IF EXISTS pg_catalog.text_ne_blob(text, blob) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.text_ne_blob(arg1 text, arg2 blob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_ne($1::blob, $2) $$;
DROP FUNCTION IF EXISTS pg_catalog.text_lt_blob(text, blob) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.text_lt_blob(arg1 text, arg2 blob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_lt($1::blob, $2) $$;
DROP FUNCTION IF EXISTS pg_catalog.text_le_blob(text, blob) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.text_le_blob(arg1 text, arg2 blob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_le($1::blob, $2) $$;
DROP FUNCTION IF EXISTS pg_catalog.test_gt_blob(text, blob) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.test_gt_blob(arg1 text, arg2 blob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_gt($1::blob, $2) $$;
DROP FUNCTION IF EXISTS pg_catalog.test_ge_blob(text, blob) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.test_ge_blob(arg1 text, arg2 blob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_ge($1::blob, $2) $$;

CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = blob, procedure = blob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = blob, procedure = blob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = blob, procedure = blob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = blob, procedure = blob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = blob, procedure = blob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = blob, procedure = blob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = text, procedure = blob_eq_text, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = text, procedure = blob_ne_text, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = text, procedure = blob_lt_text, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = text, procedure = blob_le_text, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = text, procedure = blob_gt_text, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = text, procedure = blob_ge_text, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.=(leftarg = text, rightarg = blob, procedure = text_eq_blob, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = text, rightarg = blob, procedure = text_ne_blob, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = text, rightarg = blob, procedure = text_lt_blob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = text, rightarg = blob, procedure = text_le_blob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = text, rightarg = blob, procedure = test_gt_blob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = text, rightarg = blob, procedure = test_ge_blob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE SCHEMA dolphin_catalog;

/* int4 */
create function dolphin_catalog.dolphin_int4pl (
int4,
int4
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4pl';
create operator dolphin_catalog.+(leftarg = int4, rightarg = int4, procedure = dolphin_catalog.dolphin_int4pl);

create function dolphin_catalog.dolphin_int4mi (
int4,
int4
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4mi';
create operator dolphin_catalog.-(leftarg = int4, rightarg = int4, procedure = dolphin_catalog.dolphin_int4mi);

create function dolphin_catalog.dolphin_int4mul (
int4,
int4
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4mul';
create operator dolphin_catalog.*(leftarg = int4, rightarg = int4, procedure = dolphin_catalog.dolphin_int4mul);

create function dolphin_catalog.dolphin_int4div (
int4,
int4
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4div';
create operator dolphin_catalog./(leftarg = int4, rightarg = int4, procedure = dolphin_catalog.dolphin_int4div);

/* int2 */
create function dolphin_catalog.dolphin_int2pl (
int2,
int2
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2pl';
create operator dolphin_catalog.+(leftarg = int2, rightarg = int2, procedure = dolphin_catalog.dolphin_int2pl);

create function dolphin_catalog.dolphin_int2mi (
int2,
int2
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2mi';
create operator dolphin_catalog.-(leftarg = int2, rightarg = int2, procedure = dolphin_catalog.dolphin_int2mi);

create function dolphin_catalog.dolphin_int2mul (
int2,
int2
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2mul';
create operator dolphin_catalog.*(leftarg = int2, rightarg = int2, procedure = dolphin_catalog.dolphin_int2mul);

create function dolphin_catalog.dolphin_int2div (
int2,
int2
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2div';
create operator dolphin_catalog./(leftarg = int2, rightarg = int2, procedure = dolphin_catalog.dolphin_int2div);

/* int1 */
create function dolphin_catalog.dolphin_int1pl (
int1,
int1
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1pl';
create operator dolphin_catalog.+(leftarg = int1, rightarg = int1, procedure = dolphin_catalog.dolphin_int1pl);

create function dolphin_catalog.dolphin_int1mi (
int1,
int1
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1mi';
create operator dolphin_catalog.-(leftarg = int1, rightarg = int1, procedure = dolphin_catalog.dolphin_int1mi);

create function dolphin_catalog.dolphin_int1mul (
int1,
int1
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1mul';
create operator dolphin_catalog.*(leftarg = int1, rightarg = int1, procedure = dolphin_catalog.dolphin_int1mul);

create function dolphin_catalog.dolphin_int1div (
int1,
int1
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1div';
create operator dolphin_catalog./(leftarg = int1, rightarg = int1, procedure = dolphin_catalog.dolphin_int1div);

CREATE OPERATOR pg_catalog./(leftarg = int1, rightarg = int1, procedure = dolphin_catalog.dolphin_int1div);
COMMENT ON OPERATOR pg_catalog./(int1, int1) IS 'dolphin_int1div';

/* int8 */
create function dolphin_catalog.dolphin_int8pl (
int8,
int8
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int8pl';
create operator dolphin_catalog.+(leftarg = int8, rightarg = int8, procedure = dolphin_catalog.dolphin_int8pl);

create function dolphin_catalog.dolphin_int8mi (
int8,
int8
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int8mi';
create operator dolphin_catalog.-(leftarg = int8, rightarg = int8, procedure = dolphin_catalog.dolphin_int8mi);

create function dolphin_catalog.dolphin_int8mul (
int8,
int8
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int8mul';
create operator dolphin_catalog.*(leftarg = int8, rightarg = int8, procedure = dolphin_catalog.dolphin_int8mul);

create function dolphin_catalog.dolphin_int8div (
int8,
int8
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int8div';
create operator dolphin_catalog./(leftarg = int8, rightarg = int8, procedure = dolphin_catalog.dolphin_int8div);

/* uint1 */
create function dolphin_catalog.dolphin_uint1pl (
uint1,
uint1
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1pl';
create operator dolphin_catalog.+(leftarg = uint1, rightarg = uint1, procedure = dolphin_catalog.dolphin_uint1pl);

create function dolphin_catalog.dolphin_uint1mi (
uint1,
uint1
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1mi';
create operator dolphin_catalog.-(leftarg = uint1, rightarg = uint1, procedure = dolphin_catalog.dolphin_uint1mi);

create function dolphin_catalog.dolphin_uint1mul (
uint1,
uint1
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1mul';
create operator dolphin_catalog.*(leftarg = uint1, rightarg = uint1, procedure = dolphin_catalog.dolphin_uint1mul);

create function dolphin_catalog.dolphin_uint1div (
uint1,
uint1
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1div';
create operator dolphin_catalog./(leftarg = uint1, rightarg = uint1, procedure = dolphin_catalog.dolphin_uint1div);

/* int1_uint1 */
create function dolphin_catalog.dolphin_int1_pl_uint1 (
int1,
uint1
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1_pl_uint1';
create operator dolphin_catalog.+(leftarg = int1, rightarg = uint1, procedure = dolphin_catalog.dolphin_int1_pl_uint1);

create function dolphin_catalog.dolphin_int1_mi_uint1 (
int1,
uint1
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1_mi_uint1';
create operator dolphin_catalog.-(leftarg = int1, rightarg = uint1, procedure = dolphin_catalog.dolphin_int1_mi_uint1);

create function dolphin_catalog.dolphin_int1_mul_uint1 (
int1,
uint1
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1_mul_uint1';
create operator dolphin_catalog.*(leftarg = int1, rightarg = uint1, procedure = dolphin_catalog.dolphin_int1_mul_uint1);

create function dolphin_catalog.dolphin_int1_div_uint1 (
int1,
uint1
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1_div_uint1';
create operator dolphin_catalog./(leftarg = int1, rightarg = uint1, procedure = dolphin_catalog.dolphin_int1_div_uint1);

/* uint1_int1 */
create function dolphin_catalog.dolphin_uint1_pl_int1 (
uint1,
int1
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1_pl_int1';
create operator dolphin_catalog.+(leftarg = uint1, rightarg = int1, procedure = dolphin_catalog.dolphin_uint1_pl_int1);

create function dolphin_catalog.dolphin_uint1_mi_int1 (
uint1,
int1
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1_mi_int1';
create operator dolphin_catalog.-(leftarg = uint1, rightarg = int1, procedure = dolphin_catalog.dolphin_uint1_mi_int1);

create function dolphin_catalog.dolphin_uint1_mul_int1 (
uint1,
int1
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1_mul_int1';
create operator dolphin_catalog.*(leftarg = uint1, rightarg = int1, procedure = dolphin_catalog.dolphin_uint1_mul_int1);

create function dolphin_catalog.dolphin_uint1_div_int1 (
uint1,
int1
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1_div_int1';
create operator dolphin_catalog./(leftarg = uint1, rightarg = int1, procedure = dolphin_catalog.dolphin_uint1_div_int1);

/* int2_int4 */
create function dolphin_catalog.dolphin_int24pl (
int2,
int4
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int24pl';
create operator dolphin_catalog.+(leftarg = int2, rightarg = int4, procedure = dolphin_catalog.dolphin_int24pl);

create function dolphin_catalog.dolphin_int24mi (
int2,
int4
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int24mi';
create operator dolphin_catalog.-(leftarg = int2, rightarg = int4, procedure = dolphin_catalog.dolphin_int24mi);

create function dolphin_catalog.dolphin_int24mul (
int2,
int4
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int24mul';
create operator dolphin_catalog.*(leftarg = int2, rightarg = int4, procedure = dolphin_catalog.dolphin_int24mul);

create function dolphin_catalog.dolphin_int24div (
int2,
int4
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int24div';
create operator dolphin_catalog./(leftarg = int2, rightarg = int4, procedure = dolphin_catalog.dolphin_int24div);

/* int2_int8 */
create function dolphin_catalog.dolphin_int28pl (
int2,
int8
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int28pl';
create operator dolphin_catalog.+(leftarg = int2, rightarg = int8, procedure = dolphin_catalog.dolphin_int28pl);

create function dolphin_catalog.dolphin_int28mi (
int2,
int8
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int28mi';
create operator dolphin_catalog.-(leftarg = int2, rightarg = int8, procedure = dolphin_catalog.dolphin_int28mi);

create function dolphin_catalog.dolphin_int28mul (
int2,
int8
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int28mul';
create operator dolphin_catalog.*(leftarg = int2, rightarg = int8, procedure = dolphin_catalog.dolphin_int28mul);

create function dolphin_catalog.dolphin_int28div (
int2,
int8
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int28div';
create operator dolphin_catalog./(leftarg = int2, rightarg = int8, procedure = dolphin_catalog.dolphin_int28div);

/* int2_uint2 */
create function dolphin_catalog.dolphin_int2_pl_uint2 (
int2,
uint2
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2_pl_uint2';
create operator dolphin_catalog.+(leftarg = int2, rightarg = uint2, procedure = dolphin_catalog.dolphin_int2_pl_uint2);

create function dolphin_catalog.dolphin_int2_mi_uint2 (
int2,
uint2
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2_mi_uint2';
create operator dolphin_catalog.-(leftarg = int2, rightarg = uint2, procedure = dolphin_catalog.dolphin_int2_mi_uint2);

create function dolphin_catalog.dolphin_int2_mul_uint2 (
int2,
uint2
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2_mul_uint2';
create operator dolphin_catalog.*(leftarg = int2, rightarg = uint2, procedure = dolphin_catalog.dolphin_int2_mul_uint2);

create function dolphin_catalog.dolphin_int2_div_uint2 (
int2,
uint2
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2_div_uint2';
create operator dolphin_catalog./(leftarg = int2, rightarg = uint2, procedure = dolphin_catalog.dolphin_int2_div_uint2);

/* int4_int2 */
create function dolphin_catalog.dolphin_int42pl (
int4,
int2
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int42pl';
create operator dolphin_catalog.+(leftarg = int4, rightarg = int2, procedure = dolphin_catalog.dolphin_int42pl);

create function dolphin_catalog.dolphin_int42mi (
int4,
int2
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int42mi';
create operator dolphin_catalog.-(leftarg = int4, rightarg = int2, procedure = dolphin_catalog.dolphin_int42mi);

create function dolphin_catalog.dolphin_int42mul (
int4,
int2
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int42mul';
create operator dolphin_catalog.*(leftarg = int4, rightarg = int2, procedure = dolphin_catalog.dolphin_int42mul);

create function dolphin_catalog.dolphin_int42div (
int4,
int2
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int42div';
create operator dolphin_catalog./(leftarg = int4, rightarg = int2, procedure = dolphin_catalog.dolphin_int42div);

/* int4_int8 */
create function dolphin_catalog.dolphin_int48pl (
int4,
int8
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int48pl';
create operator dolphin_catalog.+(leftarg = int4, rightarg = int8, procedure = dolphin_catalog.dolphin_int48pl);

create function dolphin_catalog.dolphin_int48mi (
int4,
int8
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int48mi';
create operator dolphin_catalog.-(leftarg = int4, rightarg = int8, procedure = dolphin_catalog.dolphin_int48mi);

create function dolphin_catalog.dolphin_int48mul (
int4,
int8
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int48mul';
create operator dolphin_catalog.*(leftarg = int4, rightarg = int8, procedure = dolphin_catalog.dolphin_int48mul);

create function dolphin_catalog.dolphin_int48div (
int4,
int8
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int48div';
create operator dolphin_catalog./(leftarg = int4, rightarg = int8, procedure = dolphin_catalog.dolphin_int48div);

/* int4_uint4 */
create function dolphin_catalog.dolphin_int4_pl_uint4 (
int4,
uint4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4_pl_uint4';
create operator dolphin_catalog.+(leftarg = int4, rightarg = uint4, procedure = dolphin_catalog.dolphin_int4_pl_uint4);

create function dolphin_catalog.dolphin_int4_mi_uint4 (
int4,
uint4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4_mi_uint4';
create operator dolphin_catalog.-(leftarg = int4, rightarg = uint4, procedure = dolphin_catalog.dolphin_int4_mi_uint4);

create function dolphin_catalog.dolphin_int4_mul_uint4 (
int4,
uint4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4_mul_uint4';
create operator dolphin_catalog.*(leftarg = int4, rightarg = uint4, procedure = dolphin_catalog.dolphin_int4_mul_uint4);

create function dolphin_catalog.dolphin_int4_div_uint4 (
int4,
uint4
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4_div_uint4';
create operator dolphin_catalog./(leftarg = int4, rightarg = uint4, procedure = dolphin_catalog.dolphin_int4_div_uint4);

/* int8_int2 */
create function dolphin_catalog.dolphin_int82pl (
int8,
int2
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int82pl';
create operator dolphin_catalog.+(leftarg = int8, rightarg = int2, procedure = dolphin_catalog.dolphin_int82pl);

create function dolphin_catalog.dolphin_int82mi (
int8,
int2
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int82mi';
create operator dolphin_catalog.-(leftarg = int8, rightarg = int2, procedure = dolphin_catalog.dolphin_int82mi);

create function dolphin_catalog.dolphin_int82mul (
int8,
int2
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int82mul';
create operator dolphin_catalog.*(leftarg = int8, rightarg = int2, procedure = dolphin_catalog.dolphin_int82mul);

create function dolphin_catalog.dolphin_int82div (
int8,
int2
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int82div';
create operator dolphin_catalog./(leftarg = int8, rightarg = int2, procedure = dolphin_catalog.dolphin_int82div);

/* int8_int4 */
create function dolphin_catalog.dolphin_int84pl (
int8,
int4
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int84pl';
create operator dolphin_catalog.+(leftarg = int8, rightarg = int4, procedure = dolphin_catalog.dolphin_int84pl);

create function dolphin_catalog.dolphin_int84mi (
int8,
int4
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int84mi';
create operator dolphin_catalog.-(leftarg = int8, rightarg = int4, procedure = dolphin_catalog.dolphin_int84mi);

create function dolphin_catalog.dolphin_int84mul (
int8,
int4
) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int84mul';
create operator dolphin_catalog.*(leftarg = int8, rightarg = int4, procedure = dolphin_catalog.dolphin_int84mul);

create function dolphin_catalog.dolphin_int84div (
int8,
int4
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int84div';
create operator dolphin_catalog./(leftarg = int8, rightarg = int4, procedure = dolphin_catalog.dolphin_int84div);

/* uint2_int2 */
create function dolphin_catalog.dolphin_uint2_pl_int2 (
uint2,
int2
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2_pl_int2';
create operator dolphin_catalog.+(leftarg = uint2, rightarg = int2, procedure = dolphin_catalog.dolphin_uint2_pl_int2);

create function dolphin_catalog.dolphin_uint2_mi_int2 (
uint2,
int2
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2_mi_int2';
create operator dolphin_catalog.-(leftarg = uint2, rightarg = int2, procedure = dolphin_catalog.dolphin_uint2_mi_int2);

create function dolphin_catalog.dolphin_uint2_mul_int2 (
uint2,
int2
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2_mul_int2';
create operator dolphin_catalog.*(leftarg = uint2, rightarg = int2, procedure = dolphin_catalog.dolphin_uint2_mul_int2);

create function dolphin_catalog.dolphin_uint2_div_int2 (
uint2,
int2
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2_div_int2';
create operator dolphin_catalog./(leftarg = uint2, rightarg = int2, procedure = dolphin_catalog.dolphin_uint2_div_int2);

/* uint2 */
create function dolphin_catalog.dolphin_uint2pl (
uint2,
uint2
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2pl';
create operator dolphin_catalog.+(leftarg = uint2, rightarg = uint2, procedure = dolphin_catalog.dolphin_uint2pl);

create function dolphin_catalog.dolphin_uint2mi (
uint2,
uint2
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2mi';
create operator dolphin_catalog.-(leftarg = uint2, rightarg = uint2, procedure = dolphin_catalog.dolphin_uint2mi);

create function dolphin_catalog.dolphin_uint2mul (
uint2,
uint2
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2mul';
create operator dolphin_catalog.*(leftarg = uint2, rightarg = uint2, procedure = dolphin_catalog.dolphin_uint2mul);

create function dolphin_catalog.dolphin_uint2div (
uint2,
uint2
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2div';
create operator dolphin_catalog./(leftarg = uint2, rightarg = uint2, procedure = dolphin_catalog.dolphin_uint2div);

/* uint4 */
create function dolphin_catalog.dolphin_uint4pl (
uint4,
uint4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4pl';
create operator dolphin_catalog.+(leftarg = uint4, rightarg = uint4, procedure = dolphin_catalog.dolphin_uint4pl);

create function dolphin_catalog.dolphin_uint4mi (
uint4,
uint4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4mi';
create operator dolphin_catalog.-(leftarg = uint4, rightarg = uint4, procedure = dolphin_catalog.dolphin_uint4mi);

create function dolphin_catalog.dolphin_uint4mul (
uint4,
uint4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4mul';
create operator dolphin_catalog.*(leftarg = uint4, rightarg = uint4, procedure = dolphin_catalog.dolphin_uint4mul);

create function dolphin_catalog.dolphin_uint4div (
uint4,
uint4
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4div';
create operator dolphin_catalog./(leftarg = uint4, rightarg = uint4, procedure = dolphin_catalog.dolphin_uint4div);

/* uint4_int4 */
create function dolphin_catalog.dolphin_uint4_pl_int4 (
uint4,
int4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4_pl_int4';
create operator dolphin_catalog.+(leftarg = uint4, rightarg = int4, procedure = dolphin_catalog.dolphin_uint4_pl_int4);

create function dolphin_catalog.dolphin_uint4_mi_int4 (
uint4,
int4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4_mi_int4';
create operator dolphin_catalog.-(leftarg = uint4, rightarg = int4, procedure = dolphin_catalog.dolphin_uint4_mi_int4);

create function dolphin_catalog.dolphin_uint4_mul_int4 (
uint4,
int4
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4_mul_int4';
create operator dolphin_catalog.*(leftarg = uint4, rightarg = int4, procedure = dolphin_catalog.dolphin_uint4_mul_int4);

create function dolphin_catalog.dolphin_uint4_div_int4 (
uint4,
int4
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4_div_int4';
create operator dolphin_catalog./(leftarg = uint4, rightarg = int4, procedure = dolphin_catalog.dolphin_uint4_div_int4);

/* float4 */
create function dolphin_catalog.dolphin_float4pl (
float4,
float4
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_float4pl';
create operator dolphin_catalog.+(leftarg = float4, rightarg = float4, procedure = dolphin_catalog.dolphin_float4pl);

create function dolphin_catalog.dolphin_float4mi (
float4,
float4
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_float4mi';
create operator dolphin_catalog.-(leftarg = float4, rightarg = float4, procedure = dolphin_catalog.dolphin_float4mi);

create function dolphin_catalog.dolphin_float4mul (
float4,
float4
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_float4mul';
create operator dolphin_catalog.*(leftarg = float4, rightarg = float4, procedure = dolphin_catalog.dolphin_float4mul);

create function dolphin_catalog.dolphin_float4div (
float4,
float4
) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_float4div';
create operator dolphin_catalog./(leftarg = float4, rightarg = float4, procedure = dolphin_catalog.dolphin_float4div);

/* float4_float8 */
create function dolphin_catalog.dolphin_float48pl (
float4,
float8
) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float48pl';
create operator dolphin_catalog.+(leftarg = float4, rightarg = float8, procedure = dolphin_catalog.dolphin_float48pl);

create function dolphin_catalog.dolphin_float48mi (
float4,
float8
) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float48mi';
create operator dolphin_catalog.-(leftarg = float4, rightarg = float8, procedure = dolphin_catalog.dolphin_float48mi);

create function dolphin_catalog.dolphin_float48mul (
float4,
float8
) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float48mul';
create operator dolphin_catalog.*(leftarg = float4, rightarg = float8, procedure = dolphin_catalog.dolphin_float48mul);

create function dolphin_catalog.dolphin_float48div (
float4,
float8
) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float48div';
create operator dolphin_catalog./(leftarg = float4, rightarg = float8, procedure = dolphin_catalog.dolphin_float48div);

/* float8_float4 */
create function dolphin_catalog.dolphin_float84pl (
float8,
float4
) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float84pl';
create operator dolphin_catalog.+(leftarg = float8, rightarg = float4, procedure = dolphin_catalog.dolphin_float84pl);

create function dolphin_catalog.dolphin_float84mi (
float8,
float4
) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float84mi';
create operator dolphin_catalog.-(leftarg = float8, rightarg = float4, procedure = dolphin_catalog.dolphin_float84mi);

create function dolphin_catalog.dolphin_float84mul (
float8,
float4
) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float84mul';
create operator dolphin_catalog.*(leftarg = float8, rightarg = float4, procedure = dolphin_catalog.dolphin_float84mul);

create function dolphin_catalog.dolphin_float84div (
float8,
float4
) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float84div';
create operator dolphin_catalog./(leftarg = float8, rightarg = float4, procedure = dolphin_catalog.dolphin_float84div);

/* uint8_int8 */
CREATE FUNCTION dolphin_catalog.dolphin_uint8_pl_int8 (
uint8,
int8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_pl_int8';
CREATE OPERATOR dolphin_catalog.+(leftarg = uint8, rightarg = int8, procedure = dolphin_catalog.dolphin_uint8_pl_int8);

CREATE FUNCTION dolphin_catalog.dolphin_uint8_mi_int8 (
uint8,
int8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_mi_int8';
CREATE OPERATOR dolphin_catalog.-(leftarg = uint8, rightarg = int8, procedure = dolphin_catalog.dolphin_uint8_mi_int8);

CREATE FUNCTION dolphin_catalog.dolphin_uint8_mul_int8 (
uint8,
int8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_mul_int8';
CREATE OPERATOR dolphin_catalog.*(leftarg = uint8, rightarg = int8, procedure = dolphin_catalog.dolphin_uint8_mul_int8);

CREATE FUNCTION dolphin_catalog.dolphin_uint8_div_int8 (
uint8,
int8
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint8_div_int8';
CREATE OPERATOR dolphin_catalog./(leftarg = uint8, rightarg = int8, procedure = dolphin_catalog.dolphin_uint8_div_int8);

/* int8_uint8 */
CREATE FUNCTION dolphin_catalog.dolphin_int8_pl_uint8 (
int8,
uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_pl_uint8';
CREATE OPERATOR dolphin_catalog.+(leftarg = int8, rightarg = uint8, procedure = dolphin_catalog.dolphin_int8_pl_uint8);

CREATE FUNCTION dolphin_catalog.dolphin_int8_mi_uint8 (
int8,
uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_mi_uint8';
CREATE OPERATOR dolphin_catalog.-(leftarg = int8, rightarg = uint8, procedure = dolphin_catalog.dolphin_int8_mi_uint8);

CREATE FUNCTION dolphin_catalog.dolphin_int8_mul_uint8 (
int8,
uint8
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_mul_uint8';
CREATE OPERATOR dolphin_catalog.*(leftarg = int8, rightarg = uint8, procedure = dolphin_catalog.dolphin_int8_mul_uint8);

create function dolphin_catalog.dolphin_int8_div_uint8 (
int8,
uint8
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int8_div_uint8';
create operator dolphin_catalog./(leftarg = int8, rightarg = uint8, procedure = dolphin_catalog.dolphin_int8_div_uint8);

/* float8 */
create operator dolphin_catalog.+(leftarg = float8, rightarg = float8, procedure = float8pl);
create operator dolphin_catalog.-(leftarg = float8, rightarg = float8, procedure = float8mi);
create operator dolphin_catalog.*(leftarg = float8, rightarg = float8, procedure = float8mul);
create operator dolphin_catalog./(leftarg = float8, rightarg = float8, procedure = float8div);

/* uint8 */
create operator dolphin_catalog.+(leftarg = uint8, rightarg = uint8, procedure = uint8pl);
create operator dolphin_catalog.-(leftarg = uint8, rightarg = uint8, procedure = uint8mi);
create operator dolphin_catalog.*(leftarg = uint8, rightarg = uint8, procedure = uint8mul);
create function dolphin_catalog.dolphin_uint8div (
uint8,
uint8
) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_uint8div';
create operator dolphin_catalog./(leftarg = uint8, rightarg = uint8, procedure = dolphin_catalog.dolphin_uint8div);

/* numeric */
create operator dolphin_catalog.+(leftarg = numeric, rightarg = numeric, procedure = numeric_add);
create operator dolphin_catalog.-(leftarg = numeric, rightarg = numeric, procedure = numeric_sub);
create operator dolphin_catalog.*(leftarg = numeric, rightarg = numeric, procedure = numeric_mul);
create operator dolphin_catalog./(leftarg = numeric, rightarg = numeric, procedure = numeric_div);

CREATE FUNCTION pg_catalog.op_datexor(date, date) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.datexor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = date, rightarg = date, procedure = pg_catalog.op_datexor);
CREATE FUNCTION pg_catalog.op_timexor(time, time) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timexor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = time, rightarg = time, procedure = pg_catalog.op_timexor);
CREATE FUNCTION pg_catalog.op_date_time_xor(date, time) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_time_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = date, rightarg = time, procedure = pg_catalog.op_date_time_xor);
CREATE FUNCTION pg_catalog.op_time_date_xor(time, date) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.time_date_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = time, rightarg = date, procedure = pg_catalog.op_time_date_xor);
CREATE FUNCTION pg_catalog.op_time_text_xor(time, text) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.time_text_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = time, rightarg = text, procedure = pg_catalog.op_time_text_xor);
CREATE FUNCTION pg_catalog.op_text_time_xor(text, time) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.text_time_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = text, rightarg = time, procedure = pg_catalog.op_text_time_xor);
CREATE FUNCTION pg_catalog.op_date_text_xor(date, text) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_text_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = date, rightarg = text, procedure = pg_catalog.op_date_text_xor);
CREATE FUNCTION pg_catalog.op_text_date_xor(text, date) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.text_date_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = text, rightarg = date, procedure = pg_catalog.op_text_date_xor);
CREATE FUNCTION pg_catalog.op_date_int8_xor(date, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_int8_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = date, rightarg = int8, procedure = pg_catalog.op_date_int8_xor);
CREATE FUNCTION pg_catalog.op_int8_date_xor(int8, date) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_date_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = int8, rightarg = date, procedure = pg_catalog.op_int8_date_xor);
CREATE FUNCTION pg_catalog.op_time_int8_xor(time, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.time_int8_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = time, rightarg = int8, procedure = pg_catalog.op_time_int8_xor);
CREATE FUNCTION pg_catalog.op_int8_time_xor(int8, time) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_time_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = int8, rightarg = time, procedure = pg_catalog.op_int8_time_xor);
CREATE FUNCTION pg_catalog.op_date_float8_xor(date, float8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_float8_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = date, rightarg = float8, procedure = pg_catalog.op_date_float8_xor);
CREATE FUNCTION pg_catalog.op_float8_date_xor(float8, date) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.float8_date_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = float8, rightarg = date, procedure = pg_catalog.op_float8_date_xor);
CREATE FUNCTION pg_catalog.op_timestampxor(timestamp, timestamp) 
RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestampxor($1, $2)::uint8';
CREATE OPERATOR pg_catalog.^(leftarg = timestamp, rightarg = timestamp, procedure = pg_catalog.op_timestampxor);
CREATE FUNCTION pg_catalog.op_timestamp_int8_xor(timestamp, int8) 
RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamp_int8_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = timestamp, rightarg = int8, procedure = pg_catalog.op_timestamp_int8_xor);
CREATE FUNCTION pg_catalog.op_int8_timestamp_xor(int8, timestamp) 
RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_timestamp_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = int8, rightarg = timestamp, procedure = pg_catalog.op_int8_timestamp_xor);
CREATE FUNCTION pg_catalog.op_timestamp_float8_xor(timestamp, float8) 
RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamp_float8_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = timestamp, rightarg = float8, procedure = pg_catalog.op_timestamp_float8_xor);
CREATE FUNCTION pg_catalog.op_float8_timestamp_xor(float8, timestamp) 
RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.float8_timestamp_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = float8, rightarg = timestamp, procedure = pg_catalog.op_float8_timestamp_xor);
CREATE FUNCTION pg_catalog.op_timestamp_text_xor(timestamp, text) 
RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamp_text_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = timestamp, rightarg = text, procedure = pg_catalog.op_timestamp_text_xor);
CREATE FUNCTION pg_catalog.op_text_timestamp_xor(text, timestamp) 
RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.text_timestamp_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = text, rightarg = timestamp, procedure = pg_catalog.op_text_timestamp_xor);
CREATE FUNCTION pg_catalog.op_timestamptzxor(timestampTz, timestampTz) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamptzxor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = timestampTz, rightarg = timestampTz, procedure = pg_catalog.op_timestamptzxor);
CREATE FUNCTION pg_catalog.op_timestamptz_int8_xor(timestampTz, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamptz_int8_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = timestampTz, rightarg = int8, procedure = pg_catalog.op_timestamptz_int8_xor);
CREATE FUNCTION pg_catalog.op_int8_timestamptz_xor(int8, timestampTz) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_timestamptz_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = int8, rightarg = timestampTz, procedure = pg_catalog.op_int8_timestamptz_xor);
CREATE FUNCTION pg_catalog.op_timestamptz_float8_xor(timestampTz, float8) 
RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamptz_float8_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = timestampTz, rightarg = float8, procedure = pg_catalog.op_timestamptz_float8_xor);
CREATE FUNCTION pg_catalog.op_float8_timestamptz_xor(float8, timestampTz) 
RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.float8_timestamptz_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = float8, rightarg = timestampTz, procedure = pg_catalog.op_float8_timestamptz_xor);
CREATE FUNCTION pg_catalog.op_timestamptz_text_xor(timestampTz, text) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamptz_text_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = timestampTz, rightarg = text, procedure = pg_catalog.op_timestamptz_text_xor);
CREATE FUNCTION pg_catalog.op_text_timestamptz_xor(text, timestampTz) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.text_timestamptz_xor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = text, rightarg = timestampTz, procedure = pg_catalog.op_text_timestamptz_xor);
CREATE FUNCTION pg_catalog.op_textxor(text, text) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.textxor($1, $2)::uint8';
create operator pg_catalog.^(leftarg = text, rightarg = text, procedure = pg_catalog.op_textxor);
CREATE FUNCTION pg_catalog.op_boolxor(boolean, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int1xor($1::int1, $2::int1)::uint8';
CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = boolean, procedure = pg_catalog.op_boolxor);
CREATE FUNCTION pg_catalog.booltofloat8(bool) RETURNS float8 LANGUAGE C STRICT AS  '$libdir/dolphin',  'bool_float8';
CREATE CAST (bool AS float8) WITH FUNCTION pg_catalog.booltofloat8(bool) AS ASSIGNMENT;
CREATE FUNCTION pg_catalog.op_bool_float8_xor(boolean, float8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.dpow($1::float8, $2)::uint8';
create operator pg_catalog.^(leftarg = boolean, rightarg = float8, procedure = pg_catalog.op_bool_float8_xor);
CREATE FUNCTION pg_catalog.op_float8_bool_xor(float8, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.dpow($1, $2::float8)::uint8';
create operator pg_catalog.^(leftarg = float8, rightarg = boolean, procedure = pg_catalog.op_float8_bool_xor);
DROP FUNCTION IF EXISTS pg_catalog.uuid_short() CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uuid_short()
RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uuid_short';
DO $for_og_310$
DECLARE
  ans boolean;
  v_isinplaceupgrade boolean;
BEGIN
    -- add special script for version before 3.1.0, cause 3.1.0 is dolphin 1.0 and 5.0.0 is dolphin 1.0 too, but they are different.
    select case when count(*)=1 then true else false end as ans from (select setting from pg_settings where name = 'upgrade_mode' and setting != '0') into ans;
    show isinplaceupgrade into v_isinplaceupgrade;
    if working_version_num() <= 92780 and ans and v_isinplaceupgrade then
        DROP CAST IF EXISTS (float8 as boolean);
        DROP CAST IF EXISTS (float as boolean);
        DROP FUNCTION IF EXISTS pg_catalog.float8_bool(float8);
        DROP FUNCTION IF EXISTS pg_catalog.float8_bool(float);

        CREATE OR REPLACE FUNCTION pg_catalog.float8_bool(float8) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'float8_bool';
        CREATE CAST (float8 as boolean) WITH FUNCTION float8_bool(float8) AS IMPLICIT;

        DROP CAST IF EXISTS (float4 as boolean);
        DROP FUNCTION IF EXISTS pg_catalog.float4_bool(float4);
        CREATE OR REPLACE FUNCTION pg_catalog.float4_bool(float4) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'float4_bool';
        CREATE CAST (float4 as boolean) WITH FUNCTION float4_bool(float4) AS IMPLICIT;
        
        DROP CAST IF EXISTS (date as boolean);
        DROP FUNCTION IF EXISTS pg_catalog.date_bool(float8);
        CREATE OR REPLACE FUNCTION pg_catalog.date_bool(date) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'date_bool';
        CREATE CAST (date as boolean) WITH FUNCTION date_bool(date) AS IMPLICIT;
        
        DROP CAST IF EXISTS (time as boolean);
        DROP FUNCTION IF EXISTS pg_catalog.time_bool(time);
        CREATE OR REPLACE FUNCTION pg_catalog.time_bool(time) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'time_bool';
        CREATE CAST (time as boolean) WITH FUNCTION time_bool(time) AS IMPLICIT;
        
        DROP CAST IF EXISTS (bit as boolean);
        DROP FUNCTION IF EXISTS pg_catalog.bit_bool(bit);
        CREATE OR REPLACE FUNCTION pg_catalog.bit_bool(bit) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'bit_bool';
        CREATE CAST (bit as boolean) WITH FUNCTION bit_bool(bit) AS IMPLICIT;

        DROP CAST IF EXISTS (text as boolean);
        DROP FUNCTION IF EXISTS pg_catalog.text_bool(text);
        CREATE OR REPLACE FUNCTION pg_catalog.text_bool(text) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'text_bool';
        CREATE CAST (text as boolean) WITH FUNCTION text_bool(text) AS IMPLICIT;

        DROP CAST IF EXISTS (varchar as boolean);
        DROP FUNCTION IF EXISTS pg_catalog.varchar_bool(varchar);
        CREATE OR REPLACE FUNCTION pg_catalog.varchar_bool(varchar) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'varchar_bool';
        CREATE CAST (varchar as boolean) WITH FUNCTION varchar_bool(varchar) AS IMPLICIT;

        DROP CAST IF EXISTS (char as boolean);
        DROP FUNCTION IF EXISTS pg_catalog.char_bool(char);
        CREATE OR REPLACE FUNCTION pg_catalog.char_bool(char) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'char_bool';
        CREATE CAST (char as boolean) WITH FUNCTION char_bool(char) AS IMPLICIT;

        CREATE OR REPLACE FUNCTION pg_catalog.boolboollike(
        bool,
        bool
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'boolboollike';

        CREATE OPERATOR pg_catalog.~~(leftarg = bool, rightarg = bool, procedure = pg_catalog.boolboollike);
        CREATE OPERATOR pg_catalog.~~*(leftarg = bool, rightarg = bool, procedure = pg_catalog.boolboollike);

        CREATE OR REPLACE FUNCTION pg_catalog.booltextlike(
        bool,
        text
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'booltextlike';

        CREATE OPERATOR pg_catalog.~~(leftarg = bool, rightarg = text, procedure = pg_catalog.booltextlike);
        CREATE OPERATOR pg_catalog.~~*(leftarg = bool, rightarg = text, procedure = pg_catalog.booltextlike);

        CREATE OR REPLACE FUNCTION pg_catalog.textboollike(
        text,
        bool
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textboollike';

        CREATE OPERATOR pg_catalog.~~(leftarg = text, rightarg = bool, procedure = pg_catalog.textboollike);
        CREATE OPERATOR pg_catalog.~~*(leftarg = text, rightarg = bool, procedure = pg_catalog.textboollike);

        CREATE OR REPLACE FUNCTION pg_catalog.boolboolnlike(
        bool,
        bool
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'boolboolnlike';

        CREATE OPERATOR pg_catalog.!~~(leftarg = bool, rightarg = bool, procedure = pg_catalog.boolboolnlike);
        CREATE OPERATOR pg_catalog.!~~*(leftarg = bool, rightarg = bool, procedure = pg_catalog.boolboolnlike);

        CREATE OR REPLACE FUNCTION pg_catalog.booltextnlike(
        bool,
        text
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'booltextnlike';

        CREATE OPERATOR pg_catalog.!~~(leftarg = bool, rightarg = text, procedure = pg_catalog.booltextnlike);
        CREATE OPERATOR pg_catalog.!~~*(leftarg = bool, rightarg = text, procedure = pg_catalog.booltextnlike);

        CREATE OR REPLACE FUNCTION pg_catalog.textboolnlike(
        text,
        bool
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textboolnlike';

        CREATE OPERATOR pg_catalog.!~~(leftarg = text, rightarg = bool, procedure = pg_catalog.textboolnlike);
        CREATE OPERATOR pg_catalog.!~~*(leftarg = text, rightarg = bool, procedure = pg_catalog.textboolnlike);

        CREATE OR REPLACE FUNCTION pg_catalog.bitlike(
        VarBit,
        VarBit
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitlike';

        CREATE OR REPLACE FUNCTION pg_catalog.bitnlike(
        VarBit,
        VarBit
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitnlike';

        CREATE OPERATOR pg_catalog.!~~(leftarg=VarBit, rightarg=VarBit, procedure=pg_catalog.bitnlike);
        CREATE OPERATOR pg_catalog.!~~*(leftarg=VarBit, rightarg=VarBit, procedure=pg_catalog.bitnlike);

        CREATE OPERATOR pg_catalog.~~(leftarg=VarBit, rightarg=VarBit, procedure=pg_catalog.bitlike);
        CREATE OPERATOR pg_catalog.~~*(leftarg=VarBit, rightarg=VarBit, procedure=pg_catalog.bitlike);


        CREATE OR REPLACE FUNCTION pg_catalog.bitothernlike(
        VarBit,
        bool
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

        CREATE OPERATOR pg_catalog.!~~(leftarg=VarBit, rightarg=bool, procedure=pg_catalog.bitothernlike);
        CREATE OPERATOR pg_catalog.!~~*(leftarg=VarBit, rightarg=bool, procedure=pg_catalog.bitothernlike);

        CREATE OR REPLACE FUNCTION pg_catalog.bitothern2like(
        bool,
        VarBit
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

        CREATE OPERATOR pg_catalog.!~~(leftarg=bool, rightarg=VarBit, procedure=pg_catalog.bitothern2like);
        CREATE OPERATOR pg_catalog.!~~*(leftarg=bool, rightarg=VarBit, procedure=pg_catalog.bitothern2like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitothern3like(
        VarBit,
        text
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

        CREATE OPERATOR pg_catalog.!~~(leftarg=VarBit, rightarg=text, procedure=pg_catalog.bitothern3like);
        CREATE OPERATOR pg_catalog.!~~*(leftarg=VarBit, rightarg=text, procedure=pg_catalog.bitothern3like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitothern4like(
        text,
        VarBit
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

        CREATE OPERATOR pg_catalog.!~~(leftarg=text, rightarg=VarBit, procedure=pg_catalog.bitothern4like);
        CREATE OPERATOR pg_catalog.!~~*(leftarg=text, rightarg=VarBit, procedure=pg_catalog.bitothern4like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitothern5like(
        VarBit,
        bytea
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

        CREATE OPERATOR pg_catalog.!~~(leftarg=VarBit, rightarg=bytea, procedure=pg_catalog.bitothern5like);
        CREATE OPERATOR pg_catalog.!~~*(leftarg=VarBit, rightarg=bytea, procedure=pg_catalog.bitothern5like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitothern6like(
        bytea,
        VarBit
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

        CREATE OPERATOR pg_catalog.!~~(leftarg=bytea, rightarg=VarBit, procedure=pg_catalog.bitothern6like);
        CREATE OPERATOR pg_catalog.!~~*(leftarg=bytea, rightarg=VarBit, procedure=pg_catalog.bitothern6like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitothern7like(
        VarBit,
        blob
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

        CREATE OPERATOR pg_catalog.!~~(leftarg=VarBit, rightarg=blob, procedure=pg_catalog.bitothern7like);
        CREATE OPERATOR pg_catalog.!~~*(leftarg=VarBit, rightarg=blob, procedure=pg_catalog.bitothern7like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitothern8like(
        blob,
        VarBit
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitothernlike';

        CREATE OPERATOR pg_catalog.!~~(leftarg=blob, rightarg=VarBit, procedure=pg_catalog.bitothern8like);
        CREATE OPERATOR pg_catalog.!~~*(leftarg=blob, rightarg=VarBit, procedure=pg_catalog.bitothern8like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitotherlike(
        VarBit,
        bool
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

        CREATE OPERATOR pg_catalog.~~(leftarg=VarBit, rightarg=bool, procedure=pg_catalog.bitotherlike);
        CREATE OPERATOR pg_catalog.~~*(leftarg=VarBit, rightarg=bool, procedure=pg_catalog.bitotherlike);

        CREATE OR REPLACE FUNCTION pg_catalog.bitother2like(
        bool,
        VarBit
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

        CREATE OPERATOR pg_catalog.~~(leftarg=bool, rightarg=VarBit, procedure=pg_catalog.bitother2like);
        CREATE OPERATOR pg_catalog.~~*(leftarg=bool, rightarg=VarBit, procedure=pg_catalog.bitother2like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitother3like(
        VarBit,
        text
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

        CREATE OPERATOR pg_catalog.~~(leftarg=VarBit, rightarg=text, procedure=pg_catalog.bitother3like);
        CREATE OPERATOR pg_catalog.~~*(leftarg=VarBit, rightarg=text, procedure=pg_catalog.bitother3like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitother4like(
        text,
        VarBit
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

        CREATE OPERATOR pg_catalog.~~(leftarg=text, rightarg=VarBit, procedure=pg_catalog.bitother4like);
        CREATE OPERATOR pg_catalog.~~*(leftarg=text, rightarg=VarBit, procedure=pg_catalog.bitother4like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitother5like(
        VarBit,
        bytea
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

        CREATE OPERATOR pg_catalog.~~(leftarg=VarBit, rightarg=bytea, procedure=pg_catalog.bitother5like);
        CREATE OPERATOR pg_catalog.~~*(leftarg=VarBit, rightarg=bytea, procedure=pg_catalog.bitother5like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitother6like(
        bytea,
        VarBit
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

        CREATE OPERATOR pg_catalog.~~(leftarg=bytea, rightarg=VarBit, procedure=pg_catalog.bitother6like);
        CREATE OPERATOR pg_catalog.~~*(leftarg=bytea, rightarg=VarBit, procedure=pg_catalog.bitother6like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitother7like(
        VarBit,
        blob
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

        CREATE OPERATOR pg_catalog.~~(leftarg=VarBit, rightarg=blob, procedure=pg_catalog.bitother7like);
        CREATE OPERATOR pg_catalog.~~*(leftarg=VarBit, rightarg=blob, procedure=pg_catalog.bitother7like);

        CREATE OR REPLACE FUNCTION pg_catalog.bitother8like(
        blob,
        VarBit
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bitotherlike';

        CREATE OPERATOR pg_catalog.~~(leftarg=blob, rightarg=VarBit, procedure=pg_catalog.bitother8like);
        CREATE OPERATOR pg_catalog.~~*(leftarg=blob, rightarg=VarBit, procedure=pg_catalog.bitother8like);

        CREATE OPERATOR pg_catalog.~~*(leftarg = bytea, rightarg = bytea, procedure = pg_catalog.bytealike);
        CREATE OPERATOR pg_catalog.!~~*(leftarg = bytea, rightarg = bytea, procedure = pg_catalog.byteanlike);

        CREATE OPERATOR pg_catalog.~~*(leftarg=raw, rightarg=raw, procedure=pg_catalog.rawlike);
        CREATE OPERATOR pg_catalog.!~~*(leftarg=raw, rightarg=raw, procedure=pg_catalog.rawnlike);

        DROP FUNCTION IF EXISTS pg_catalog.b_between_and("any","any","any");
        CREATE OR REPLACE FUNCTION pg_catalog.b_between_and("any","any","any") returns boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'between_and';

        DROP FUNCTION IF EXISTS pg_catalog.b_sym_between_and("any","any","any");
        CREATE OR REPLACE FUNCTION pg_catalog.b_sym_between_and("any","any","any") returns boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'sym_between_and';

        DROP FUNCTION IF EXISTS pg_catalog.b_not_between_and("any","any","any");
        CREATE OR REPLACE FUNCTION pg_catalog.b_not_between_and("any","any","any") returns boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'not_between_and';

        DROP FUNCTION IF EXISTS pg_catalog.b_not_sym_between_and("any","any","any");
        CREATE OR REPLACE FUNCTION pg_catalog.b_not_sym_between_and("any","any","any") returns boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'not_sym_between_and';

        CREATE OR REPLACE FUNCTION pg_catalog.dolphin_version() RETURNS text AS '$libdir/dolphin','dolphin_version' LANGUAGE C IMMUTABLE STRICT;
        
        DROP FUNCTION IF EXISTS pg_catalog.xor(a integer, b integer);
        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.bpchar_text(bpchar);
        CREATE OR REPLACE FUNCTION pg_catalog.bpchar_text (
        bpchar
        ) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bpchar_text';
        
        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;
        
        DROP FUNCTION IF EXISTS pg_catalog.bigint_any_value (bigint, bigint);
        CREATE OR REPLACE FUNCTION pg_catalog.bigint_any_value (bigint, bigint) RETURNS bigint LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bigint_any_value';

        drop aggregate if exists pg_catalog.any_value(bigint);
        CREATE AGGREGATE pg_catalog.any_value(bigint) (
                sfunc = bigint_any_value,
                stype = int8
        );

        DROP FUNCTION IF EXISTS pg_catalog.numeric_any_value (numeric, numeric);
        CREATE OR REPLACE FUNCTION pg_catalog.numeric_any_value (numeric, numeric) RETURNS numeric LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_any_value';

        drop aggregate if exists pg_catalog.any_value(numeric);
        CREATE AGGREGATE pg_catalog.any_value(numeric) (
                sfunc = numeric_any_value,
                stype = numeric
        );

        DROP FUNCTION IF EXISTS pg_catalog.double_any_value (double precision, double precision);
        CREATE OR REPLACE FUNCTION pg_catalog.double_any_value (double precision, double precision) RETURNS double precision LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'double_any_value';

        drop aggregate if exists pg_catalog.any_value(double precision);
        CREATE AGGREGATE pg_catalog.any_value(double precision) (
                sfunc = double_any_value,
                stype = double precision
        );

        DROP FUNCTION IF EXISTS pg_catalog.float_any_value (float4, float4);
        CREATE OR REPLACE FUNCTION pg_catalog.float_any_value (float4, float4) RETURNS float4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float_any_value';

        drop aggregate if exists pg_catalog.any_value(float4);
        CREATE AGGREGATE pg_catalog.any_value(float4) (
                sfunc = float_any_value,
                stype = float4
        );

        DROP FUNCTION IF EXISTS pg_catalog.text_any_value (text, text);
        CREATE OR REPLACE FUNCTION pg_catalog.text_any_value (text, text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'text_any_value';

        drop aggregate if exists pg_catalog.any_value(text);
        CREATE AGGREGATE pg_catalog.any_value(text) (
                sfunc = text_any_value,
                stype = text
        );

        DROP FUNCTION IF EXISTS pg_catalog.bytea_any_value (bytea, bytea);
        CREATE OR REPLACE FUNCTION pg_catalog.bytea_any_value (bytea, bytea) RETURNS bytea LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bytea_any_value';

        drop aggregate if exists pg_catalog.any_value(bytea);
        CREATE AGGREGATE pg_catalog.any_value(bytea) (
                sfunc = bytea_any_value,
                stype = bytea
        );

        DROP FUNCTION IF EXISTS pg_catalog.blob_any_value (blob, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_any_value (blob, blob) RETURNS blob LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'blob_any_value';

        drop aggregate if exists pg_catalog.any_value(blob);
        CREATE AGGREGATE pg_catalog.any_value(blob) (
                sfunc = blob_any_value,
                stype = blob
        );

        DROP FUNCTION IF EXISTS pg_catalog.dolphin_attname_eq(name, name);
        CREATE OR REPLACE FUNCTION pg_catalog.dolphin_attname_eq(name, name) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_attname_eq';

        CREATE OR REPLACE FUNCTION pg_catalog.binary_in (
        cstring
        ) RETURNS binary  LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_binaryin';
        
        CREATE OR REPLACE FUNCTION pg_catalog.binary_in (
        text
        ) RETURNS binary   AS
        $$
        BEGIN
            RETURN (SELECT binary_in($1::cstring));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OR REPLACE FUNCTION pg_catalog.binarytextlike(
        binary,
        text
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT bytealike($1::bytea,$2::binary::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.~~(leftarg = binary, rightarg = text, procedure = pg_catalog.binarytextlike);
        CREATE OPERATOR pg_catalog.~~*(leftarg = binary, rightarg = text, procedure = pg_catalog.binarytextlike);

        CREATE OR REPLACE FUNCTION pg_catalog.textbinarylike(
        text,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT bytealike($1::binary::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.~~(leftarg = text, rightarg = binary, procedure = pg_catalog.textbinarylike);
        CREATE OPERATOR pg_catalog.~~*(leftarg = text, rightarg = binary, procedure = pg_catalog.textbinarylike);

        CREATE OR REPLACE FUNCTION pg_catalog.binarytextnlike(
        binary,
        text
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteanlike($1::bytea,$2::binary::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.!~~(leftarg = binary, rightarg = text, procedure = pg_catalog.binarytextnlike);
        CREATE OPERATOR pg_catalog.!~~*(leftarg = binary, rightarg = text, procedure = pg_catalog.binarytextnlike);

        CREATE OR REPLACE FUNCTION pg_catalog.textbinarynlike(
        text,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteanlike($1::binary::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.!~~(leftarg = text, rightarg = binary, procedure = pg_catalog.textbinarynlike);
        CREATE OPERATOR pg_catalog.!~~*(leftarg = text, rightarg = binary, procedure = pg_catalog.textbinarynlike);

        CREATE OR REPLACE FUNCTION pg_catalog.like_escape(
        binary,
        text
        ) RETURNS bytea AS
        $$
        BEGIN
            RETURN (SELECT like_escape($1::bytea,$2::binary::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OR REPLACE FUNCTION pg_catalog.binaryeq(
        binary,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteaeq($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.=(leftarg = binary, rightarg = binary, procedure = pg_catalog.binaryeq,restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES);

        CREATE OR REPLACE FUNCTION pg_catalog.binaryne(
        binary,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteane($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<>(leftarg = binary, rightarg = binary, procedure = pg_catalog.binaryne,restrict = neqsel, join = neqjoinsel);


        CREATE OR REPLACE FUNCTION pg_catalog.binarygt(
        binary,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteagt($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = binary, procedure = pg_catalog.binarygt,restrict = scalargtsel, join = scalargtjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.binarylt(
        binary,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT bytealt($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = binary, procedure = pg_catalog.binarylt,restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.binaryge(
        binary,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteage($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = binary, procedure = pg_catalog.binaryge,restrict = scalargtsel, join = scalargtjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.binaryle(
        binary,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteale($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = binary, procedure = pg_catalog.binaryle,restrict = scalarltsel, join = scalarltjoinsel);
        
        CREATE OR REPLACE FUNCTION pg_catalog.text_varbinary_eq(
        text,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteaeq($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.=(leftarg = text, rightarg = varbinary, procedure = pg_catalog.text_varbinary_eq,restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES);

        CREATE OR REPLACE FUNCTION pg_catalog.text_varbinary_ne(
        text,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteane($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<>(leftarg = text, rightarg = varbinary, procedure = pg_catalog.text_varbinary_ne,restrict = neqsel, join = neqjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.text_varbinary_gt(
        text,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteagt($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.>(leftarg = text, rightarg = varbinary, procedure = pg_catalog.text_varbinary_gt,restrict = scalargtsel, join = scalargtjoinsel);


        CREATE OR REPLACE FUNCTION pg_catalog.text_varbinary_lt(
        text,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT bytealt($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<(leftarg = text, rightarg = varbinary, procedure = pg_catalog.text_varbinary_lt,restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.text_varbinary_ge(
        text,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteage($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.>=(leftarg = text, rightarg = varbinary, procedure = pg_catalog.text_varbinary_ge,restrict = scalargtsel, join = scalargtjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.text_varbinary_le(
        text,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteale($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<=(leftarg = text, rightarg = varbinary, procedure = pg_catalog.text_varbinary_le,restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_text_eq(
        varbinary,
        text
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteaeq($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.=(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinary_text_eq,restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_text_ne(
        varbinary,
        text
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteane($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<>(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinary_text_ne,restrict = neqsel, join = neqjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_text_gt(
        varbinary,
        text
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteagt($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.>(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinary_text_gt,restrict = scalargtsel, join = scalargtjoinsel);


        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_text_lt(
        varbinary,
        text
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT bytealt($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinary_text_lt,restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_text_ge(
        varbinary,
        text
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteage($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.>=(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinary_text_ge,restrict = scalargtsel, join = scalargtjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_text_le(
        varbinary,
        text
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteale($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<=(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinary_text_le,restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary_eq(
        binary,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteaeq($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.=(leftarg = binary, rightarg = varbinary, procedure = pg_catalog.binary_varbinary_eq,restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES);

        CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary_ne(
        binary,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteane($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<>(leftarg = binary, rightarg = varbinary, procedure = pg_catalog.binary_varbinary_ne,restrict = neqsel, join = neqjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary_gt(
        binary,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteagt($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = varbinary, procedure = pg_catalog.binary_varbinary_gt,restrict = scalargtsel, join = scalargtjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary_lt(
        binary,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT bytealt($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = varbinary, procedure = pg_catalog.binary_varbinary_lt,restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary_ge(
        binary,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteage($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = varbinary, procedure = pg_catalog.binary_varbinary_ge,restrict = scalargtsel, join = scalargtjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary_le(
        binary,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteale($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = varbinary, procedure = pg_catalog.binary_varbinary_le,restrict = scalarltsel, join = scalarltjoinsel);



        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_binary_eq(
        varbinary,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteaeq($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.=(leftarg = varbinary, rightarg = binary, procedure = pg_catalog.varbinary_binary_eq,restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_binary_ne(
        varbinary,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteane($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<>(leftarg = varbinary, rightarg = binary, procedure = pg_catalog.varbinary_binary_ne,restrict = neqsel, join = neqjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_binary_gt(
        varbinary,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteagt($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.>(leftarg = varbinary, rightarg = binary, procedure = pg_catalog.varbinary_binary_gt,restrict = scalargtsel, join = scalargtjoinsel);


        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_binary_lt(
        varbinary,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT bytealt($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<(leftarg = varbinary, rightarg = binary, procedure = pg_catalog.varbinary_binary_lt,restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_binary_ge(
        varbinary,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteage($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.>=(leftarg = varbinary, rightarg = binary, procedure = pg_catalog.varbinary_binary_ge,restrict = scalargtsel, join = scalargtjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_binary_le(
        varbinary,
        binary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteale($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<=(leftarg = varbinary, rightarg = binary, procedure = pg_catalog.varbinary_binary_le,restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_varbinary_eq(
        varbinary,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteaeq($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.=(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_varbinary_eq,restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_varbinary_ne(
        varbinary,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteane($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<>(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_varbinary_ne,restrict = neqsel, join = neqjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_varbinary_gt(
        varbinary,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteagt($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.>(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_varbinary_gt,restrict = scalargtsel, join = scalargtjoinsel);


        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_varbinary_lt(
        varbinary,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT bytealt($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_varbinary_lt,restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_varbinary_ge(
        varbinary,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteage($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.>=(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_varbinary_ge,restrict = scalargtsel, join = scalargtjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.varbinary_varbinary_le(
        varbinary,
        varbinary
        ) RETURNS bool AS
        $$
        BEGIN
            RETURN (SELECT byteale($1::bytea,$2::bytea));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OPERATOR pg_catalog.<=(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_varbinary_le,restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.bit2numeric (bit) RETURNS numeric AS
        $$
        BEGIN
            RETURN (SELECT bittouint8($1));
        END;
        $$
        LANGUAGE plpgsql;

        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';
        
        create operator pg_catalog.^(leftarg = int1, rightarg = int1, procedure = pg_catalog.int1xor);

        CREATE OR REPLACE FUNCTION pg_catalog.blobxor(
        blob,
        blob
        )RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
        CREATE OR REPLACE FUNCTION pg_catalog.blobxor(
        blob,
        int
        )RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
        CREATE OR REPLACE FUNCTION pg_catalog.blobxor(
        int,
        blob
        )RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
        CREATE OR REPLACE FUNCTION pg_catalog.blobxor(
        int8,
        blob
        )RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
        CREATE OR REPLACE FUNCTION pg_catalog.blobxor(
        blob,
        int8
        )RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
        CREATE OR REPLACE FUNCTION pg_catalog.blobxor(
        float8,
        blob
        )RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
        CREATE OR REPLACE FUNCTION pg_catalog.blobxor(
        blob,
        float8
        )RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blobxor';
        create operator pg_catalog.^(leftarg = blob, rightarg = blob, procedure = pg_catalog.blobxor);
        create operator pg_catalog.^(leftarg = blob, rightarg = integer, procedure = pg_catalog.blobxor);
        create operator pg_catalog.^(leftarg = integer, rightarg = blob, procedure = pg_catalog.blobxor);
        create operator pg_catalog.^(leftarg = int8, rightarg = blob, procedure = pg_catalog.blobxor);
        create operator pg_catalog.^(leftarg = blob, rightarg = int8, procedure = pg_catalog.blobxor);
        create operator pg_catalog.^(leftarg = float8, rightarg = blob, procedure = pg_catalog.blobxor);
        create operator pg_catalog.^(leftarg = blob, rightarg = float8, procedure = pg_catalog.blobxor);


        DROP FUNCTION IF EXISTS pg_catalog.bit_longblob(uint8,longblob);
        CREATE OR REPLACE FUNCTION pg_catalog.bit_longblob (t1 uint8, t2 longblob) RETURNS uint8  AS
        $$
        DECLARE num NUMBER := to_number(unhex(substring(cast(t2 as text), 3)));
        BEGIN
            IF num > 9223372036854775807 then
                num = 9223372036854775807;
            ELSEIF num < -9223372036854775808 then
                num = 9223372036854775808;
            END IF;
            RETURN (SELECT uint8_xor(t1, num));
        END;
        $$
        LANGUAGE plpgsql;
        drop aggregate if exists pg_catalog.bit_xor(longblob);
        create aggregate pg_catalog.bit_xor(longblob) (SFUNC=bit_longblob, STYPE= uint8);

        DROP FUNCTION IF EXISTS pg_catalog.bit_blob(uint8,blob);
        CREATE OR REPLACE FUNCTION pg_catalog.bit_blob (t1 uint8, t2 blob) RETURNS uint8  AS
        $$
        DECLARE num NUMBER := to_number((cast(t2 as text)));
        BEGIN
            IF num > 9223372036854775807 then
                num = 9223372036854775807;
            ELSEIF num < -9223372036854775808 then
                num = 9223372036854775808;
            END IF;
            RETURN (SELECT uint8_xor(t1, num));
        END;
        $$
        LANGUAGE plpgsql;
        drop aggregate if exists pg_catalog.bit_xor(blob);
        create aggregate pg_catalog.bit_xor(blob) (SFUNC=bit_blob, STYPE= uint8);

        DROP FUNCTION IF EXISTS pg_catalog.varlena2float8(anyelement);
        CREATE OR REPLACE FUNCTION pg_catalog.varlena2float8(anyelement) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'Varlena2Float8';

        CREATE CAST (bytea AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
        CREATE CAST ("binary" AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
        CREATE CAST ("varbinary" AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
        CREATE CAST (blob AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
        CREATE CAST (tinyblob AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
        CREATE CAST (mediumblob AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
        CREATE CAST (longblob AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS IMPLICIT;
        CREATE CAST (json AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement);

        DROP FUNCTION IF EXISTS pg_catalog.blob_eq(blob, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_eq(arg1 blob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
        DROP FUNCTION IF EXISTS pg_catalog.blob_ne(blob, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_ne(arg1 blob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
        DROP FUNCTION IF EXISTS pg_catalog.blob_lt(blob, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_lt(arg1 blob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
        DROP FUNCTION IF EXISTS pg_catalog.blob_le(blob, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_le(arg1 blob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
        DROP FUNCTION IF EXISTS pg_catalog.blob_gt(blob, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_gt(arg1 blob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
        DROP FUNCTION IF EXISTS pg_catalog.blob_ge(blob, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_ge(arg1 blob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';

        DROP FUNCTION IF EXISTS pg_catalog.blob_eq_text(blob, text);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_eq_text(arg1 blob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_eq($1, $2::blob) $$;
        DROP FUNCTION IF EXISTS pg_catalog.blob_ne_text(blob, text);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_ne_text(arg1 blob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_ne($1, $2::blob) $$;
        DROP FUNCTION IF EXISTS pg_catalog.blob_lt_text(blob, text);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_lt_text(arg1 blob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_lt($1, $2::blob) $$;
        DROP FUNCTION IF EXISTS pg_catalog.blob_le_text(blob, text);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_le_text(arg1 blob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_le($1, $2::blob) $$;
        DROP FUNCTION IF EXISTS pg_catalog.blob_gt_text(blob, text);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_gt_text(arg1 blob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_gt($1, $2::blob) $$;
        DROP FUNCTION IF EXISTS pg_catalog.blob_ge_text(blob, text);
        CREATE OR REPLACE FUNCTION pg_catalog.blob_ge_text(arg1 blob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_ge($1, $2::blob) $$;

        DROP FUNCTION IF EXISTS pg_catalog.text_eq_blob(text, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.text_eq_blob(arg1 text, arg2 blob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_eq($1::blob, $2) $$;
        DROP FUNCTION IF EXISTS pg_catalog.text_ne_blob(text, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.text_ne_blob(arg1 text, arg2 blob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_ne($1::blob, $2) $$;
        DROP FUNCTION IF EXISTS pg_catalog.text_lt_blob(text, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.text_lt_blob(arg1 text, arg2 blob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_lt($1::blob, $2) $$;
        DROP FUNCTION IF EXISTS pg_catalog.text_le_blob(text, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.text_le_blob(arg1 text, arg2 blob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_le($1::blob, $2) $$;
        DROP FUNCTION IF EXISTS pg_catalog.test_gt_blob(text, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.test_gt_blob(arg1 text, arg2 blob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_gt($1::blob, $2) $$;
        DROP FUNCTION IF EXISTS pg_catalog.test_ge_blob(text, blob);
        CREATE OR REPLACE FUNCTION pg_catalog.test_ge_blob(arg1 text, arg2 blob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT blob_ge($1::blob, $2) $$;

        CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = blob, procedure = blob_eq, restrict = eqsel, join = eqjoinsel);
        CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = blob, procedure = blob_ne, restrict = neqsel, join = neqjoinsel);
        CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = blob, procedure = blob_lt, restrict = scalarltsel, join = scalarltjoinsel);
        CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = blob, procedure = blob_le, restrict = scalarltsel, join = scalarltjoinsel);
        CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = blob, procedure = blob_gt, restrict = scalarltsel, join = scalarltjoinsel);
        CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = blob, procedure = blob_ge, restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = text, procedure = blob_eq_text, restrict = eqsel, join = eqjoinsel);
        CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = text, procedure = blob_ne_text, restrict = neqsel, join = neqjoinsel);
        CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = text, procedure = blob_lt_text, restrict = scalarltsel, join = scalarltjoinsel);
        CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = text, procedure = blob_le_text, restrict = scalarltsel, join = scalarltjoinsel);
        CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = text, procedure = blob_gt_text, restrict = scalarltsel, join = scalarltjoinsel);
        CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = text, procedure = blob_ge_text, restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OPERATOR pg_catalog.=(leftarg = text, rightarg = blob, procedure = text_eq_blob, restrict = eqsel, join = eqjoinsel);
        CREATE OPERATOR pg_catalog.<>(leftarg = text, rightarg = blob, procedure = text_ne_blob, restrict = neqsel, join = neqjoinsel);
        CREATE OPERATOR pg_catalog.<(leftarg = text, rightarg = blob, procedure = text_lt_blob, restrict = scalarltsel, join = scalarltjoinsel);
        CREATE OPERATOR pg_catalog.<=(leftarg = text, rightarg = blob, procedure = text_le_blob, restrict = scalarltsel, join = scalarltjoinsel);
        CREATE OPERATOR pg_catalog.>(leftarg = text, rightarg = blob, procedure = test_gt_blob, restrict = scalarltsel, join = scalarltjoinsel);
        CREATE OPERATOR pg_catalog.>=(leftarg = text, rightarg = blob, procedure = test_ge_blob, restrict = scalarltsel, join = scalarltjoinsel);

        CREATE OR REPLACE FUNCTION pg_catalog.show_character_set(OUT "charset" NAME,
                                                 OUT "description" TEXT,
                                                 OUT "default collation" TEXT,
                                                 OUT "maxlen" INT4,
                                                 OUT "server" BOOL
        ) RETURNS SETOF RECORD AS '$libdir/dolphin','ShowCharset' 
         LANGUAGE C;

        CREATE OR REPLACE FUNCTION pg_catalog.show_collation(OUT "collation" NAME,
                                                 OUT "charset" NAME,
                                                 OUT "id" OID,
                                                 OUT "default" TEXT,
                                                 OUT "compiled" TEXT,
                                                 OUT "sortlen" INT4
        ) RETURNS SETOF RECORD AS '$libdir/dolphin','ShowCollation' 
         LANGUAGE C;

        CREATE OR REPLACE FUNCTION pg_catalog.dolphin_types()
        RETURNS text[][] LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_types';
        
        DROP FUNCTION IF EXISTS pg_catalog.gs_get_viewdef_oid(integer);

        CREATE OR REPLACE FUNCTION pg_catalog.gs_get_viewdef_oid (
        integer
        ) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'gs_get_viewdef_oid';

        DROP FUNCTION IF EXISTS pg_catalog.system_user();

        CREATE OR REPLACE FUNCTION pg_catalog.system_user ()
        RETURNS text
        AS
        $$
        BEGIN
            RETURN (SELECT session_user);
        END;
        $$
        LANGUAGE plpgsql;
        DROP FUNCTION IF EXISTS pg_catalog.database();
        CREATE OR REPLACE FUNCTION pg_catalog.database(
        ) RETURNS name LANGUAGE C STABLE STRICT AS '$libdir/dolphin','get_b_database';

        CREATE OR REPLACE FUNCTION pg_catalog.boolxor (
        boolean,
        boolean
        ) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'boolxor';
        create operator pg_catalog.^(leftarg = boolean, rightarg = boolean, procedure = pg_catalog.boolxor);

        CREATE OR REPLACE FUNCTION pg_catalog.ord (text) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'ord_text';

        CREATE OR REPLACE FUNCTION pg_catalog.ord (numeric) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'ord_numeric';

        DROP FUNCTION IF EXISTS pg_catalog.substring_index (text, text, numeric);
        CREATE OR REPLACE FUNCTION pg_catalog.substring_index (
        text,
        text,
        numeric
        ) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index';

        DROP FUNCTION IF EXISTS pg_catalog.substring_index (boolean, text, numeric);
        CREATE OR REPLACE FUNCTION pg_catalog.substring_index (
        boolean,
        text,
        numeric
        ) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_bool_1';

        DROP FUNCTION IF EXISTS pg_catalog.substring_index (text, boolean, numeric);
        CREATE OR REPLACE FUNCTION pg_catalog.substring_index (
        text,
        boolean,
        numeric
        ) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_bool_2';

        DROP FUNCTION IF EXISTS pg_catalog.substring_index (boolean, boolean, numeric);
        CREATE OR REPLACE FUNCTION pg_catalog.substring_index (
        boolean,
        boolean,
        numeric
        ) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_2bool';

        CREATE OR REPLACE FUNCTION pg_catalog.bool_float8_xor(
        boolean,
        float8
        ) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bool_float8_xor';
        create operator pg_catalog.^(leftarg = boolean, rightarg = float8, procedure = pg_catalog.bool_float8_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.float8_bool_xor(
        float8,
        boolean
        ) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float8_bool_xor';
        create operator pg_catalog.^(leftarg = float8, rightarg = boolean, procedure = pg_catalog.float8_bool_xor);

        DROP FUNCTION IF EXISTS pg_catalog.b_db_sys_real_timestamp(integer);
        CREATE OR REPLACE FUNCTION pg_catalog.b_db_sys_real_timestamp(integer) returns timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'b_db_sys_real_timestamp';

        DROP FUNCTION IF EXISTS pg_catalog.b_db_statement_start_timestamp(integer);
        CREATE OR REPLACE FUNCTION pg_catalog.b_db_statement_start_timestamp(integer) returns timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'b_db_statement_start_timestamp';

        DROP OPERATOR IF EXISTS public.+(year, interval);
        DROP OPERATOR IF EXISTS pg_catalog.+(year, interval);
        CREATE OPERATOR pg_catalog.+ (
           leftarg = year,
           rightarg = interval,
           procedure = year_pl_interval,
           commutator = operator(pg_catalog.+)
        );

        DROP OPERATOR IF EXISTS public.-(year, interval);
        DROP OPERATOR IF EXISTS pg_catalog.-(year, interval);
        CREATE OPERATOR pg_catalog.- (
           leftarg = year,
           rightarg = interval,
           procedure = year_mi_interval,
           commutator = operator(pg_catalog.-)
        );

        DROP OPERATOR IF EXISTS public.+(interval, year);
        DROP OPERATOR IF EXISTS pg_catalog.+(interval, year);
        CREATE OPERATOR pg_catalog.+ (
           leftarg = interval,
           rightarg = year,
           procedure = interval_pl_year,
           commutator = operator(pg_catalog.+)
        );

        CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_time (int8) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_b_format_time';
        DROP CAST IF EXISTS (int8 AS time);

        CREATE CAST(int8 AS time) WITH FUNCTION int64_b_format_time(int8) AS IMPLICIT;

        CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_datetime (int4) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int32_b_format_datetime';

        CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_datetime (int8) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_b_format_datetime';

        CREATE OR REPLACE FUNCTION pg_catalog.numeric_b_format_datetime (numeric) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_b_format_datetime';

        DROP CAST IF EXISTS (int4 AS datetime);

        CREATE CAST(int4 AS timestamp(0) without time zone) WITH FUNCTION int32_b_format_datetime(int4) AS IMPLICIT;

        DROP CAST IF EXISTS (int8 AS datetime);

        CREATE CAST(int8 AS timestamp(0) without time zone) WITH FUNCTION int64_b_format_datetime(int8) AS IMPLICIT;

        DROP CAST IF EXISTS (numeric AS datetime);

        CREATE CAST(numeric AS timestamp(0) without time zone) WITH FUNCTION numeric_b_format_datetime(numeric) AS IMPLICIT;

        DROP FUNCTION IF EXISTS pg_catalog.year (datetime);
        CREATE OR REPLACE FUNCTION pg_catalog.year (timestamp(0) without time zone) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'datetime_year_part';
        CREATE OR REPLACE FUNCTION pg_catalog.year (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'text_year_part';
        CREATE OR REPLACE FUNCTION pg_catalog.sec_to_time (text) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'sec_to_time_str';

        DROP FUNCTION IF EXISTS pg_catalog.subtime (text, text);
        DROP FUNCTION IF EXISTS pg_catalog.subtime (date, text);
        DROP FUNCTION IF EXISTS pg_catalog.subtime (date, datetime);
        DROP FUNCTION IF EXISTS pg_catalog.subtime (date, date);
        DROP FUNCTION IF EXISTS pg_catalog.subtime (text, datetime);
        DROP FUNCTION IF EXISTS pg_catalog.subtime (text, date);
        DROP FUNCTION IF EXISTS pg_catalog.subtime (numeric, numeric);
        DROP FUNCTION IF EXISTS pg_catalog.subtime (text, numeric);
        DROP FUNCTION IF EXISTS pg_catalog.subtime (numeric, text);

        DROP FUNCTION IF EXISTS pg_catalog.timediff (text, text);
        DROP FUNCTION IF EXISTS pg_catalog.timediff (datetime, text);
        DROP FUNCTION IF EXISTS pg_catalog.timediff (time, text);
        DROP FUNCTION IF EXISTS pg_catalog.timediff (datetime, time);
        DROP FUNCTION IF EXISTS pg_catalog.timediff (time, date);
        DROP FUNCTION IF EXISTS pg_catalog.timediff (date, text);
        DROP FUNCTION IF EXISTS pg_catalog.timediff (date, time);
        DROP FUNCTION IF EXISTS pg_catalog.timediff (numeric, numeric);
        DROP FUNCTION IF EXISTS pg_catalog.timediff (text, numeric);
        DROP FUNCTION IF EXISTS pg_catalog.timediff (numeric, text);

        CREATE OR REPLACE FUNCTION pg_catalog.subtime ("any", "any") RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'subtime';
        CREATE OR REPLACE FUNCTION pg_catalog.timediff ("any", "any") RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timediff';

        DROP FUNCTION IF EXISTS pg_catalog.time_format (date, text);
        CREATE OR REPLACE FUNCTION pg_catalog.time_format (date, text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_format_date';
        
        DROP FUNCTION IF EXISTS pg_catalog.time_mysql (text);
        DROP FUNCTION IF EXISTS pg_catalog.time_mysql (numeric);
        DROP FUNCTION IF EXISTS pg_catalog.time_mysql (date);
        CREATE OR REPLACE FUNCTION pg_catalog.time_mysql ("any") RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_mysql';

        DROP FUNCTION IF EXISTS pg_catalog.timestamp_mysql (datetime);
        DROP FUNCTION IF EXISTS pg_catalog.timestamp_mysql (datetime, text);
        DROP FUNCTION IF EXISTS pg_catalog.timestamp_mysql (text, text);
        DROP FUNCTION IF EXISTS pg_catalog.timestamp_mysql (time, text);
        DROP FUNCTION IF EXISTS pg_catalog.timestamp_mysql (time);
        
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_mysql ("any") RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_param1';
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_mysql ("any", "any") RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_param2';

        DROP FUNCTION IF EXISTS pg_catalog.timestamp_add (text, numeric, text);
        DROP FUNCTION IF EXISTS pg_catalog.timestamp_add (text, numeric, time);
        DROP FUNCTION IF EXISTS pg_catalog.timestamp_add (text, numeric, numeric);

        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_add (text, numeric, "any") RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_add_numeric';
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_add (text, text, "any") RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_add_text';

        DROP FUNCTION IF EXISTS pg_catalog.to_days (datetime);
        CREATE OR REPLACE FUNCTION pg_catalog.to_days (timestamp(0) without time zone) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'to_days';

        DROP FUNCTION IF EXISTS pg_catalog.to_seconds (text);
        DROP FUNCTION IF EXISTS pg_catalog.to_seconds (time);
        DROP FUNCTION IF EXISTS pg_catalog.to_seconds (numeric);
        CREATE OR REPLACE FUNCTION pg_catalog.to_seconds ("any") RETURNS numeric LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'to_seconds';

        DROP FUNCTION IF EXISTS pg_catalog.unix_timestamp (text);
        DROP FUNCTION IF EXISTS pg_catalog.unix_timestamp (time);
        DROP FUNCTION IF EXISTS pg_catalog.unix_timestamp (numeric);
        CREATE OR REPLACE FUNCTION pg_catalog.unix_timestamp ("any") RETURNS numeric LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'unix_timestamp';

        DROP FUNCTION IF EXISTS pg_catalog.utc_timestamp_func (int4);
        CREATE OR REPLACE FUNCTION pg_catalog.utc_timestamp_func (int4) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'utc_timestamp_func';
        
        DROP FUNCTION IF EXISTS pg_catalog.b_db_date(text);
        CREATE OR REPLACE FUNCTION pg_catalog.b_db_date(text) RETURNS date LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'b_db_date_text';
        DROP FUNCTION IF EXISTS pg_catalog.b_db_date(numeric);
        CREATE OR REPLACE FUNCTION pg_catalog.b_db_date(numeric) RETURNS date LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'b_db_date_numeric';

        DROP FUNCTION IF EXISTS pg_catalog.datediff(text, text);
        DROP FUNCTION IF EXISTS pg_catalog.datediff(text, numeric);
        DROP FUNCTION IF EXISTS pg_catalog.datediff(numeric, text);
        DROP FUNCTION IF EXISTS pg_catalog.datediff(numeric, numeric);
        CREATE OR REPLACE FUNCTION pg_catalog.datediff(text, text) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'datediff_t_t';
        CREATE OR REPLACE FUNCTION pg_catalog.datediff(text, numeric) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'datediff_t_n';
        CREATE OR REPLACE FUNCTION pg_catalog.datediff(numeric, text) RETURNS int4 AS $$ SELECT -pg_catalog.datediff($2, $1) $$ LANGUAGE SQL;
        CREATE OR REPLACE FUNCTION pg_catalog.datediff(numeric, numeric) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'datediff_n_n';
        CREATE OR REPLACE FUNCTION pg_catalog.datediff(time, text) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'datediff_time_t';
        CREATE OR REPLACE FUNCTION pg_catalog.datediff(time, numeric) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'datediff_time_n';
        CREATE OR REPLACE FUNCTION pg_catalog.datediff(time, time) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'datediff_time_time';
        CREATE OR REPLACE FUNCTION pg_catalog.datediff(text, time) RETURNS int4 AS $$ SELECT -pg_catalog.datediff($2, $1) $$ LANGUAGE SQL;
        CREATE OR REPLACE FUNCTION pg_catalog.datediff(numeric, time) RETURNS int4 AS $$ SELECT -pg_catalog.datediff($2, $1) $$ LANGUAGE SQL;

        DROP FUNCTION IF EXISTS pg_catalog.b_timestampdiff(text,text,text);
        DROP FUNCTION IF EXISTS pg_catalog.b_timestampdiff(text,time,text);
        DROP FUNCTION IF EXISTS pg_catalog.b_timestampdiff(text,text,time);
        CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,text,text) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'timestampdiff_datetime_tt';
        CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,numeric,numeric) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'timestampdiff_datetime_nn';
        CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,text,numeric) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'timestampdiff_datetime_tn';
        CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,numeric,text) RETURNS int8 AS $$ SELECT -pg_catalog.b_timestampdiff($1, $3, $2) $$ LANGUAGE SQL;
        CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,time,text) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'timestampdiff_time_before_t';
        CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,time,numeric) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'timestampdiff_time_before_n';
        CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,text,time) RETURNS int8 AS $$ SELECT -pg_catalog.b_timestampdiff($1, $3, $2) $$ LANGUAGE SQL;
        CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,numeric,time) RETURNS int8 AS $$ SELECT -pg_catalog.b_timestampdiff($1, $3, $2) $$ LANGUAGE SQL;
        
        DROP FUNCTION IF EXISTS pg_catalog.convert_tz(text,text,text);
        DROP FUNCTION IF EXISTS pg_catalog.convert_tz(numeric,text,text);
        CREATE OR REPLACE FUNCTION pg_catalog.convert_tz(text,text,text) RETURNS timestamp(0) without time zone LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'convert_tz_t';
        CREATE OR REPLACE FUNCTION pg_catalog.convert_tz(numeric,text,text) RETURNS timestamp(0) without time zone LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'convert_tz_n';
        CREATE OR REPLACE FUNCTION pg_catalog.convert_tz(time,text,text) RETURNS timestamp(0) without time zone LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'convert_tz_time';

        DROP FUNCTION IF EXISTS pg_catalog.adddate(text, int8);
        CREATE OR REPLACE FUNCTION pg_catalog.adddate (text, int8) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'adddate_datetime_days_t';

        DROP FUNCTION IF EXISTS pg_catalog.adddate(text, interval);
        DROP FUNCTION IF EXISTS pg_catalog.adddate(numeric, int8);
        DROP FUNCTION IF EXISTS pg_catalog.adddate(numeric, interval);
        CREATE OR REPLACE FUNCTION pg_catalog.adddate (text, interval) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'adddate_datetime_interval_t';
        CREATE OR REPLACE FUNCTION pg_catalog.adddate (numeric, int8) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'adddate_datetime_days_n';
        CREATE OR REPLACE FUNCTION pg_catalog.adddate (numeric, interval) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'adddate_datetime_interval_n';
        
        DROP FUNCTION IF EXISTS pg_catalog.date_sub (text, interval);
        DROP FUNCTION IF EXISTS pg_catalog.date_sub (numeric, interval);
        DROP FUNCTION IF EXISTS pg_catalog.date_sub (time, interval);
        CREATE OR REPLACE FUNCTION pg_catalog.date_sub (text, interval) RETURNS text AS $$ SELECT pg_catalog.adddate($1, -$2)  $$ LANGUAGE SQL;
        CREATE OR REPLACE FUNCTION pg_catalog.date_sub (numeric, interval) RETURNS text AS $$ SELECT pg_catalog.adddate($1, -$2)  $$ LANGUAGE SQL;
        CREATE OR REPLACE FUNCTION pg_catalog.date_sub (time, interval) RETURNS time AS $$ SELECT pg_catalog.adddate($1, -$2)  $$ LANGUAGE SQL;

        DROP FUNCTION IF EXISTS pg_catalog.date_add (numeric, interval);
        CREATE OR REPLACE FUNCTION pg_catalog.date_add (numeric, interval) RETURNS text AS $$ SELECT pg_catalog.adddate($1, $2)  $$ LANGUAGE SQL;

        DROP FUNCTION IF EXISTS pg_catalog.addtime (date, datetime);
        DROP FUNCTION IF EXISTS pg_catalog.addtime (text, datetime);
        CREATE OR REPLACE FUNCTION pg_catalog.addtime (date, timestamp(0) without time zone) RETURNS TEXT LANGUAGE SQL STABLE STRICT as 'select pg_catalog.addtime(cast(0 as time), cast($2 as time))';
        CREATE OR REPLACE FUNCTION pg_catalog.addtime (text, timestamp(0) without time zone) RETURNS TEXT LANGUAGE SQL STABLE STRICT as 'select pg_catalog.addtime($1, cast($2 as time))';

        CREATE OR REPLACE FUNCTION pg_catalog.hour (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetHour';
        CREATE OR REPLACE FUNCTION pg_catalog.microsecond (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMicrosecond';
        CREATE OR REPLACE FUNCTION pg_catalog.minute (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMinute';
        CREATE OR REPLACE FUNCTION pg_catalog.second (text) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetSecond';

        CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth (timestamptz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''day'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth (timetz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''day'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth (abstime) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''day'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth (date) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''day'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth (time) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''day'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth (timestamp(0) with time zone) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''day'', $1)';

        CREATE OR REPLACE FUNCTION pg_catalog.dayofweek (timestamptz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select 1 + pg_catalog.date_part(''dow'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofweek (timetz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select 1 + pg_catalog.date_part(''dow'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofweek (abstime) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select 1 + pg_catalog.date_part(''dow'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofweek (date) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select 1 + pg_catalog.date_part(''dow'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofweek (time) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select 1 + pg_catalog.date_part(''dow'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofweek (timestamp(0) with time zone) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select 1 + pg_catalog.date_part(''dow'', $1)';

        CREATE OR REPLACE FUNCTION pg_catalog.dayofyear (timestamptz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''doy'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofyear (timetz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''doy'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofyear (abstime) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''doy'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofyear (date) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''doy'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofyear (time) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''doy'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.dayofyear (timestamp(0) with time zone) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''doy'', $1)';

        CREATE OR REPLACE FUNCTION pg_catalog.quarter (timestamptz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.quarter (timetz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.quarter (abstime) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.quarter (date) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.quarter (time) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.quarter (timestamp(0) with time zone) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)';

        CREATE OR REPLACE FUNCTION pg_catalog.weekday (timestamptz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1) - 1';
        CREATE OR REPLACE FUNCTION pg_catalog.weekday (timetz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1) - 1';
        CREATE OR REPLACE FUNCTION pg_catalog.weekday (abstime) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1) - 1';
        CREATE OR REPLACE FUNCTION pg_catalog.weekday (date) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1) - 1';
        CREATE OR REPLACE FUNCTION pg_catalog.weekday (time) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1) - 1';
        CREATE OR REPLACE FUNCTION pg_catalog.weekday (timestamp(0) with time zone) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1) - 1';

        CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (timestamptz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (timetz) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (abstime) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (date) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (time) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)';
        CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (timestamp(0) with time zone) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)';

        CREATE OR REPLACE FUNCTION pg_catalog.get_format (int4, text) RETURNS TEXT LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'get_format';

        CREATE OR REPLACE FUNCTION pg_catalog.date_format (text, text) RETURNS TEXT LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'date_format_text';
        CREATE OR REPLACE FUNCTION pg_catalog.date_format (numeric, text) RETURNS TEXT LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'date_format_numeric';

        CREATE OR REPLACE FUNCTION pg_catalog.b_extract (text, text) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'b_extract_text';
        CREATE OR REPLACE FUNCTION pg_catalog.b_extract (text, numeric) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'b_extract_numeric';

        CREATE OR REPLACE FUNCTION pg_catalog.str_to_date (text, text) RETURNS text LANGUAGE C STABLE CALLED ON NULL INPUT as '$libdir/dolphin', 'str_to_date';

        CREATE OR REPLACE FUNCTION pg_catalog.from_unixtime (numeric) RETURNS timestamp(0) without time zone LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'from_unixtime_with_one_arg';
        CREATE OR REPLACE FUNCTION pg_catalog.from_unixtime (numeric, text) RETURNS TEXT LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'from_unixtime_with_two_arg';

        -- support bit_xor for date

        DROP FUNCTION IF EXISTS pg_catalog.date_xor_transfn(int16, date);
        CREATE OR REPLACE FUNCTION pg_catalog.date_xor_transfn (
        int16, date
        ) RETURNS int16 LANGUAGE C as '$libdir/dolphin',  'date_xor_transfn';

        DROP FUNCTION IF EXISTS pg_catalog.date_agg_finalfn(int16);
        CREATE OR REPLACE FUNCTION pg_catalog.date_agg_finalfn (
        int16
        ) RETURNS int16 LANGUAGE C as '$libdir/dolphin',  'date_agg_finalfn';

        drop aggregate if exists pg_catalog.bit_xor(date);
        create aggregate pg_catalog.bit_xor(date) (SFUNC=date_xor_transfn, finalfunc = date_agg_finalfn,  STYPE= int16);

        -- support bit_xor aggregate for year

        DROP FUNCTION IF EXISTS pg_catalog.year_xor_transfn(integer, year) ;
        CREATE OR REPLACE FUNCTION pg_catalog.year_xor_transfn (
        integer, year
        ) RETURNS integer LANGUAGE C as '$libdir/dolphin',  'year_xor_transfn';

        drop aggregate if exists pg_catalog.bit_xor(year);
        create aggregate pg_catalog.bit_xor(year) (SFUNC=year_xor_transfn, STYPE= integer);

        -- support bit_xor for datetime and timestamp
        DROP FUNCTION IF EXISTS pg_catalog.timestamp_xor_transfn(int16, timestamp(0) with time zone) ;
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_xor_transfn (
        int16, timestamp(0) with time zone
        ) RETURNS int16 LANGUAGE C as '$libdir/dolphin',  'timestamp_xor_transfn';

        DROP FUNCTION IF EXISTS pg_catalog.timestamp_agg_finalfn(int16) ;
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_agg_finalfn (
        int16
        ) RETURNS int16 LANGUAGE C as '$libdir/dolphin',  'timestamp_agg_finalfn';

        drop aggregate if exists pg_catalog.bit_xor(timestamp(0) with time zone);
        create aggregate pg_catalog.bit_xor(timestamp(0) with time zone) (SFUNC=timestamp_xor_transfn, finalfunc=timestamp_agg_finalfn, STYPE=int16);

        -- support bit_xor aggregate for time

        DROP FUNCTION IF EXISTS pg_catalog.time_xor_transfn(int16, time) ;
        CREATE OR REPLACE FUNCTION pg_catalog.time_xor_transfn (
        int16, time
        ) RETURNS int16 LANGUAGE C as '$libdir/dolphin',  'time_xor_transfn';

        create aggregate pg_catalog.bit_xor(time) (SFUNC=time_xor_transfn, STYPE= int16);

        DROP FUNCTION IF EXISTS pg_catalog.timetz_xor_transfn(int16, time with time zone) ;
        CREATE OR REPLACE FUNCTION pg_catalog.timetz_xor_transfn (
        int16, time with time zone
        ) RETURNS int16 LANGUAGE C as '$libdir/dolphin',  'timetz_xor_transfn';

        create aggregate pg_catalog.bit_xor(time with time zone) (SFUNC=timetz_xor_transfn, STYPE= int16);


        DROP FUNCTION IF EXISTS pg_catalog.year_any_value (year, year) ;
        CREATE OR REPLACE FUNCTION pg_catalog.year_any_value (year, year) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_any_value';

        drop aggregate if exists pg_catalog.any_value(year);
        CREATE AGGREGATE pg_catalog.any_value(year) (
                sfunc = year_any_value,
                stype = year
        );

        DROP FUNCTION IF EXISTS pg_catalog.time_int8(time) ;
        CREATE OR REPLACE FUNCTION pg_catalog.time_int8(time) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time_int8';
        CREATE CAST (time as int8) with function pg_catalog.time_int8(time);
        CREATE OR REPLACE FUNCTION pg_catalog.time_float (time) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_float';
        DROP CAST IF EXISTS (time AS float8) ;
        CREATE CAST(time AS float8) WITH FUNCTION time_float(time) AS IMPLICIT;
        DROP FUNCTION IF EXISTS pg_catalog.time_numeric(time) ;
        CREATE OR REPLACE FUNCTION pg_catalog.time_numeric(time) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time_numeric';
        CREATE CAST (time as numeric) with function pg_catalog.time_numeric(time);

        CREATE OR REPLACE FUNCTION pg_catalog.time_integer (time) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.time_float($1) as integer)';
        DROP CAST IF EXISTS (time AS integer) ;
        CREATE CAST(time AS integer) WITH FUNCTION time_integer(time);

        CREATE OR REPLACE FUNCTION pg_catalog.time_pl_float (time, float8) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.time_float($1) + $2';
        -- DROP OPERATOR IF EXISTS + (time, float8);
        CREATE OPERATOR pg_catalog.+ (
            PROCEDURE = time_pl_float,
            LEFTARG = time,
            RIGHTARG = float8
        );

        CREATE OR REPLACE FUNCTION pg_catalog.time_mi_float (time, float8) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.time_float($1) - $2';
        -- DROP OPERATOR IF EXISTS - (time, float8);
        CREATE OPERATOR pg_catalog.- (
            PROCEDURE = time_mi_float,
            LEFTARG = time,
            RIGHTARG = float8
        );

        CREATE OR REPLACE FUNCTION pg_catalog.datetime_float (timestamp(0) without time zone) RETURNS float8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'datetime_float';
        DROP CAST IF EXISTS (timestamp(0) without time zone AS float8) ;
        CREATE CAST(timestamp(0) without time zone AS float8) WITH FUNCTION datetime_float(timestamp(0) without time zone) AS IMPLICIT;

        CREATE OR REPLACE FUNCTION pg_catalog.datetime_bigint (timestamp(0) without time zone) RETURNS bigint LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as bigint)';
        DROP CAST IF EXISTS (timestamp(0) without time zone AS bigint) ;
        CREATE CAST(timestamp(0) without time zone AS bigint) WITH FUNCTION datetime_bigint(timestamp(0) without time zone);

        CREATE OR REPLACE FUNCTION pg_catalog.datetime_pl_float (timestamp(0) without time zone, float8) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.datetime_float($1) + $2';
        -- DROP OPERATOR IF EXISTS + (timestamp(0) without time zone, float8);
        CREATE OPERATOR pg_catalog.+ (
            PROCEDURE = datetime_pl_float,
            LEFTARG = timestamp(0) without time zone,
            RIGHTARG = float8
        );

        CREATE OR REPLACE FUNCTION pg_catalog.datetime_mi_float (timestamp(0) without time zone, float8) RETURNS float8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.datetime_float($1) - $2';
        -- DROP OPERATOR IF EXISTS - (timestamp(0) without time zone, float8);
        CREATE OPERATOR pg_catalog.- (
            PROCEDURE = datetime_mi_float,
            LEFTARG = timestamp(0) without time zone,
            RIGHTARG = float8
        );

        CREATE OR REPLACE FUNCTION pg_catalog.date_int (date) RETURNS int4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'date_int';
        DROP CAST IF EXISTS (date AS integer) ;
        CREATE CAST(date AS integer) WITH FUNCTION date_int(date);

        -- CREATE OR REPLACE FUNCTION pg_catalog.date_pl_int (date, integer) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_int($1) + $2';
        -- -- DROP OPERATOR + (date, integer);
        -- CREATE OPERATOR + (
        --     PROCEDURE = date_pl_int,
        --     LEFTARG = date,
        --     RIGHTARG = integer
        -- );

        -- CREATE OR REPLACE FUNCTION pg_catalog.date_mi_int (date, integer) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_int($1) - $2';
        -- -- DROP OPERATOR - (date, integer);
        -- CREATE OPERATOR - (
        --     PROCEDURE = date_mi_int,
        --     LEFTARG = date,
        --     RIGHTARG = integer
        -- );

        CREATE OR REPLACE FUNCTION pg_catalog.datexor(
        date,
        date
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'datexor';
        create operator pg_catalog.^(leftarg = date, rightarg = date, procedure = pg_catalog.datexor);

        CREATE OR REPLACE FUNCTION pg_catalog.timexor(
        time,
        time
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timexor';
        create operator pg_catalog.^(leftarg = time, rightarg = time, procedure = pg_catalog.timexor);

        CREATE OR REPLACE FUNCTION pg_catalog.date_time_xor(
        date,
        time
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_time_xor';
        create operator pg_catalog.^(leftarg = date, rightarg = time, procedure = pg_catalog.date_time_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.time_date_xor(
        time,
        date
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_date_xor';
        create operator pg_catalog.^(leftarg = time, rightarg = date, procedure = pg_catalog.time_date_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.time_text_xor(
        time,
        text
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_text_xor';
        create operator pg_catalog.^(leftarg = time, rightarg = text, procedure = pg_catalog.time_text_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.text_time_xor(
        text,
        time
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_time_xor';
        create operator pg_catalog.^(leftarg = text, rightarg = time, procedure = pg_catalog.text_time_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.date_text_xor(
        date,
        text
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_text_xor';
        create operator pg_catalog.^(leftarg = date, rightarg = text, procedure = pg_catalog.date_text_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.text_date_xor(
        text,
        date
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_date_xor';
        create operator pg_catalog.^(leftarg = text, rightarg = date, procedure = pg_catalog.text_date_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.date_int8_xor(
        date,
        int8
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_int8_xor';
        create operator pg_catalog.^(leftarg = date, rightarg = int8, procedure = pg_catalog.date_int8_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.int8_date_xor(
        int8,
        date
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_date_xor';
        create operator pg_catalog.^(leftarg = int8, rightarg = date, procedure = pg_catalog.int8_date_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.time_int8_xor(
        time,
        int8
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_int8_xor';
        create operator pg_catalog.^(leftarg = time, rightarg = int8, procedure = pg_catalog.time_int8_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.int8_time_xor(
        int8,
        time
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_time_xor';
        create operator pg_catalog.^(leftarg = int8, rightarg = time, procedure = pg_catalog.int8_time_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.date_float8_xor(
        date,
        float8
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_float8_xor';
        create operator pg_catalog.^(leftarg = date, rightarg = float8, procedure = pg_catalog.date_float8_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.float8_date_xor(
        float8,
        date
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float8_date_xor';
        create operator pg_catalog.^(leftarg = float8, rightarg = date, procedure = pg_catalog.float8_date_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.timestampxor(
        timestamp without time zone,
        timestamp without time zone
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestampxor';
        create operator pg_catalog.^(leftarg = timestamp without time zone, rightarg = timestamp without time zone, procedure = pg_catalog.timestampxor);

        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_int8_xor(
        timestamp without time zone,
        int8
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamp_int8_xor';
        create operator pg_catalog.^(leftarg = timestamp without time zone, rightarg = int8, procedure = pg_catalog.timestamp_int8_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.int8_timestamp_xor(
        int8,
        timestamp without time zone
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_timestamp_xor';
        create operator pg_catalog.^(leftarg = int8, rightarg = timestamp without time zone, procedure = pg_catalog.int8_timestamp_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_float8_xor(
        timestamp without time zone,
        float8
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamp_float8_xor';
        create operator pg_catalog.^(leftarg = timestamp without time zone, rightarg = float8, procedure = pg_catalog.timestamp_float8_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.float8_timestamp_xor(
        float8,
        timestamp without time zone
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float8_timestamp_xor';
        create operator pg_catalog.^(leftarg = float8, rightarg = timestamp without time zone, procedure = pg_catalog.float8_timestamp_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_xor(
        timestamp without time zone,
        text
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamp_text_xor';
        create operator pg_catalog.^(leftarg = timestamp without time zone, rightarg = text, procedure = pg_catalog.timestamp_text_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_xor(
        text,
        timestamp without time zone
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_timestamp_xor';
        create operator pg_catalog.^(leftarg = text, rightarg = timestamp without time zone, procedure = pg_catalog.text_timestamp_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.timestamptzxor(
        timestampTz,
        timestampTz
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptzxor';
        create operator pg_catalog.^(leftarg = timestampTz, rightarg = timestampTz, procedure = pg_catalog.timestamptzxor);

        CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_int8_xor(
        timestampTz,
        int8
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptz_int8_xor';
        create operator pg_catalog.^(leftarg = timestampTz, rightarg = int8, procedure = pg_catalog.timestamptz_int8_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.int8_timestamptz_xor(
        int8,
        timestampTz
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_timestamptz_xor';
        create operator pg_catalog.^(leftarg = int8, rightarg = timestampTz, procedure = pg_catalog.int8_timestamptz_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_float8_xor(
        timestampTz,
        float8
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptz_float8_xor';
        create operator pg_catalog.^(leftarg = timestampTz, rightarg = float8, procedure = pg_catalog.timestamptz_float8_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.float8_timestamptz_xor(
        float8,
        timestampTz
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float8_timestamptz_xor';
        create operator pg_catalog.^(leftarg = float8, rightarg = timestampTz, procedure = pg_catalog.float8_timestamptz_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_text_xor(
        timestampTz,
        text
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptz_text_xor';
        create operator pg_catalog.^(leftarg = timestampTz, rightarg = text, procedure = pg_catalog.timestamptz_text_xor);

        CREATE OR REPLACE FUNCTION pg_catalog.text_timestamptz_xor(
        text,
        timestampTz
        ) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_timestamptz_xor';
        create operator pg_catalog.^(leftarg = text, rightarg = timestampTz, procedure = pg_catalog.text_timestamptz_xor);

        DROP FUNCTION IF EXISTS pg_catalog.sleep(float8) ;
        CREATE OR REPLACE FUNCTION pg_catalog.sleep (float8)
        RETURNS int LANGUAGE C STABLE CALLED ON NULL INPUT as '$libdir/dolphin', 'db_b_sleep';

        DROP FUNCTION IF EXISTS pg_catalog.timetz_int8(timetz) ;
        CREATE OR REPLACE FUNCTION pg_catalog.timetz_int8(timetz) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timetz_int8';
        CREATE CAST (timetz as int8) with function pg_catalog.timetz_int8(timetz);

        DROP FUNCTION IF EXISTS pg_catalog.timetz_float8(timetz) ;
        CREATE OR REPLACE FUNCTION pg_catalog.timetz_float8(timetz) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timetz_float8';
        CREATE CAST (timetz as float8) with function pg_catalog.timetz_float8(timetz);

        DROP FUNCTION IF EXISTS pg_catalog.timetz_numeric(timetz) ;
        CREATE OR REPLACE FUNCTION pg_catalog.timetz_numeric(timetz) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timetz_numeric';
        CREATE CAST (timetz as numeric) with function pg_catalog.timetz_numeric(timetz);

        DROP FUNCTION IF EXISTS pg_catalog.timestamp_numeric(timestamp without time zone) ;
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_numeric(timestamp without time zone) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamp_numeric';
        CREATE CAST (timestamp without time zone as numeric) with function pg_catalog.timestamp_numeric(timestamp without time zone);

        DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int8("timestamptz") ;
        CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_int8("timestamptz") RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamptz_int8';
        CREATE CAST ("timestamptz" as int8) with function pg_catalog.timestamptz_int8("timestamptz");

        DROP FUNCTION IF EXISTS pg_catalog.timestamptz_float8("timestamptz") ;
        CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_float8("timestamptz") RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamptz_float8';
        CREATE CAST ("timestamptz" as float8) with function pg_catalog.timestamptz_float8("timestamptz");

        DROP FUNCTION IF EXISTS pg_catalog.timestamptz_numeric("timestamptz") ;
        CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_numeric("timestamptz") RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamptz_numeric';
        CREATE CAST ("timestamptz" as numeric) with function pg_catalog.timestamptz_numeric("timestamptz");

        DROP FUNCTION IF EXISTS pg_catalog.date_int8("date") ;
        CREATE OR REPLACE FUNCTION pg_catalog.date_int8("date") RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'date_int8';
        CREATE CAST ("date" as int8) with function pg_catalog.date_int8("date");

        DROP FUNCTION IF EXISTS pg_catalog.date2float8("date") ;
        CREATE OR REPLACE FUNCTION pg_catalog.date2float8("date") RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::float8; $$;
        CREATE CAST ("date" as float8) with function pg_catalog.date2float8("date");

        DROP FUNCTION IF EXISTS pg_catalog.date_numeric("date") ;
        CREATE OR REPLACE FUNCTION pg_catalog.date_numeric("date") RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'date_numeric';
        CREATE CAST ("date" as numeric) with function pg_catalog.date_numeric("date");

        DROP FUNCTION IF EXISTS pg_catalog.date_any_value (date, date) ;
        CREATE OR REPLACE FUNCTION pg_catalog.date_any_value (date, date) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'date_any_value';

        DROP FUNCTION IF EXISTS pg_catalog.year_float8("year") ;
        CREATE OR REPLACE FUNCTION pg_catalog.year_float8("year") RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_float8';
        drop CAST IF EXISTS (year AS float8) ;
        CREATE CAST ("year" as float8) with function pg_catalog.year_float8("year");

        DROP FUNCTION IF EXISTS pg_catalog.year_numeric("year") ;
        CREATE OR REPLACE FUNCTION pg_catalog.year_numeric("year") RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_numeric';
        drop CAST IF EXISTS (year AS numeric) ;
        CREATE CAST ("year" as numeric) with function pg_catalog.year_numeric("year");

        drop aggregate if exists pg_catalog.any_value(date);
        CREATE AGGREGATE pg_catalog.any_value(date) (
                sfunc = date_any_value,
                stype = date
        );

        DROP FUNCTION IF EXISTS pg_catalog.time_any_value (time, time) ;
        CREATE OR REPLACE FUNCTION pg_catalog.time_any_value (time, time) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_any_value';

        drop aggregate if exists pg_catalog.any_value(time);
        CREATE AGGREGATE pg_catalog.any_value(time) (
                sfunc = time_any_value,
                stype = time
        );

        DROP FUNCTION IF EXISTS pg_catalog.timetz_any_value (timetz, timetz) ;
        CREATE OR REPLACE FUNCTION pg_catalog.timetz_any_value (timetz, timetz) RETURNS timetz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timetz_any_value';

        drop aggregate if exists pg_catalog.any_value(timetz);
        CREATE AGGREGATE pg_catalog.any_value(timetz) (
                sfunc = timetz_any_value,
                stype = timetz
        );

        DROP FUNCTION IF EXISTS pg_catalog.timestamp_any_value (timestamp without time zone, timestamp without time zone) ;
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_any_value (timestamp without time zone, timestamp without time zone) RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_any_value';

        drop aggregate if exists pg_catalog.any_value(timestamp without time zone);
        CREATE AGGREGATE pg_catalog.any_value(timestamp without time zone) (
                sfunc = timestamp_any_value,
                stype = timestamp without time zone
        );

        DROP FUNCTION IF EXISTS pg_catalog.timestamptz_any_value (timestamptz, timestamptz) ;
        CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_any_value (timestamptz, timestamptz) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_any_value';

        drop aggregate if exists pg_catalog.any_value(timestamptz);
        CREATE AGGREGATE pg_catalog.any_value(timestamptz) (
                sfunc = timestamptz_any_value,
                stype = timestamptz
        );
        
        DROP FUNCTION IF EXISTS pg_catalog.json_quote(text);
        DROP FUNCTION IF EXISTS pg_catalog.json_array(variadic "any");
        CREATE OR REPLACE FUNCTION pg_catalog.json_quote(text) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_quote';
        CREATE OR REPLACE FUNCTION pg_catalog.json_array(variadic "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_array';
        CREATE OR REPLACE FUNCTION pg_catalog.json_array() RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_array';

        DROP FUNCTION IF EXISTS pg_catalog.json_contains(json, json, text);
        DROP FUNCTION IF EXISTS pg_catalog.json_contains(json, json);
        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';

        DROP FUNCTION IF EXISTS pg_catalog.json_contains_path(json, text, variadic text[]);
        CREATE OR REPLACE FUNCTION pg_catalog.json_contains_path("any", text, variadic text[]) RETURNS boolean LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_contains_path';
        
        CREATE OR REPLACE FUNCTION pg_catalog.json_extract("any", variadic text[]) RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin',  'json_extract';

        DROP FUNCTION IF EXISTS pg_catalog.json_extract(json, variadic text[]);
        DROP FUNCTION IF EXISTS pg_catalog.json_keys(json);
        DROP FUNCTION IF EXISTS pg_catalog.json_keys(json,text);

        DROP FUNCTION IF EXISTS pg_catalog.json_search(json,text,"any");
        DROP FUNCTION IF EXISTS pg_catalog.json_search(json,text,"any","any");
        DROP FUNCTION IF EXISTS pg_catalog.json_search(json,text,"any","any",variadic text[]);

        DROP FUNCTION IF EXISTS pg_catalog.json_array_append(json, VARIADIC "any");

        DROP FUNCTION IF EXISTS pg_catalog.json_append(json, VARIADIC "any");

        DROP FUNCTION IF EXISTS pg_catalog.json_unquote(text);
        DROP FUNCTION IF EXISTS pg_catalog.json_unquote(json);

        DROP FUNCTION IF EXISTS pg_catalog.json_merge_preserve(variadic json[]);

        DROP FUNCTION IF EXISTS pg_catalog.json_merge(variadic json[]);

        DROP FUNCTION IF EXISTS pg_catalog.json_merge_patch(variadic json[]);

        DROP FUNCTION IF EXISTS pg_catalog.json_insert(variadic "any");

        DROP FUNCTION IF EXISTS pg_catalog.json_depth(json);

        DROP FUNCTION IF EXISTS pg_catalog.json_replace(variadic arr "any");

        DROP FUNCTION IF EXISTS pg_catalog.json_remove(json, variadic "any");

        DROP FUNCTION IF EXISTS pg_catalog.json_array_insert(json, variadic "any");

        DROP FUNCTION IF EXISTS pg_catalog.json_set( variadic "any");

        CREATE OR REPLACE FUNCTION pg_catalog.json_keys("any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_keys';
        CREATE OR REPLACE FUNCTION pg_catalog.json_keys("any",text) RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_keys';

        CREATE OR REPLACE FUNCTION pg_catalog.json_search("any",text,"any") RETURNS text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_search';
        CREATE OR REPLACE FUNCTION pg_catalog.json_search("any",text,"any","any") RETURNS text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_search';
        CREATE OR REPLACE FUNCTION pg_catalog.json_search("any",text,"any","any",variadic text[]) RETURNS text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_search';

        CREATE OR REPLACE FUNCTION pg_catalog.json_array_append("any", VARIADIC "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_array_append';

        CREATE OR REPLACE FUNCTION pg_catalog.json_append("any", VARIADIC "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_append';

        CREATE OR REPLACE FUNCTION pg_catalog.json_unquote("any") RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','json_unquote';

        CREATE OR REPLACE FUNCTION pg_catalog.json_merge_preserve(variadic arr "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_merge_preserve';

        CREATE OR REPLACE FUNCTION pg_catalog.json_merge(variadic arr "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_merge';

        CREATE OR REPLACE FUNCTION pg_catalog.json_merge_patch(variadic arr "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_merge_patch';

        CREATE OR REPLACE FUNCTION pg_catalog.json_insert(variadic "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_insert';

        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_replace(variadic arr "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_replace';

        CREATE OR REPLACE FUNCTION pg_catalog.json_remove(variadic arr "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_remove';

        CREATE OR REPLACE FUNCTION pg_catalog.json_array_insert(variadic arr "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_array_insert';

        CREATE OR REPLACE FUNCTION pg_catalog.json_set(variadic "any") RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_set';

        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 aggregate pg_catalog.json_arrayagg("any") (SFUNC = json_agg_transfn, STYPE = internal, finalfunc = json_agg_finalfn);

        CREATE OR REPLACE FUNCTION pg_catalog.json_objectagg_mysql_transfn (
            internal, "any", "any"
        ) RETURNS internal LANGUAGE C as '$libdir/dolphin', 'json_objectagg_mysql_transfn';

        CREATE OR REPLACE FUNCTION pg_catalog.json_objectagg_finalfn(
            internal
        ) RETURNS json LANGUAGE C as '$libdir/dolphin', 'json_objectagg_finalfn';

        create aggregate pg_catalog.json_objectagg("any", "any") (SFUNC = json_objectagg_mysql_transfn, STYPE = internal, finalfunc = json_objectagg_finalfn);

        CREATE OR REPLACE FUNCTION pg_catalog.json_valid("any") RETURNS boolean LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_valid';

        CREATE OR REPLACE FUNCTION pg_catalog.json_storage_size("any") RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_storage_size';

        CREATE OR REPLACE FUNCTION pg_catalog.json_pretty("any") RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_pretty';

        CREATE OR REPLACE FUNCTION pg_catalog.json_type("any") RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_type';

        DROP CAST IF EXISTS(UINT1 AS TEXT);
        DROP CAST IF EXISTS(UINT1 AS INTERVAL);
        DROP FUNCTION IF EXISTS NUMTODAY(uint1);
        DROP FUNCTION IF EXISTS TO_TEXT(uint1);
        CREATE OR REPLACE FUNCTION pg_catalog.NUMTODAY(uint1)
        RETURNS INTERVAL
        AS $$ SELECT NUMTODSINTERVAL(uint1_numeric($1),'DAY')$$
        LANGUAGE SQL IMMUTABLE STRICT;

        CREATE OR REPLACE FUNCTION pg_catalog.TO_TEXT(UINT1)
        RETURNS TEXT
        AS $$ select CAST(uint1out($1) AS VARCHAR2)  $$
        LANGUAGE SQL  STRICT IMMUTABLE;
        CREATE CAST (UINT1 AS TEXT) WITH FUNCTION TO_TEXT(UINT1) AS IMPLICIT;
        CREATE CAST (UINT1 AS INTERVAL) WITH FUNCTION NUMTODAY(UINT1) AS IMPLICIT;

        DROP OPERATOR CLASS IF EXISTS uint1_ops USING hash;
        DROP OPERATOR CLASS IF EXISTS uint2_ops USING hash;
        DROP OPERATOR CLASS IF EXISTS uint4_ops USING hash;
        DROP OPERATOR CLASS IF EXISTS uint8_ops USING hash;
        DROP OPERATOR CLASS IF EXISTS uint_ops USING btree;
        DROP OPERATOR CLASS IF EXISTS uint2_ops USING btree;
        DROP OPERATOR CLASS IF EXISTS uint4_ops USING btree;
        DROP OPERATOR CLASS IF EXISTS uint8_ops USING btree;

        DROP OPERATOR IF EXISTS pg_catalog.=(uint1,uint1);
        CREATE OPERATOR pg_catalog.=(
        leftarg = uint1, rightarg = uint1, procedure = uint1eq,
        commutator=operator(pg_catalog.=),
        restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES
        );
        
        DROP CAST IF EXISTS (TEXT AS UINT1);
        DROP FUNCTION IF EXISTS uint1(text);
        CREATE OR REPLACE FUNCTION pg_catalog.uint1(text)
        RETURNS uint1
        LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_uint1';
        CREATE CAST (TEXT AS UINT1) WITH FUNCTION UINT1(TEXT) AS IMPLICIT;
        
        DROP OPERATOR IF EXISTS pg_catalog.=(int1,uint1);
        CREATE OPERATOR pg_catalog.=(
        leftarg = int1, rightarg = uint1, procedure = int1_uint1_eq,
        commutator=operator(pg_catalog.=),
        restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES
        );
        
        DROP CAST IF EXISTS(uint2 AS INTERVAL);
        DROP CAST IF EXISTS(uint2 AS TEXT);
        DROP FUNCTION IF EXISTS NUMTODAY(uint2);
        DROP FUNCTION IF EXISTS TO_TEXT(uint2);
        CREATE OR REPLACE FUNCTION pg_catalog.NUMTODAY(uint2)
        RETURNS INTERVAL
        AS $$ SELECT NUMTODSINTERVAL(uint2_numeric($1),'DAY')$$
        LANGUAGE SQL IMMUTABLE STRICT;

        CREATE OR REPLACE FUNCTION pg_catalog.TO_TEXT(uint2)
        RETURNS TEXT
        AS $$ select CAST(uint2out($1) AS VARCHAR2)  $$
        LANGUAGE SQL  STRICT IMMUTABLE;
        CREATE CAST (uint2 AS TEXT) WITH FUNCTION TO_TEXT(uint2) AS IMPLICIT;
        CREATE CAST (uint2 AS INTERVAL) WITH FUNCTION NUMTODAY(uint2) AS IMPLICIT;

        DROP OPERATOR IF EXISTS pg_catalog.=(uint2,uint2);
        CREATE OPERATOR pg_catalog.=(
        leftarg = uint2, rightarg = uint2, procedure = uint2eq,
        commutator=operator(pg_catalog.=),
        restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES
        );
        
        DROP CAST IF EXISTS (TEXT AS uint2);
        DROP FUNCTION IF EXISTS uint2(text);
        CREATE OR REPLACE FUNCTION pg_catalog.uint2(text)
        RETURNS uint2
        LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_uint2';
        CREATE CAST (TEXT AS uint2) WITH FUNCTION uint2(TEXT) AS IMPLICIT;

        DROP OPERATOR IF EXISTS pg_catalog.=(int2,uint2);
        CREATE OPERATOR pg_catalog.=(
        leftarg = int2, rightarg = uint2, procedure = int2_uint2_eq,
        commutator=operator(pg_catalog.=),
        restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES
        );
        
        DROP CAST IF EXISTS(uint4 AS TEXT);
        DROP CAST IF EXISTS(uint4 AS INTERVAL);
        DROP FUNCTION IF EXISTS NUMTODAY(uint4);
        DROP FUNCTION IF EXISTS TO_TEXT(uint4);
        CREATE OR REPLACE FUNCTION pg_catalog.NUMTODAY(uint4)
        RETURNS INTERVAL
        AS $$ SELECT NUMTODSINTERVAL(uint4_numeric($1),'DAY')$$
        LANGUAGE SQL IMMUTABLE STRICT;
        CREATE OR REPLACE FUNCTION pg_catalog.TO_TEXT(uint4)
        RETURNS TEXT
        AS $$ select CAST(uint4out($1) AS VARCHAR2)  $$
        LANGUAGE SQL  STRICT IMMUTABLE;
        CREATE CAST (uint4 AS TEXT) WITH FUNCTION TO_TEXT(uint4) AS IMPLICIT;
        CREATE CAST (uint4 AS INTERVAL) WITH FUNCTION NUMTODAY(uint4) AS IMPLICIT;
        
        DROP OPERATOR IF EXISTS pg_catalog.=(uint4,uint4);
        CREATE OPERATOR pg_catalog.=(
        leftarg = uint4, rightarg = uint4, procedure = uint4eq,
        commutator=operator(pg_catalog.=),
        restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES
        );
        
        DROP CAST IF EXISTS (TEXT AS uint4);
        DROP FUNCTION IF EXISTS uint4(text);
        CREATE OR REPLACE FUNCTION pg_catalog.uint4(text)
        RETURNS uint4
        LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_uint4';
        CREATE CAST (TEXT AS uint4) WITH FUNCTION uint4(TEXT) AS IMPLICIT;

        DROP OPERATOR IF EXISTS pg_catalog.=(int4,uint4);
        CREATE OPERATOR pg_catalog.=(
        leftarg = int4, rightarg = uint4, procedure = int4_uint4_eq,
        commutator=operator(pg_catalog.=),
        restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES
        );
        
        DROP CAST IF EXISTS (uint8 AS TEXT);
        DROP FUNCTION IF EXISTS TO_TEXT(uint8);
        CREATE OR REPLACE FUNCTION pg_catalog.TO_TEXT(uint8)
        RETURNS TEXT
        AS $$ select CAST(uint8out($1) AS VARCHAR2)  $$
        LANGUAGE SQL  STRICT IMMUTABLE;
        CREATE CAST (uint8 AS TEXT) WITH FUNCTION TO_TEXT(uint8) AS IMPLICIT;

        
        DROP OPERATOR IF EXISTS pg_catalog.=(uint8,uint8);
        CREATE OPERATOR pg_catalog.=(
        leftarg = uint8, rightarg = uint8, procedure = uint8eq,
        commutator=operator(pg_catalog.=),
        restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES
        );
        
        DROP CAST IF EXISTS (TEXT AS uint8);
        DROP FUNCTION IF EXISTS uint8(text);
        CREATE OR REPLACE FUNCTION pg_catalog.uint8(text)
        RETURNS uint8
        LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_uint8';
        CREATE CAST (TEXT AS uint8) WITH FUNCTION uint8(TEXT) AS IMPLICIT;
        
        DROP OPERATOR IF EXISTS pg_catalog.=(int8,uint8);
        CREATE OPERATOR pg_catalog.=(
        leftarg = int8, rightarg = uint8, procedure = int8_uint8_eq,
        commutator=operator(pg_catalog.=),
        restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES
        );
        
        DROP FUNCTION IF EXISTS pg_catalog.uint8_uint4_eq(uint8,uint4);
        CREATE OR REPLACE FUNCTION pg_catalog.uint8_uint4_eq (
        uint8,uint4
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_uint4_eq';

        DROP OPERATOR IF EXISTS pg_catalog.=(uint4,uint8);
        CREATE OPERATOR pg_catalog.=(
        leftarg = uint4, rightarg = uint8, procedure = uint4_uint8_eq,
        restrict = eqsel, join = eqjoinsel,
        commutator=operator(pg_catalog.=),
        HASHES, MERGES
        );
        
        CREATE OPERATOR pg_catalog.=(
        leftarg = uint8, rightarg = uint4, procedure = uint8_uint4_eq,
        restrict = eqsel, join = eqjoinsel,
        commutator=operator(pg_catalog.=),
        HASHES, MERGES
        );
        COMMENT ON OPERATOR pg_catalog.=(uint8, uint4) IS 'uint8_uint4_eq';

        CREATE OPERATOR CLASS uint_ops
            DEFAULT FOR TYPE uint1 USING btree family integer_ops AS
                OPERATOR        1       < ,
                OPERATOR        1       <(uint1, uint2),
                OPERATOR        1       <(uint1, uint4),
                OPERATOR        1       <(uint1, uint8),
                OPERATOR        1       <(uint1, int1),
                OPERATOR        1       <(uint1, int2),
                OPERATOR        1       <(uint1, int4),
                OPERATOR        1       <(uint1, int8),
                OPERATOR        2       <= ,
                OPERATOR        2       <=(uint1, uint2),
                OPERATOR        2       <=(uint1, uint4),
                OPERATOR        2       <=(uint1, uint8),
                OPERATOR        2       <=(uint1, int1),
                OPERATOR        2       <=(uint1, int2),
                OPERATOR        2       <=(uint1, int4),
                OPERATOR        2       <=(uint1, int8),
                OPERATOR        3       = ,
                OPERATOR        3       =(uint1, uint2),
                OPERATOR        3       =(uint1, uint4),
                OPERATOR        3       =(uint1, uint8),
                OPERATOR        3       =(uint1, int1),
                OPERATOR        3       =(uint1, int2),
                OPERATOR        3       =(uint1, int4),
                OPERATOR        3       =(uint1, int8),
                OPERATOR        4       >= ,
                OPERATOR        4       >=(uint1, uint2),
                OPERATOR        4       >=(uint1, uint4),
                OPERATOR        4       >=(uint1, uint8),
                OPERATOR        4       >=(uint1, int1),
                OPERATOR        4       >=(uint1, int2),
                OPERATOR        4       >=(uint1, int4),
                OPERATOR        4       >=(uint1, int8),
                OPERATOR        5       > ,
                OPERATOR        5       >(uint1, uint2),
                OPERATOR        5       >(uint1, uint4),
                OPERATOR        5       >(uint1, uint8),
                OPERATOR        5       >(uint1, int1),
                OPERATOR        5       >(uint1, int2),
                OPERATOR        5       >(uint1, int4),
                OPERATOR        5       >(uint1, int8),
                FUNCTION        1       uint1cmp(uint1, uint1),
                FUNCTION        1       uint12cmp(uint1, uint2),
                FUNCTION        1       uint14cmp(uint1, uint4),
                FUNCTION        1       uint18cmp(uint1, uint8),
                FUNCTION        1       uint1_int1cmp(uint1, int1),
                FUNCTION        1       uint1_int2cmp(uint1, int2),
                FUNCTION        1       uint1_int4cmp(uint1, int4),
                FUNCTION        1       uint1_int8cmp(uint1, int8),
                FUNCTION        2       uint1_sortsupport(internal);

        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);

        CREATE OPERATOR CLASS uint8_ops
            DEFAULT FOR TYPE uint8 USING btree family integer_ops AS
                OPERATOR        1       < ,
                OPERATOR        1       <(uint8, int8),
                OPERATOR        2       <= ,
                OPERATOR        2       <=(uint8, int8),
                OPERATOR        3       = ,
                OPERATOR        3       =(uint8, int8),
                OPERATOR        4       >= ,
                OPERATOR        4       >=(uint8, int8),
                OPERATOR        5       > ,
                OPERATOR        5       >(uint8, int8),
                FUNCTION        1       uint8cmp(uint8, uint8),
                FUNCTION        1       uint8_int8cmp(uint8, int8),
                FUNCTION        2       uint8_sortsupport(internal);

        CREATE OPERATOR CLASS uint1_ops
            DEFAULT FOR TYPE uint1 USING hash family integer_ops AS
                OPERATOR        1       = ,
                OPERATOR        1       =(uint1, uint2),
                OPERATOR        1       =(uint1, uint4),
                OPERATOR        1       =(uint1, uint8),
                OPERATOR        1       =(uint1, int1),
                OPERATOR        1       =(uint1, int2),
                OPERATOR        1       =(uint1, int4),
                OPERATOR        1       =(uint1, int8),
                OPERATOR        1       =(int1, uint1),
                FUNCTION        1       hashint1(int1),
                FUNCTION        1       hashuint1(uint1);

        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 uint8_ops
            DEFAULT FOR TYPE uint8 USING hash family integer_ops AS
                OPERATOR        1       = ,
                OPERATOR        1       =(uint8, int8),
                OPERATOR        1       =(int8, uint8),
                OPERATOR        1       =(uint8, uint4),
                FUNCTION        1       hashuint8(uint8);

        DROP FUNCTION IF EXISTS pg_catalog.i1_cast_ui1(int1);
        CREATE OR REPLACE FUNCTION pg_catalog.i1_cast_ui1 (
        int1
        ) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1_cast_ui1';
        DROP FUNCTION IF EXISTS pg_catalog.i1_cast_ui2(int1);
        CREATE OR REPLACE FUNCTION pg_catalog.i1_cast_ui2 (
        int1
        ) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1_cast_ui2';
        DROP FUNCTION IF EXISTS pg_catalog.i1_cast_ui4(int1);
        CREATE OR REPLACE FUNCTION pg_catalog.i1_cast_ui4 (
        int1
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1_cast_ui4';
        DROP FUNCTION IF EXISTS pg_catalog.i1_cast_ui8(int1);
        CREATE OR REPLACE FUNCTION pg_catalog.i1_cast_ui8 (
        int1
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1_cast_ui8';

        drop CAST IF EXISTS (uint4 AS timestamp(0) without time zone);
        drop CAST IF EXISTS (uint4 AS datetime);
        DROP FUNCTION IF EXISTS pg_catalog.int32_b_format_datetime(uint4);
        CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_datetime (
        uint4
        ) RETURNS timestamp(0) without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int32_b_format_datetime';
        CREATE CAST (uint4 AS timestamp(0) without time zone) WITH FUNCTION int32_b_format_datetime(uint4);

        drop CAST IF EXISTS (uint8 AS timestamp(0) without time zone);
        drop CAST IF EXISTS (uint8 AS datetime);
        DROP FUNCTION IF EXISTS pg_catalog.int64_b_format_datetime(uint8);
        CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_datetime (
        uint8
        ) RETURNS timestamp(0) without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int64_b_format_datetime';
        CREATE CAST (uint8 AS timestamp(0) without time zone) WITH FUNCTION int64_b_format_datetime(uint8);

        DROP FUNCTION IF EXISTS pg_catalog.year_uint8("year");
        CREATE OR REPLACE FUNCTION pg_catalog.year_uint8("year") RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_uint8';
        drop CAST IF EXISTS (year AS uint8);
        CREATE CAST ("year" as uint8) with function pg_catalog.year_uint8("year");

        drop CAST IF EXISTS (bit AS uint4);
        drop CAST IF EXISTS (bit AS uint8);
        CREATE CAST (bit AS uint4) WITH FUNCTION bittouint4(bit) AS IMPLICIT;
        CREATE CAST (bit AS uint8) WITH FUNCTION bittouint8(bit) AS IMPLICIT;
        
        DROP FUNCTION IF EXISTS pg_catalog.uint2_xor_bool(uint2, boolean);
        CREATE OR REPLACE FUNCTION pg_catalog.uint2_xor_bool (
        uint2, boolean
        ) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_xor_bool';

        DROP FUNCTION IF EXISTS pg_catalog.uint1_xor_bool(uint1, boolean);
        CREATE OR REPLACE FUNCTION pg_catalog.uint1_xor_bool (
        uint1, boolean
        ) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_xor_bool';

        DROP FUNCTION IF EXISTS pg_catalog.uint4_xor_bool(uint4, boolean);
        CREATE OR REPLACE FUNCTION pg_catalog.uint4_xor_bool (
        uint4, boolean
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_xor_bool';

        DROP FUNCTION IF EXISTS pg_catalog.uint8_xor_bool(uint8, boolean);
        CREATE OR REPLACE FUNCTION pg_catalog.uint8_xor_bool (
        uint8, boolean
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_xor_bool';

        DROP FUNCTION IF EXISTS pg_catalog.bool_xor_uint1(boolean, uint1);
        CREATE OR REPLACE FUNCTION pg_catalog.bool_xor_uint1 (
        boolean, uint1
        ) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bool_xor_uint1';

        DROP FUNCTION IF EXISTS pg_catalog.bool_xor_uint2(boolean, uint2);
        CREATE OR REPLACE FUNCTION pg_catalog.bool_xor_uint2 (
        boolean, uint2
        ) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bool_xor_uint2';

        DROP FUNCTION IF EXISTS pg_catalog.bool_xor_uint4(boolean, uint4);
        CREATE OR REPLACE FUNCTION pg_catalog.bool_xor_uint4 (
        boolean, uint4
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bool_xor_uint4';

        DROP FUNCTION IF EXISTS pg_catalog.bool_xor_uint8(boolean, uint8);
        CREATE OR REPLACE FUNCTION pg_catalog.bool_xor_uint8 (
        boolean, uint8
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bool_xor_uint8';

        CREATE OPERATOR pg_catalog.^(
        leftarg = uint8, rightarg = boolean, procedure = uint8_xor_bool,
        commutator=operator(pg_catalog.^)
        );
        COMMENT ON OPERATOR pg_catalog.^(uint8, boolean) IS 'uint8_xor_bool';
        CREATE OPERATOR pg_catalog.^(
        leftarg = uint4, rightarg = boolean, procedure = uint4_xor_bool,
        commutator=operator(pg_catalog.^)
        );
        COMMENT ON OPERATOR pg_catalog.^(uint4, boolean) IS 'uint4_xor_bool';
        CREATE OPERATOR pg_catalog.^(
        leftarg = uint2, rightarg = boolean, procedure = uint2_xor_bool,
        commutator=operator(pg_catalog.^)
        );
        COMMENT ON OPERATOR pg_catalog.^(uint2, boolean) IS 'uint2_xor_bool';
        CREATE OPERATOR pg_catalog.^(
        leftarg = uint1, rightarg = boolean, procedure = uint1_xor_bool,
        commutator=operator(pg_catalog.^)
        );
        COMMENT ON OPERATOR pg_catalog.^(uint1, boolean) IS 'uint1_xor_bool';
        CREATE OPERATOR pg_catalog.^(
        leftarg = boolean, rightarg = uint1, procedure = bool_xor_uint1,
        commutator=operator(pg_catalog.^)
        );
        COMMENT ON OPERATOR pg_catalog.^(boolean, uint1) IS 'bool_xor_uint1';
        CREATE OPERATOR pg_catalog.^(
        leftarg = boolean, rightarg = uint2, procedure = bool_xor_uint2,
        commutator=operator(pg_catalog.^)
        );
        COMMENT ON OPERATOR pg_catalog.^(boolean, uint2) IS 'bool_xor_uint2';
        CREATE OPERATOR pg_catalog.^(
        leftarg = boolean, rightarg = uint4, procedure = bool_xor_uint4,
        commutator=operator(pg_catalog.^)
        );
        COMMENT ON OPERATOR pg_catalog.^(boolean, uint4) IS 'bool_xor_uint4';
        CREATE OPERATOR pg_catalog.^(
        leftarg = boolean, rightarg = uint8, procedure = bool_xor_uint8,
        commutator=operator(pg_catalog.^)
        );
        COMMENT ON OPERATOR pg_catalog.^(boolean, uint8) IS 'bool_xor_uint8';

        DROP FUNCTION IF EXISTS pg_catalog.timestamp_uint8(timestamp(0) with time zone);
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_uint8(timestamp(0) with time zone)
        RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamp_uint8';
        drop CAST IF EXISTS (timestamp(0) with time zone AS uint8);
        CREATE CAST (timestamp(0) with time zone AS uint8) WITH FUNCTION timestamp_uint8(timestamp(0) with time zone);

        DROP FUNCTION IF EXISTS pg_catalog.cash_uint(money);
        CREATE OR REPLACE FUNCTION pg_catalog.cash_uint(money)
        RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'cash_uint';
        drop CAST IF EXISTS (money AS uint8);
        CREATE CAST (money AS uint8) WITH FUNCTION cash_uint(money) AS ASSIGNMENT;

        drop aggregate if exists pg_catalog.bit_xor(text);
        drop aggregate if exists pg_catalog.any_value(uint8);
        drop aggregate if exists pg_catalog.bit_xor(int8);
        drop aggregate if exists pg_catalog.bit_xor(varbit);

        DROP FUNCTION IF EXISTS pg_catalog.int8_xor(uint8,int8);
        CREATE OR REPLACE FUNCTION pg_catalog.int8_xor (
        uint8,int8
        ) RETURNS uint8 LANGUAGE C as '$libdir/dolphin',  'uint8_xor_int8';
        create aggregate pg_catalog.bit_xor(int8) (SFUNC=int8_xor, STYPE= uint8);

        DROP FUNCTION IF EXISTS pg_catalog.uint8_xor(uint8,int8);
        CREATE OR REPLACE FUNCTION pg_catalog.uint8_xor (
        uint8,int8
        ) RETURNS uint8 LANGUAGE C as '$libdir/dolphin',  'uint8xor';

        drop aggregate if exists pg_catalog.bit_xor(text);
        DROP FUNCTION IF EXISTS pg_catalog.text_xor(uint8,text);
        CREATE OR REPLACE FUNCTION pg_catalog.text_xor (t1 uint8,t2 text) RETURNS uint8 AS
        $$
        DECLARE num NUMBER := to_number(t2);
        BEGIN
            IF num > 9223372036854775807 then
                num = 9223372036854775807;
            ELSEIF num < -9223372036854775808 then
                num = 9223372036854775808;
            END IF;
            RETURN (SELECT uint8_xor(t1, num));
        END;
        $$
        LANGUAGE plpgsql;
        create aggregate pg_catalog.bit_xor(text) (SFUNC=text_xor, STYPE= uint8);

        DROP FUNCTION IF EXISTS pg_catalog.uint_any_value (uint8, uint8);
        CREATE OR REPLACE FUNCTION pg_catalog.uint_any_value (uint8, uint8) RETURNS uint8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint_any_value';
        CREATE AGGREGATE pg_catalog.any_value(uint8) (
                sfunc = uint_any_value,
                stype = uint8
        );

        DROP FUNCTION IF EXISTS pg_catalog.bit_count(numeric) ;
        CREATE OR REPLACE FUNCTION pg_catalog.bit_count (numeric)  RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_numeric';
        DROP FUNCTION IF EXISTS pg_catalog.bit_count(text) ;
        CREATE OR REPLACE FUNCTION pg_catalog.bit_count (text)  RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_text';
        DROP FUNCTION IF EXISTS pg_catalog.bit_count_bit(text) ;
        CREATE OR REPLACE FUNCTION pg_catalog.bit_count_bit (text) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_bit';
        DROP FUNCTION IF EXISTS pg_catalog.bit_count(bit) ;
        CREATE OR REPLACE FUNCTION pg_catalog.bit_count (bit) RETURNS int8 AS $$ SELECT pg_catalog.bit_count_bit(cast($1 as text)) $$ LANGUAGE SQL;

        -- support bit_xor aggregate for varbit

        DROP FUNCTION IF EXISTS pg_catalog.varbit_bit_xor_transfn(varbit, varbit) ;
        CREATE FUNCTION pg_catalog.varbit_bit_xor_transfn (
        t1 varbit ,t2 varbit
        ) RETURNS varbit AS
        $$
        BEGIN
            IF t1 is null THEN
                RETURN t2;
            ELSEIF t2 is null THEN
                RETURN t1;
            ELSE
                RETURN (SELECT bitxor(t1, t2));
            END IF;
        END;
        $$
        LANGUAGE plpgsql;

        DROP FUNCTION IF EXISTS pg_catalog.varbit_bit_xor_finalfn(varbit) ;
        CREATE FUNCTION pg_catalog.varbit_bit_xor_finalfn (
        t varbit
        ) RETURNS int8 AS
        $$
        BEGIN
            IF t is null THEN
                RETURN 0;
            ELSE
                RETURN (SELECT int8(t));
            END IF;
        END;
        $$
        LANGUAGE plpgsql;

        create aggregate pg_catalog.bit_xor(varbit) (SFUNC=varbit_bit_xor_transfn, finalfunc = varbit_bit_xor_finalfn ,STYPE= varbit);

        DROP FUNCTION IF EXISTS pg_catalog.connection_id();

        CREATE OR REPLACE FUNCTION pg_catalog.connection_id()
        RETURNS int8 AS
        $$
        BEGIN
            RETURN (select pg_backend_pid());
        END;
        $$
        LANGUAGE plpgsql;

        DROP FUNCTION IF EXISTS pg_catalog.set_native_password(text, text);
        CREATE OR REPLACE FUNCTION pg_catalog.set_native_password(text, text) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'set_native_password';
        create or replace function pg_catalog.b_plpgsql_call_handler() returns language_handler language C volatile as '$libdir/dolphin', 'b_plpgsql_call_handler';
        create or replace function pg_catalog.b_plpgsql_inline_handler(internal) returns void language C strict volatile as '$libdir/dolphin', 'b_plpgsql_inline_handler';
        create or replace function pg_catalog.b_plpgsql_validator(oid) returns void language C strict volatile as '$libdir/dolphin', 'b_plpgsql_validator';

        DROP FUNCTION IF EXISTS pg_catalog.enum2float8(anyenum);
        CREATE OR REPLACE FUNCTION pg_catalog.enum2float8(anyenum) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'Enum2Float8';

        INSERT INTO pg_catalog.pg_cast
        -- castsource is anyenum(3500), casttarget(701) is float8, castowner is 10(superuser)
        SELECT 3500, 701, oid, 'i', 'f', 10
        FROM pg_proc WHERE 
        proname = 'enum2float8' AND
        -- namespace is pg_catalog
        pronamespace = 11 AND
        -- input arg is anyenum
        proargtypes='3500' AND
        -- return type is float8
        prorettype = 701;

        DROP FUNCTION IF EXISTS pg_catalog.enumtextlt(anyenum, text); 
        CREATE FUNCTION pg_catalog.enumtextlt ( 
        anyenum, text 
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtextlt';
        DROP FUNCTION IF EXISTS pg_catalog.enumtextle(anyenum, text); 
        CREATE FUNCTION pg_catalog.enumtextle ( 
        anyenum, text 
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtextle';
        DROP FUNCTION IF EXISTS pg_catalog.enumtextne(anyenum, text); 
        CREATE FUNCTION pg_catalog.enumtextne ( 
        anyenum, text 
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtextne';
        DROP FUNCTION IF EXISTS pg_catalog.enumtexteq(anyenum, text); 
        CREATE FUNCTION pg_catalog.enumtexteq ( 
        anyenum, text 
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtexteq';
        DROP FUNCTION IF EXISTS pg_catalog.enumtextgt(anyenum, text); 
        CREATE FUNCTION pg_catalog.enumtextgt ( 
        anyenum, text 
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtextgt';
        DROP FUNCTION IF EXISTS pg_catalog.enumtextge(anyenum, text); 
        CREATE FUNCTION pg_catalog.enumtextge ( 
        anyenum, text 
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'enumtextge';
        DROP FUNCTION IF EXISTS pg_catalog.textenumlt(text, anyenum); 
        CREATE FUNCTION pg_catalog.textenumlt ( 
        text, anyenum 
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textenumlt';
        DROP FUNCTION IF EXISTS pg_catalog.textenumle(text, anyenum); 
        CREATE FUNCTION pg_catalog.textenumle ( 
        text, anyenum 
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textenumle';
        DROP FUNCTION IF EXISTS pg_catalog.textenumne(text, anyenum); 
        CREATE FUNCTION pg_catalog.textenumne ( 
        text, anyenum 
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textenumne';
        DROP FUNCTION IF EXISTS pg_catalog.textenumeq(text, anyenum); 
        CREATE FUNCTION pg_catalog.textenumeq ( 
        text, anyenum 
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textenumeq';
        DROP FUNCTION IF EXISTS pg_catalog.textenumgt(text, anyenum); 
        CREATE FUNCTION pg_catalog.textenumgt ( 
        text, anyenum 
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textenumgt';
        DROP FUNCTION IF EXISTS pg_catalog.textenumge(text, anyenum); 
        CREATE FUNCTION pg_catalog.textenumge ( 
        text, anyenum 
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'textenumge';

        CREATE OPERATOR pg_catalog.=( 
         PROCEDURE = enumtexteq, LEFTARG = anyenum, RIGHTARG = text, COMMUTATOR = OPERATOR(pg_catalog.=), NEGATOR = OPERATOR(pg_catalog.<>), RESTRICT = eqsel, JOIN = eqjoinsel, HASHES
        );

        CREATE OPERATOR pg_catalog.<>( 
         PROCEDURE = enumtextne, LEFTARG = anyenum, RIGHTARG = text, COMMUTATOR = OPERATOR(pg_catalog.<>), NEGATOR = OPERATOR(pg_catalog.=), RESTRICT = neqsel, JOIN = neqjoinsel
        );

        CREATE OPERATOR pg_catalog.<( 
         PROCEDURE = enumtextlt, LEFTARG = anyenum, RIGHTARG = text, COMMUTATOR = OPERATOR(pg_catalog.>), NEGATOR = OPERATOR(pg_catalog.>=), RESTRICT = scalarltsel, JOIN = scalarltjoinsel
        );

        CREATE OPERATOR pg_catalog.>( 
         PROCEDURE = enumtextgt, LEFTARG = anyenum, RIGHTARG = text, COMMUTATOR = OPERATOR(pg_catalog.<), NEGATOR = OPERATOR(pg_catalog.<=), RESTRICT = scalargtsel, JOIN = scalargtjoinsel
        );

        CREATE OPERATOR pg_catalog.<=( 
         PROCEDURE = enumtextle, LEFTARG = anyenum, RIGHTARG = text, COMMUTATOR = OPERATOR(pg_catalog.>=), NEGATOR = OPERATOR(pg_catalog.>), RESTRICT = scalarltsel, JOIN = scalarltjoinsel
        );

        CREATE OPERATOR pg_catalog.>=( 
         PROCEDURE = enumtextge, LEFTARG = anyenum, RIGHTARG = text, COMMUTATOR = OPERATOR(pg_catalog.<=), NEGATOR = OPERATOR(pg_catalog.<), RESTRICT = scalargtsel, JOIN = scalargtjoinsel
        );

        CREATE OPERATOR pg_catalog.=( 
         PROCEDURE = textenumeq, LEFTARG = text, RIGHTARG = anyenum, COMMUTATOR = OPERATOR(pg_catalog.=), NEGATOR = OPERATOR(pg_catalog.<>), RESTRICT = eqsel, JOIN = eqjoinsel, HASHES
        );

        CREATE OPERATOR pg_catalog.<>( 
         PROCEDURE = textenumne, LEFTARG = text, RIGHTARG = anyenum, COMMUTATOR = OPERATOR(pg_catalog.<>), NEGATOR = OPERATOR(pg_catalog.=), RESTRICT = neqsel, JOIN = neqjoinsel
        );

        CREATE OPERATOR pg_catalog.<( 
         PROCEDURE = textenumlt, LEFTARG = text, RIGHTARG = anyenum, COMMUTATOR = OPERATOR(pg_catalog.>), NEGATOR = OPERATOR(pg_catalog.>=), RESTRICT = scalarltsel, JOIN = scalarltjoinsel
        );

        CREATE OPERATOR pg_catalog.>( 
         PROCEDURE = textenumgt, LEFTARG = text, RIGHTARG = anyenum, COMMUTATOR = OPERATOR(pg_catalog.<), NEGATOR = OPERATOR(pg_catalog.<=), RESTRICT = scalargtsel, JOIN = scalargtjoinsel
        );

        CREATE OPERATOR pg_catalog.<=( 
         PROCEDURE = textenumle, LEFTARG = text, RIGHTARG = anyenum, COMMUTATOR = OPERATOR(pg_catalog.>=), NEGATOR = OPERATOR(pg_catalog.>), RESTRICT = scalarltsel, JOIN = scalarltjoinsel
        );

        CREATE OPERATOR pg_catalog.>=( 
         PROCEDURE = textenumge, LEFTARG = text, RIGHTARG = anyenum, COMMUTATOR = OPERATOR(pg_catalog.<=), NEGATOR = OPERATOR(pg_catalog.<), RESTRICT = scalargtsel, JOIN = scalargtjoinsel
        );
        
        DROP FUNCTION IF EXISTS pg_catalog.from_base64 (text);
        DROP FUNCTION IF EXISTS pg_catalog.from_base64 (bool);
        DROP FUNCTION IF EXISTS pg_catalog.from_base64 (bit);
        CREATE OR REPLACE FUNCTION pg_catalog.from_base64 (text)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_decode';

        CREATE OR REPLACE FUNCTION pg_catalog.from_base64 (bool1 bool)
        RETURNS text
        AS
        $$
        BEGIN
            RETURN (SELECT from_base64(''));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OR REPLACE FUNCTION pg_catalog.from_base64(bit1 bit)
        RETURNS text
        AS
        $$
        BEGIN
            RETURN (SELECT from_base64(encode((decode(hex(bit1), 'hex')), 'escape')));
        END;
        $$
        LANGUAGE plpgsql;
        
        DROP FUNCTION IF EXISTS pg_catalog.oct(text);
        DROP FUNCTION IF EXISTS pg_catalog.oct(boolean);
        DROP FUNCTION IF EXISTS pg_catalog.oct(bit);

        CREATE OR REPLACE FUNCTION pg_catalog.oct(t1 text) RETURNS text AS
        $$
        BEGIN
            RETURN (SELECT conv(t1, 10, 8));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OR REPLACE FUNCTION pg_catalog.oct(t1 bit) RETURNS text AS
        $$
        BEGIN
            RETURN (SELECT conv(t1, 10, 8));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OR REPLACE FUNCTION pg_catalog.oct(t1 boolean) RETURNS text AS
        $$
        BEGIN
            RETURN int4(t1);
        END;
        $$
        LANGUAGE plpgsql;

        DROP FUNCTION IF EXISTS pg_catalog.schema ();

        CREATE OR REPLACE FUNCTION pg_catalog.schema ()
        RETURNS text
        AS
        $$
        BEGIN
            RETURN (SELECT CURRENT_SCHEMA());
        END;
        $$
        LANGUAGE plpgsql;
        
        CREATE OR REPLACE FUNCTION pg_catalog.show_status(is_session boolean)
        RETURNS TABLE (VARIABLE_NAME text, VALUE text) AS
        $$
        DECLARE sql_mode text;
        BEGIN
        EXECUTE IMMEDIATE 'show dolphin.sql_mode' into sql_mode;
        set dolphin.sql_mode='ansi_quotes,pipes_as_concat';
        RETURN QUERY
        select 'os_runtime_count' as variable_name , count(*)::text as value from dbe_perf.global_os_runtime
        union
        select concat(nodename, '-', memorytype) as variable_name, memorymbytes::text as value from dbe_perf.global_memory_node_detail
        union
        select unnest(array['p80', 'p95']) as variable_name, unnest(array[p80, p95]::text[]) as value from dbe_perf.statement_responsetime_percentile
        union
        select 'global_instance_time_count' as variable_name, count(*)::text as value from dbe_perf.global_instance_time
        union
        select unnest(array['node_name', 'worker_info', 'session_info', 'stream_info']) as variable_name, unnest(array[node_name, worker_info, session_info, stream_info]) as value from dbe_perf.global_threadpool_status
        union
        select unnest(array['group_id', 'bind_numa_id', 'bind_cpu_number', 'listener']) as variable_name, unnest(array[group_id, bind_numa_id, bind_cpu_number, listener]::text[]) as value from dbe_perf.global_threadpool_status
        union
        select 'os_threads_count' as variable_name,count(*)::text as value from dbe_perf.global_os_threads
        union
        select unnest(array['node_name', 'user_name']) as variable_name, unnest(array[node_name, user_name]) as value from dbe_perf.summary_user_login
        union
        select unnest(array['login_counter', 'logout_counter', 'user_id']) as variable_name, unnest(array[login_counter, logout_counter, user_id]::text[]) as value from dbe_perf.summary_user_login
        union
        select unnest(array['select_count', 'update_count', 'insert_count', 'delete_count', 'ddl_count', 'dml_count', 'dcl_count']) as variable_name, unnest(array[select_count, update_count, insert_count, delete_count, ddl_count, dml_count, dcl_count]::text[]) as value from dbe_perf.summary_workload_sql_count
        union
        select unnest(array['node_name', 'workload']) as variable_name, unnest(array[node_name, workload]::text[]) as value from dbe_perf.global_workload_transaction
        union
        select unnest(array['commit_counter', 'rollback_counter', 'resp_min', 'resp_max', 'resp_avg', 'resp_total', 'bg_commit_counter', 'bg_rollback_counter', 'bg_resp_min', 'bg_resp_max', 'bg_resp_avg', 'bg_resp_total']) as variable_name,
        unnest(array[commit_counter, rollback_counter, resp_min, resp_max, resp_avg, resp_total, bg_commit_counter, bg_rollback_counter, bg_resp_min, bg_resp_max, bg_resp_avg, bg_resp_total]::text[]) as value from dbe_perf.global_workload_transaction
        union
        select 'node_name' as variable_name, node_name::text as value from dbe_perf.global_bgwriter_stat
        union
        select 'stats_reset' as variable_name, stats_reset::text as value from dbe_perf.global_bgwriter_stat
        union
        select unnest(array['checkpoint_write_time', 'checkpoint_sync_time']) as variable_name, unnest(array[checkpoint_write_time, checkpoint_sync_time]::text[]) as value from dbe_perf.global_bgwriter_stat
        union
        select unnest(array['checkpoints_timed', 'checkpoints_req', 'buffers_checkpoint', 'buffers_clean', 'maxwritten_clean', 'buffers_backend', 'buffers_backend_fsync', 'buffers_alloc']) as variable_name, unnest(array[checkpoints_timed, checkpoints_req, buffers_checkpoint, buffers_clean, maxwritten_clean, buffers_backend, buffers_backend_fsync, buffers_alloc]::text[]) as value from dbe_perf.global_bgwriter_stat
        union
        select unnest(array['phyrds', 'phywrts', 'phyblkrd', 'phyblkwrt']) as variable_name, unnest(array[phyrds, phywrts, phyblkrd, phyblkwrt]::text[]) as value from dbe_perf.summary_rel_iostat
        union
        select 'summary_file_iostat_count' as variable_name, count(*)::text as value from dbe_perf.summary_file_iostat
        union
        select unnest(array['phywrts', 'phyblkwrt', 'writetim', 'avgiotim', 'lstiotim', 'miniotim', 'maxiowtm']) as variable_name, unnest(array[phywrts, phyblkwrt, writetim, avgiotim, lstiotim, miniotim, maxiowtm]::text[]) as value from dbe_perf.summary_file_redo_iostat
        union
        select unnest(array['node_name', 'worker_info']) as variable_name, unnest(array[node_name, worker_info]::text[]) as value from dbe_perf.global_redo_status union select unnest(array['redo_start_ptr', 'redo_start_time', 'redo_done_time', 'curr_time', 'min_recovery_point', 'read_ptr', 'last_replayed_read_ptr', 'recovery_done_ptr', 'read_xlog_io_counter', 'read_xlog_io_total_dur', 'read_data_io_counter', 'read_data_io_total_dur', 'write_data_io_counter', 'write_data_io_total_dur', 'process_pending_counter', 'process_pending_total_dur', 'apply_counter', 'apply_total_dur', 'speed', 'local_max_ptr', 'primary_flush_ptr']) as variable_name, unnest(array[redo_start_ptr, redo_start_time, redo_done_time, curr_time, min_recovery_point, read_ptr, last_replayed_read_ptr, recovery_done_ptr, read_xlog_io_counter, read_xlog_io_total_dur, read_data_io_counter, read_data_io_total_dur, write_data_io_counter, write_data_io_total_dur, process_pending_counter, process_pending_total_dur, apply_counter, apply_total_dur, speed, local_max_ptr, primary_flush_ptr]::text[]) as value from dbe_perf.global_redo_status
        union
        select unnest(array['node_name', 'ckpt_redo_point']) as variable_name, unnest(array[node_name, ckpt_redo_point]::text[]) as value from dbe_perf.global_ckpt_status union select unnest(array['ckpt_clog_flush_num', 'ckpt_csnlog_flush_num', 'ckpt_multixact_flush_num', 'ckpt_predicate_flush_num', 'ckpt_twophase_flush_num']) as variable_name, unnest(array[ckpt_clog_flush_num, ckpt_csnlog_flush_num, ckpt_multixact_flush_num, ckpt_predicate_flush_num, ckpt_twophase_flush_num]::text[]) as value from dbe_perf.global_ckpt_status
        union
        select unnest(array['databaseid', 'tablespaceid', 'relfilenode']) as variable_name, unnest(array[databaseid, tablespaceid, relfilenode]::text[]) as value from dbe_perf.summary_stat_bad_block
        union
        select unnest(array['forknum', 'error_count']) as variable_name, unnest(array[forknum, error_count]::text[]) as value from dbe_perf.summary_stat_bad_block
        union
        select unnest(array['first_time', 'last_time']) as variable_name, unnest(array[first_time, last_time]::text[]) as value from dbe_perf.summary_stat_bad_block
        union
        select unnest(array['node_name', 'queue_head_page_rec_lsn', 'queue_rec_lsn', 'current_xlog_insert_lsn', 'ckpt_redo_point']) as variable_name, unnest(array[node_name, queue_head_page_rec_lsn, queue_rec_lsn, current_xlog_insert_lsn, ckpt_redo_point]) as value from dbe_perf.global_pagewriter_status
        union
        select unnest(array['pgwr_actual_flush_total_num', 'pgwr_last_flush_num', 'remain_dirty_page_num']) as variable_name, unnest(array[pgwr_actual_flush_total_num, pgwr_last_flush_num, remain_dirty_page_num]::text[]) as value from dbe_perf.global_pagewriter_status
        union
        select unnest(array['confl_tablespace', 'confl_lock', 'confl_snapshot', 'confl_bufferpin', 'confl_deadlock']) as variable_name, unnest(array[confl_tablespace, confl_lock, confl_snapshot, confl_bufferpin, confl_deadlock]::text[]) as value from dbe_perf.summary_stat_database_conflicts where datname = current_database()
        union
        select 'wait_events_count' as variable_name, count(*)::text as value from dbe_perf.global_wait_events
        union
        select 'locks_count' as variable_name,count(*)::text as value from pg_locks where database in (select oid from pg_database where datname = current_database())
        union
        select 'datname' as variable_name, datname::text as value from pg_stat_database where datname = current_database()
        union
        select unnest(array['numbackends', 'xact_commit', 'xact_rollback', 'blks_read', 'blks_hit', 'tup_returned', 'tup_fetched', 'tup_inserted', 'tup_updated', 'tup_deleted', 'conflicts', 'temp_files', 'temp_bytes', 'deadlocks', 'datid']) as variable_name, unnest(array[numbackends, xact_commit, xact_rollback, blks_read, blks_hit, tup_returned, tup_fetched, tup_inserted, tup_updated, tup_deleted, conflicts, temp_files, temp_bytes, deadlocks, datid]::text[]) as value from pg_stat_database where datname = current_database()
        union
        select unnest(array['blk_read_time', 'blk_write_time']) as variable_name, unnest(array[blk_read_time, blk_write_time]::text[]) as value from pg_stat_database where datname = current_database()
        union
        select 'stats_reset' as variable_name, stats_reset::text as value from pg_stat_database where datname = current_database()
        union
        select unnest(array['curr_dwn', 'curr_start_page', 'file_trunc_num', 'file_reset_num', 'total_writes', 'low_threshold_writes', 'high_threshold_writes', 'total_pages', 'low_threshold_pages', 'high_threshold_pages', 'file_id']) as variable_name, unnest(array[curr_dwn, curr_start_page, file_trunc_num, file_reset_num, total_writes, low_threshold_writes, high_threshold_writes, total_pages, low_threshold_pages, high_threshold_pages, file_id]::text[]) as value from dbe_perf.global_double_write_status
        union
        select unnest(array['active', 'dummy_standby']) as variable_name, unnest(array[active, dummy_standby]::text[]) as value from dbe_perf.global_replication_slots
        union
        select 'datoid' as variable_name, datoid::text as value from dbe_perf.global_replication_slots
        union
        select unnest(array['node_name', 'database']) as variable_name, unnest(array[node_name, database]::text[]) as value from dbe_perf.global_replication_slots
        union
        select unnest(array['slot_name', 'plugin', 'slot_type', 'restart_lsn']) as variable_name, unnest(array[slot_name, plugin, slot_type, restart_lsn]) as value from dbe_perf.global_replication_slots
        union
        select unnest(array['x_min', 'catalog_xmin']) as variable_name, unnest(array[x_min, catalog_xmin]::text[]) as value from dbe_perf.global_replication_slots
        union
        select unnest(array['node_name', 'usename']) as variable_name, unnest(array[node_name, usename]::text[]) as value from dbe_perf.global_replication_stat
        union
        select unnest(array['pid', 'client_port', 'sync_priority']) as variable_name, unnest(array[pid, client_port, sync_priority]) as value from dbe_perf.global_replication_stat
        union
        select 'usesysid' as variable_name, usesysid::text as value from dbe_perf.global_replication_stat
        union
        select 'backend_start' as variable_name, backend_start::text as value from dbe_perf.global_replication_stat
        union
        select 'client_addr' as variable_name, client_addr::text as value from dbe_perf.global_replication_stat
        union
        select unnest(array['application_name', 'client_hostname', 'state', 'sender_sent_location', 'receiver_write_location', 'receiver_flush_location', 'receiver_replay_location', 'sync_state']) as variable_name, unnest(array[application_name, client_hostname, state, sender_sent_location, receiver_write_location, receiver_flush_location, receiver_replay_location, sync_state]) as value from dbe_perf.global_replication_stat
        union
        select unnest(array['owner', 'database']) as variable_name, unnest(array[owner, database]::text[]) as value from dbe_perf.summary_transactions_prepared_xacts
        union
        select 'transaction' as variable_name, transaction::text as value from dbe_perf.summary_transactions_prepared_xacts
        union
        select 'gid' as variable_name, gid as value from dbe_perf.summary_transactions_prepared_xacts
        union
        select 'prepared' as variable_name, prepared::text as value from dbe_perf.summary_transactions_prepared_xacts order by variable_name;
        EXECUTE IMMEDIATE 'set dolphin.sql_mode=''' || sql_mode || '''';
        END;
        $$
        LANGUAGE plpgsql;
        
        CREATE OPERATOR pg_catalog.+(
        leftarg = int1, rightarg = int1, procedure = int1pl,
        commutator=operator(pg_catalog.+)
        );
        COMMENT ON OPERATOR pg_catalog.+(int1, int1) IS 'int1pl';

        CREATE OPERATOR pg_catalog.-(
        leftarg = int1, rightarg = int1, procedure = int1mi,
        commutator=operator(pg_catalog.-)
        );
        COMMENT ON OPERATOR pg_catalog.-(int1, int1) IS 'int1mi';

        CREATE OPERATOR pg_catalog.*(
        leftarg = int1, rightarg = int1, procedure = int1mul,
        commutator=operator(pg_catalog.*)
        );
        COMMENT ON OPERATOR pg_catalog.*(int1, int1) IS 'int1mul';

        CREATE OPERATOR pg_catalog.%(
        leftarg = int1, rightarg = int1, procedure = int1mod,
        commutator=operator(pg_catalog.%)
        );
        COMMENT ON OPERATOR pg_catalog.%(int1, int1) IS 'int1mod';

        CREATE OPERATOR pg_catalog.&(
        leftarg = int1, rightarg = int1, procedure = int1and,
        commutator=operator(pg_catalog.&)
        );
        COMMENT ON OPERATOR pg_catalog.&(int1, int1) IS 'int1and';

        CREATE OPERATOR pg_catalog.|(
        leftarg = int1, rightarg = int1, procedure = int1or,
        commutator=operator(pg_catalog.|)
        );
        COMMENT ON OPERATOR pg_catalog.|(int1, int1) IS 'int1or';

        CREATE OPERATOR pg_catalog.#(
        leftarg = int1, rightarg = int1, procedure = int1xor,
        commutator=operator(pg_catalog.#)
        );
        COMMENT ON OPERATOR pg_catalog.#(int1, int1) IS 'int1xor';

        CREATE OPERATOR pg_catalog.>>(
        leftarg = int1, rightarg = int4, procedure = int1shr
        );
        COMMENT ON OPERATOR pg_catalog.>>(int1, int4) IS 'int1shr';

        CREATE OPERATOR pg_catalog.<<(
        leftarg = int1, rightarg = int4, procedure = int1shl
        );
        COMMENT ON OPERATOR pg_catalog.<<(int1, int4) IS 'int1shl';

        CREATE OPERATOR pg_catalog.~(
        rightarg = int1, procedure = int1not
        );

        CREATE OPERATOR pg_catalog.+(
        rightarg = int1, procedure = int1up
        );

        CREATE OPERATOR pg_catalog.-(
        rightarg = int1, procedure = int1um
        );

        CREATE OPERATOR pg_catalog.@(
        rightarg = int1, procedure = int1abs
        );

        DROP FUNCTION IF EXISTS pg_catalog.int1_accum(numeric[], int1) ;
        CREATE OR REPLACE FUNCTION pg_catalog.int1_accum(numeric[], int1)
         RETURNS numeric[] LANGUAGE C STRICT AS  '$libdir/dolphin',  'int1_accum';

        drop aggregate if exists pg_catalog.stddev_pop(int1);
        create aggregate pg_catalog.stddev_pop(int1) (SFUNC=int1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_stddev_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

        DROP FUNCTION IF EXISTS pg_catalog.int1_list_agg_transfn(internal, int1, text);

        CREATE OR REPLACE FUNCTION pg_catalog.int1_list_agg_transfn(internal, int1, text)
         RETURNS internal LANGUAGE C AS    '$libdir/dolphin',    'int1_list_agg_transfn';

        DROP FUNCTION IF EXISTS pg_catalog.int1_list_agg_noarg2_transfn(internal, int1);

        CREATE OR REPLACE FUNCTION pg_catalog.int1_list_agg_noarg2_transfn(internal, int1)
         RETURNS internal LANGUAGE C  AS '$libdir/dolphin',    'int1_list_agg_noarg2_transfn';

        drop aggregate if exists pg_catalog.listagg(int1,text);
        create aggregate pg_catalog.listagg(int1,text) (SFUNC=int1_list_agg_transfn, finalfunc = list_agg_finalfn,  STYPE= internal);

        drop aggregate if exists pg_catalog.listagg(int1);
        create aggregate pg_catalog.listagg(int1) (SFUNC=int1_list_agg_noarg2_transfn, finalfunc = list_agg_finalfn,  STYPE= internal);

        drop aggregate if exists pg_catalog.var_pop(int1);
        create aggregate pg_catalog.var_pop(int1) (SFUNC=int1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

        drop aggregate if exists pg_catalog.var_samp(int1);
        create aggregate pg_catalog.var_samp(int1) (SFUNC=int1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

        drop aggregate if exists pg_catalog.variance(int1);
        create aggregate pg_catalog.variance(int1) (SFUNC=int1_accum, cFUNC=numeric_collect, STYPE= numeric[], finalfunc = numeric_var_samp, initcond = '{0,0,0}', initcollect = '{0,0,0}');

        CREATE OR REPLACE FUNCTION pg_catalog.int12eq (
        int1,int2
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int12eq';

        CREATE OR REPLACE FUNCTION pg_catalog.int12lt (
        int1,int2
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int12lt';

        CREATE OR REPLACE FUNCTION pg_catalog.int12le (
        int1,int2
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int12le';

        CREATE OR REPLACE FUNCTION pg_catalog.int12gt (
        int1,int2
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int12gt';

        CREATE OR REPLACE FUNCTION pg_catalog.int12ge (
        int1,int2
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int12ge';

        CREATE OR REPLACE FUNCTION pg_catalog.int14eq (
        int1,int4
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int14eq';

        CREATE OR REPLACE FUNCTION pg_catalog.int14lt (
        int1,int4
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int14lt';

        CREATE OR REPLACE FUNCTION pg_catalog.int14le (
        int1,int4
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int14le';

        CREATE OR REPLACE FUNCTION pg_catalog.int14gt (
        int1,int4
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int14gt';

        CREATE OR REPLACE FUNCTION pg_catalog.int14ge (
        int1,int4
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int14ge';

        CREATE OR REPLACE FUNCTION pg_catalog.int18eq (
        int1,int8
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int18eq';

        CREATE OR REPLACE FUNCTION pg_catalog.int18lt (
        int1,int8
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int18lt';

        CREATE OR REPLACE FUNCTION pg_catalog.int18le (
        int1,int8
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int18le';

        CREATE OR REPLACE FUNCTION pg_catalog.int18gt (
        int1,int8
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int18gt';

        CREATE OR REPLACE FUNCTION pg_catalog.int18ge (
        int1,int8
        ) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int18ge';

        CREATE OPERATOR pg_catalog.=(
        leftarg = int1, rightarg = int2, procedure = int12eq,
        restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES
        );
        COMMENT ON OPERATOR pg_catalog.=(int1, int2) IS 'int12eq';

        CREATE OPERATOR pg_catalog.<(
        leftarg = int1, rightarg = int2, procedure = int12lt,
        restrict = scalarltsel, join = scalarltjoinsel
        );
        COMMENT ON OPERATOR pg_catalog.<(int1, int2) IS 'int12lt';

        CREATE OPERATOR pg_catalog.<=(
        leftarg = int1, rightarg = int2, procedure = int12le,
        restrict = scalarltsel, join = scalarltjoinsel
        );
        COMMENT ON OPERATOR pg_catalog.<=(int1, int2) IS 'int12le';

        CREATE OPERATOR pg_catalog.>(
        leftarg = int1, rightarg = int2, procedure = int12gt,
        restrict = scalargtsel, join = scalargtjoinsel
        );
        COMMENT ON OPERATOR pg_catalog.>(int1, int2) IS 'int12gt';

        CREATE OPERATOR pg_catalog.>=(
        leftarg = int1, rightarg = int2, procedure = int12ge,
        restrict = scalargtsel, join = scalargtjoinsel
        );
        COMMENT ON OPERATOR pg_catalog.>=(int1, int2) IS 'int12ge';

        CREATE OPERATOR pg_catalog.=(
        leftarg = int1, rightarg = int4, procedure = int14eq,
        restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES
        );
        COMMENT ON OPERATOR pg_catalog.=(int1, int4) IS 'int14eq';

        CREATE OPERATOR pg_catalog.<(
        leftarg = int1, rightarg = int4, procedure = int14lt,
        restrict = scalarltsel, join = scalarltjoinsel
        );
        COMMENT ON OPERATOR pg_catalog.<(int1, int4) IS 'int14lt';

        CREATE OPERATOR pg_catalog.<=(
        leftarg = int1, rightarg = int4, procedure = int14le,
        restrict = scalarltsel, join = scalarltjoinsel
        );
        COMMENT ON OPERATOR pg_catalog.<=(int1, int4) IS 'int14le';

        CREATE OPERATOR pg_catalog.>(
        leftarg = int1, rightarg = int4, procedure = int14gt,
        restrict = scalargtsel, join = scalargtjoinsel
        );
        COMMENT ON OPERATOR pg_catalog.>(int1, int4) IS 'int14gt';

        CREATE OPERATOR pg_catalog.>=(
        leftarg = int1, rightarg = int4, procedure = int14ge,
        restrict = scalargtsel, join = scalargtjoinsel
        );
        COMMENT ON OPERATOR pg_catalog.>=(int1, int4) IS 'int14ge';

        CREATE OPERATOR pg_catalog.=(
        leftarg = int1, rightarg = int8, procedure = int18eq,
        restrict = eqsel, join = eqjoinsel,
        HASHES, MERGES
        );
        COMMENT ON OPERATOR pg_catalog.=(int1, int8) IS 'int18eq';

        CREATE OPERATOR pg_catalog.<(
        leftarg = int1, rightarg = int8, procedure = int18lt,
        restrict = scalarltsel, join = scalarltjoinsel
        );
        COMMENT ON OPERATOR pg_catalog.<(int1, int8) IS 'int18lt';

        CREATE OPERATOR pg_catalog.<=(
        leftarg = int1, rightarg = int8, procedure = int18le,
        restrict = scalarltsel, join = scalarltjoinsel
        );
        COMMENT ON OPERATOR pg_catalog.<=(int1, int8) IS 'int18le';

        CREATE OPERATOR pg_catalog.>(
        leftarg = int1, rightarg = int8, procedure = int18gt,
        restrict = scalargtsel, join = scalargtjoinsel
        );
        COMMENT ON OPERATOR pg_catalog.>(int1, int8) IS 'int18gt';

        CREATE OPERATOR pg_catalog.>=(
        leftarg = int1, rightarg = int8, procedure = int18ge,
        restrict = scalargtsel, join = scalargtjoinsel
        );
        COMMENT ON OPERATOR pg_catalog.>=(int1, int8) IS 'int18ge';

        CREATE OR REPLACE FUNCTION pg_catalog.int12cmp (
        int1,int2
        ) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int12cmp';

        CREATE OR REPLACE FUNCTION pg_catalog.int14cmp (
        int1,int4
        ) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int14cmp';

        CREATE OR REPLACE FUNCTION pg_catalog.int18cmp (
        int1,int8
        ) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int18cmp';

        CREATE OPERATOR CLASS int1_ops
            FOR TYPE int1 USING btree family int1_ops AS
                OPERATOR        1       <(int1, int2),
                OPERATOR        1       <(int1, int4),
                OPERATOR        1       <(int1, int8),
                OPERATOR        2       <=(int1, int2),
                OPERATOR        2       <=(int1, int4),
                OPERATOR        2       <=(int1, int8),
                OPERATOR        3       =(int1, int2),
                OPERATOR        3       =(int1, int4),
                OPERATOR        3       =(int1, int8),
                OPERATOR        4       >=(int1, int2),
                OPERATOR        4       >=(int1, int4),
                OPERATOR        4       >=(int1, int8),
                OPERATOR        5       >(int1, int2),
                OPERATOR        5       >(int1, int4),
                OPERATOR        5       >(int1, int8),
                FUNCTION        1       int12cmp(int1, int2),
                FUNCTION        1       int14cmp(int1, int4),
                FUNCTION        1       int18cmp(int1, int8);

        CREATE OPERATOR CLASS int1_ops
            FOR TYPE int1 USING cbtree family int1_ops AS
                OPERATOR        1       <(int1, int2),
                OPERATOR        1       <(int1, int4),
                OPERATOR        1       <(int1, int8),
                OPERATOR        2       <=(int1, int2),
                OPERATOR        2       <=(int1, int4),
                OPERATOR        2       <=(int1, int8),
                OPERATOR        3       =(int1, int2),
                OPERATOR        3       =(int1, int4),
                OPERATOR        3       =(int1, int8),
                OPERATOR        4       >=(int1, int2),
                OPERATOR        4       >=(int1, int4),
                OPERATOR        4       >=(int1, int8),
                OPERATOR        5       >(int1, int2),
                OPERATOR        5       >(int1, int4),
                OPERATOR        5       >(int1, int8),
                FUNCTION        1       int12cmp(int1, int2),
                FUNCTION        1       int14cmp(int1, int4),
                FUNCTION        1       int18cmp(int1, int8);

        CREATE OPERATOR CLASS int1_ops
            FOR TYPE int1 USING ubtree family int1_ops AS
                OPERATOR        1       <(int1, int2),
                OPERATOR        1       <(int1, int4),
                OPERATOR        1       <(int1, int8),
                OPERATOR        2       <=(int1, int2),
                OPERATOR        2       <=(int1, int4),
                OPERATOR        2       <=(int1, int8),
                OPERATOR        3       =(int1, int2),
                OPERATOR        3       =(int1, int4),
                OPERATOR        3       =(int1, int8),
                OPERATOR        4       >=(int1, int2),
                OPERATOR        4       >=(int1, int4),
                OPERATOR        4       >=(int1, int8),
                OPERATOR        5       >(int1, int2),
                OPERATOR        5       >(int1, int4),
                OPERATOR        5       >(int1, int8),
                FUNCTION        1       int12cmp(int1, int2),
                FUNCTION        1       int14cmp(int1, int4),
                FUNCTION        1       int18cmp(int1, int8);

        CREATE OPERATOR CLASS int1_ops
            FOR TYPE int1 USING hash family int1_ops AS
                OPERATOR        1       =(int1, int2),
                OPERATOR        1       =(int1, int4),
                OPERATOR        1       =(int1, int8),
                FUNCTION        1       hashint2(int2),
                FUNCTION        1       hashint4(int4),
                FUNCTION        1       hashint8(int8);

        DROP FUNCTION IF EXISTS pg_catalog.to_base64 (bytea);
        DROP FUNCTION IF EXISTS pg_catalog.to_base64 (numeric);
        DROP FUNCTION IF EXISTS pg_catalog.to_base64 (text);
        DROP FUNCTION IF EXISTS pg_catalog.to_base64 (bit);
        CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (bytea)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode';

        CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (num1 numeric)
        RETURNS text
        AS
        $$
        BEGIN
            RETURN (SELECT to_base64(cast(to_char(num1) AS bytea)));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (t1 text)
        RETURNS text
        AS
        $$
        BEGIN
            RETURN (SELECT to_base64(cast(t1 AS bytea)));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OR REPLACE FUNCTION pg_catalog.to_base64(bit1 bit)
        RETURNS text
        AS
        $$
        BEGIN
            RETURN (SELECT to_base64((decode(hex(bit1), 'hex'))));
        END;
        $$
        LANGUAGE plpgsql;
        
        DROP FUNCTION IF EXISTS pg_catalog.unhex (text) ;
        DROP FUNCTION IF EXISTS pg_catalog.unhex (numeric) ;
        DROP FUNCTION IF EXISTS pg_catalog.unhex (bool) ;
        DROP FUNCTION IF EXISTS pg_catalog.unhex (bytea) ;
        DROP FUNCTION IF EXISTS pg_catalog.unhex ("timestamp") ;

        CREATE OR REPLACE FUNCTION pg_catalog.unhex (text)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'unhex';

        CREATE OR REPLACE FUNCTION pg_catalog.unhex (num1 numeric)
        RETURNS text
        AS
        $$
        BEGIN
            RETURN (SELECT unhex(to_char(num1)));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OR REPLACE FUNCTION pg_catalog.unhex (bool1 bool)
        RETURNS text
        AS
        $$
        BEGIN
            RETURN (SELECT unhex(cast(bool1 AS numeric)));
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OR REPLACE FUNCTION pg_catalog.unhex (bin1 bytea)
        RETURNS text
        AS
        $$
        BEGIN
            RETURN NULL;
        END;
        $$
        LANGUAGE plpgsql;

        CREATE OR REPLACE FUNCTION pg_catalog.unhex (datetime1 "timestamp")
        RETURNS text
        AS
        $$
        BEGIN
            RETURN NULL;
        END;
        $$
        LANGUAGE plpgsql;
        
        CREATE SCHEMA dolphin_catalog;

        /* int4 */
        create function dolphin_catalog.dolphin_int4pl (
        int4,
        int4
        ) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4pl';
        create operator dolphin_catalog.+(leftarg = int4, rightarg = int4, procedure = dolphin_catalog.dolphin_int4pl);

        create function dolphin_catalog.dolphin_int4mi (
        int4,
        int4
        ) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4mi';
        create operator dolphin_catalog.-(leftarg = int4, rightarg = int4, procedure = dolphin_catalog.dolphin_int4mi);

        create function dolphin_catalog.dolphin_int4mul (
        int4,
        int4
        ) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4mul';
        create operator dolphin_catalog.*(leftarg = int4, rightarg = int4, procedure = dolphin_catalog.dolphin_int4mul);

        create function dolphin_catalog.dolphin_int4div (
        int4,
        int4
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4div';
        create operator dolphin_catalog./(leftarg = int4, rightarg = int4, procedure = dolphin_catalog.dolphin_int4div);

        /* int2 */
        create function dolphin_catalog.dolphin_int2pl (
        int2,
        int2
        ) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2pl';
        create operator dolphin_catalog.+(leftarg = int2, rightarg = int2, procedure = dolphin_catalog.dolphin_int2pl);

        create function dolphin_catalog.dolphin_int2mi (
        int2,
        int2
        ) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2mi';
        create operator dolphin_catalog.-(leftarg = int2, rightarg = int2, procedure = dolphin_catalog.dolphin_int2mi);

        create function dolphin_catalog.dolphin_int2mul (
        int2,
        int2
        ) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2mul';
        create operator dolphin_catalog.*(leftarg = int2, rightarg = int2, procedure = dolphin_catalog.dolphin_int2mul);

        create function dolphin_catalog.dolphin_int2div (
        int2,
        int2
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2div';
        create operator dolphin_catalog./(leftarg = int2, rightarg = int2, procedure = dolphin_catalog.dolphin_int2div);

        /* int1 */
        create function dolphin_catalog.dolphin_int1pl (
        int1,
        int1
        ) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1pl';
        create operator dolphin_catalog.+(leftarg = int1, rightarg = int1, procedure = dolphin_catalog.dolphin_int1pl);

        create function dolphin_catalog.dolphin_int1mi (
        int1,
        int1
        ) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1mi';
        create operator dolphin_catalog.-(leftarg = int1, rightarg = int1, procedure = dolphin_catalog.dolphin_int1mi);

        create function dolphin_catalog.dolphin_int1mul (
        int1,
        int1
        ) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1mul';
        create operator dolphin_catalog.*(leftarg = int1, rightarg = int1, procedure = dolphin_catalog.dolphin_int1mul);

        create function dolphin_catalog.dolphin_int1div (
        int1,
        int1
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1div';
        create operator dolphin_catalog./(leftarg = int1, rightarg = int1, procedure = dolphin_catalog.dolphin_int1div);

        CREATE OPERATOR pg_catalog./(leftarg = int1, rightarg = int1, procedure = dolphin_catalog.dolphin_int1div);
        COMMENT ON OPERATOR pg_catalog./(int1, int1) IS 'dolphin_int1div';

        /* int8 */
        create function dolphin_catalog.dolphin_int8pl (
        int8,
        int8
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int8pl';
        create operator dolphin_catalog.+(leftarg = int8, rightarg = int8, procedure = dolphin_catalog.dolphin_int8pl);

        create function dolphin_catalog.dolphin_int8mi (
        int8,
        int8
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int8mi';
        create operator dolphin_catalog.-(leftarg = int8, rightarg = int8, procedure = dolphin_catalog.dolphin_int8mi);

        create function dolphin_catalog.dolphin_int8mul (
        int8,
        int8
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int8mul';
        create operator dolphin_catalog.*(leftarg = int8, rightarg = int8, procedure = dolphin_catalog.dolphin_int8mul);

        create function dolphin_catalog.dolphin_int8div (
        int8,
        int8
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int8div';
        create operator dolphin_catalog./(leftarg = int8, rightarg = int8, procedure = dolphin_catalog.dolphin_int8div);

        /* uint1 */
        create function dolphin_catalog.dolphin_uint1pl (
        uint1,
        uint1
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1pl';
        create operator dolphin_catalog.+(leftarg = uint1, rightarg = uint1, procedure = dolphin_catalog.dolphin_uint1pl);

        create function dolphin_catalog.dolphin_uint1mi (
        uint1,
        uint1
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1mi';
        create operator dolphin_catalog.-(leftarg = uint1, rightarg = uint1, procedure = dolphin_catalog.dolphin_uint1mi);

        create function dolphin_catalog.dolphin_uint1mul (
        uint1,
        uint1
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1mul';
        create operator dolphin_catalog.*(leftarg = uint1, rightarg = uint1, procedure = dolphin_catalog.dolphin_uint1mul);

        create function dolphin_catalog.dolphin_uint1div (
        uint1,
        uint1
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1div';
        create operator dolphin_catalog./(leftarg = uint1, rightarg = uint1, procedure = dolphin_catalog.dolphin_uint1div);

        /* int1_uint1 */
        create function dolphin_catalog.dolphin_int1_pl_uint1 (
        int1,
        uint1
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1_pl_uint1';
        create operator dolphin_catalog.+(leftarg = int1, rightarg = uint1, procedure = dolphin_catalog.dolphin_int1_pl_uint1);

        create function dolphin_catalog.dolphin_int1_mi_uint1 (
        int1,
        uint1
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1_mi_uint1';
        create operator dolphin_catalog.-(leftarg = int1, rightarg = uint1, procedure = dolphin_catalog.dolphin_int1_mi_uint1);

        create function dolphin_catalog.dolphin_int1_mul_uint1 (
        int1,
        uint1
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1_mul_uint1';
        create operator dolphin_catalog.*(leftarg = int1, rightarg = uint1, procedure = dolphin_catalog.dolphin_int1_mul_uint1);

        create function dolphin_catalog.dolphin_int1_div_uint1 (
        int1,
        uint1
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int1_div_uint1';
        create operator dolphin_catalog./(leftarg = int1, rightarg = uint1, procedure = dolphin_catalog.dolphin_int1_div_uint1);

        /* uint1_int1 */
        create function dolphin_catalog.dolphin_uint1_pl_int1 (
        uint1,
        int1
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1_pl_int1';
        create operator dolphin_catalog.+(leftarg = uint1, rightarg = int1, procedure = dolphin_catalog.dolphin_uint1_pl_int1);

        create function dolphin_catalog.dolphin_uint1_mi_int1 (
        uint1,
        int1
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1_mi_int1';
        create operator dolphin_catalog.-(leftarg = uint1, rightarg = int1, procedure = dolphin_catalog.dolphin_uint1_mi_int1);

        create function dolphin_catalog.dolphin_uint1_mul_int1 (
        uint1,
        int1
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1_mul_int1';
        create operator dolphin_catalog.*(leftarg = uint1, rightarg = int1, procedure = dolphin_catalog.dolphin_uint1_mul_int1);

        create function dolphin_catalog.dolphin_uint1_div_int1 (
        uint1,
        int1
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint1_div_int1';
        create operator dolphin_catalog./(leftarg = uint1, rightarg = int1, procedure = dolphin_catalog.dolphin_uint1_div_int1);

        /* int2_int4 */
        create function dolphin_catalog.dolphin_int24pl (
        int2,
        int4
        ) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int24pl';
        create operator dolphin_catalog.+(leftarg = int2, rightarg = int4, procedure = dolphin_catalog.dolphin_int24pl);

        create function dolphin_catalog.dolphin_int24mi (
        int2,
        int4
        ) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int24mi';
        create operator dolphin_catalog.-(leftarg = int2, rightarg = int4, procedure = dolphin_catalog.dolphin_int24mi);

        create function dolphin_catalog.dolphin_int24mul (
        int2,
        int4
        ) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int24mul';
        create operator dolphin_catalog.*(leftarg = int2, rightarg = int4, procedure = dolphin_catalog.dolphin_int24mul);

        create function dolphin_catalog.dolphin_int24div (
        int2,
        int4
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int24div';
        create operator dolphin_catalog./(leftarg = int2, rightarg = int4, procedure = dolphin_catalog.dolphin_int24div);

        /* int2_int8 */
        create function dolphin_catalog.dolphin_int28pl (
        int2,
        int8
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int28pl';
        create operator dolphin_catalog.+(leftarg = int2, rightarg = int8, procedure = dolphin_catalog.dolphin_int28pl);

        create function dolphin_catalog.dolphin_int28mi (
        int2,
        int8
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int28mi';
        create operator dolphin_catalog.-(leftarg = int2, rightarg = int8, procedure = dolphin_catalog.dolphin_int28mi);

        create function dolphin_catalog.dolphin_int28mul (
        int2,
        int8
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int28mul';
        create operator dolphin_catalog.*(leftarg = int2, rightarg = int8, procedure = dolphin_catalog.dolphin_int28mul);

        create function dolphin_catalog.dolphin_int28div (
        int2,
        int8
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int28div';
        create operator dolphin_catalog./(leftarg = int2, rightarg = int8, procedure = dolphin_catalog.dolphin_int28div);

        /* int2_uint2 */
        create function dolphin_catalog.dolphin_int2_pl_uint2 (
        int2,
        uint2
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2_pl_uint2';
        create operator dolphin_catalog.+(leftarg = int2, rightarg = uint2, procedure = dolphin_catalog.dolphin_int2_pl_uint2);

        create function dolphin_catalog.dolphin_int2_mi_uint2 (
        int2,
        uint2
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2_mi_uint2';
        create operator dolphin_catalog.-(leftarg = int2, rightarg = uint2, procedure = dolphin_catalog.dolphin_int2_mi_uint2);

        create function dolphin_catalog.dolphin_int2_mul_uint2 (
        int2,
        uint2
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2_mul_uint2';
        create operator dolphin_catalog.*(leftarg = int2, rightarg = uint2, procedure = dolphin_catalog.dolphin_int2_mul_uint2);

        create function dolphin_catalog.dolphin_int2_div_uint2 (
        int2,
        uint2
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int2_div_uint2';
        create operator dolphin_catalog./(leftarg = int2, rightarg = uint2, procedure = dolphin_catalog.dolphin_int2_div_uint2);

        /* int4_int2 */
        create function dolphin_catalog.dolphin_int42pl (
        int4,
        int2
        ) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int42pl';
        create operator dolphin_catalog.+(leftarg = int4, rightarg = int2, procedure = dolphin_catalog.dolphin_int42pl);

        create function dolphin_catalog.dolphin_int42mi (
        int4,
        int2
        ) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int42mi';
        create operator dolphin_catalog.-(leftarg = int4, rightarg = int2, procedure = dolphin_catalog.dolphin_int42mi);

        create function dolphin_catalog.dolphin_int42mul (
        int4,
        int2
        ) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int42mul';
        create operator dolphin_catalog.*(leftarg = int4, rightarg = int2, procedure = dolphin_catalog.dolphin_int42mul);

        create function dolphin_catalog.dolphin_int42div (
        int4,
        int2
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int42div';
        create operator dolphin_catalog./(leftarg = int4, rightarg = int2, procedure = dolphin_catalog.dolphin_int42div);

        /* int4_int8 */
        create function dolphin_catalog.dolphin_int48pl (
        int4,
        int8
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int48pl';
        create operator dolphin_catalog.+(leftarg = int4, rightarg = int8, procedure = dolphin_catalog.dolphin_int48pl);

        create function dolphin_catalog.dolphin_int48mi (
        int4,
        int8
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int48mi';
        create operator dolphin_catalog.-(leftarg = int4, rightarg = int8, procedure = dolphin_catalog.dolphin_int48mi);

        create function dolphin_catalog.dolphin_int48mul (
        int4,
        int8
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int48mul';
        create operator dolphin_catalog.*(leftarg = int4, rightarg = int8, procedure = dolphin_catalog.dolphin_int48mul);

        create function dolphin_catalog.dolphin_int48div (
        int4,
        int8
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int48div';
        create operator dolphin_catalog./(leftarg = int4, rightarg = int8, procedure = dolphin_catalog.dolphin_int48div);

        /* int4_uint4 */
        create function dolphin_catalog.dolphin_int4_pl_uint4 (
        int4,
        uint4
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4_pl_uint4';
        create operator dolphin_catalog.+(leftarg = int4, rightarg = uint4, procedure = dolphin_catalog.dolphin_int4_pl_uint4);

        create function dolphin_catalog.dolphin_int4_mi_uint4 (
        int4,
        uint4
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4_mi_uint4';
        create operator dolphin_catalog.-(leftarg = int4, rightarg = uint4, procedure = dolphin_catalog.dolphin_int4_mi_uint4);

        create function dolphin_catalog.dolphin_int4_mul_uint4 (
        int4,
        uint4
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4_mul_uint4';
        create operator dolphin_catalog.*(leftarg = int4, rightarg = uint4, procedure = dolphin_catalog.dolphin_int4_mul_uint4);

        create function dolphin_catalog.dolphin_int4_div_uint4 (
        int4,
        uint4
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int4_div_uint4';
        create operator dolphin_catalog./(leftarg = int4, rightarg = uint4, procedure = dolphin_catalog.dolphin_int4_div_uint4);

        /* int8_int2 */
        create function dolphin_catalog.dolphin_int82pl (
        int8,
        int2
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int82pl';
        create operator dolphin_catalog.+(leftarg = int8, rightarg = int2, procedure = dolphin_catalog.dolphin_int82pl);

        create function dolphin_catalog.dolphin_int82mi (
        int8,
        int2
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int82mi';
        create operator dolphin_catalog.-(leftarg = int8, rightarg = int2, procedure = dolphin_catalog.dolphin_int82mi);

        create function dolphin_catalog.dolphin_int82mul (
        int8,
        int2
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int82mul';
        create operator dolphin_catalog.*(leftarg = int8, rightarg = int2, procedure = dolphin_catalog.dolphin_int82mul);

        create function dolphin_catalog.dolphin_int82div (
        int8,
        int2
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int82div';
        create operator dolphin_catalog./(leftarg = int8, rightarg = int2, procedure = dolphin_catalog.dolphin_int82div);

        /* int8_int4 */
        create function dolphin_catalog.dolphin_int84pl (
        int8,
        int4
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int84pl';
        create operator dolphin_catalog.+(leftarg = int8, rightarg = int4, procedure = dolphin_catalog.dolphin_int84pl);

        create function dolphin_catalog.dolphin_int84mi (
        int8,
        int4
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int84mi';
        create operator dolphin_catalog.-(leftarg = int8, rightarg = int4, procedure = dolphin_catalog.dolphin_int84mi);

        create function dolphin_catalog.dolphin_int84mul (
        int8,
        int4
        ) RETURNS int8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'int84mul';
        create operator dolphin_catalog.*(leftarg = int8, rightarg = int4, procedure = dolphin_catalog.dolphin_int84mul);

        create function dolphin_catalog.dolphin_int84div (
        int8,
        int4
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int84div';
        create operator dolphin_catalog./(leftarg = int8, rightarg = int4, procedure = dolphin_catalog.dolphin_int84div);

        /* uint2_int2 */
        create function dolphin_catalog.dolphin_uint2_pl_int2 (
        uint2,
        int2
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2_pl_int2';
        create operator dolphin_catalog.+(leftarg = uint2, rightarg = int2, procedure = dolphin_catalog.dolphin_uint2_pl_int2);

        create function dolphin_catalog.dolphin_uint2_mi_int2 (
        uint2,
        int2
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2_mi_int2';
        create operator dolphin_catalog.-(leftarg = uint2, rightarg = int2, procedure = dolphin_catalog.dolphin_uint2_mi_int2);

        create function dolphin_catalog.dolphin_uint2_mul_int2 (
        uint2,
        int2
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2_mul_int2';
        create operator dolphin_catalog.*(leftarg = uint2, rightarg = int2, procedure = dolphin_catalog.dolphin_uint2_mul_int2);

        create function dolphin_catalog.dolphin_uint2_div_int2 (
        uint2,
        int2
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2_div_int2';
        create operator dolphin_catalog./(leftarg = uint2, rightarg = int2, procedure = dolphin_catalog.dolphin_uint2_div_int2);

        /* uint2 */
        create function dolphin_catalog.dolphin_uint2pl (
        uint2,
        uint2
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2pl';
        create operator dolphin_catalog.+(leftarg = uint2, rightarg = uint2, procedure = dolphin_catalog.dolphin_uint2pl);

        create function dolphin_catalog.dolphin_uint2mi (
        uint2,
        uint2
        ) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2mi';
        create operator dolphin_catalog.-(leftarg = uint2, rightarg = uint2, procedure = dolphin_catalog.dolphin_uint2mi);

        create function dolphin_catalog.dolphin_uint2mul (
        uint2,
        uint2
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2mul';
        create operator dolphin_catalog.*(leftarg = uint2, rightarg = uint2, procedure = dolphin_catalog.dolphin_uint2mul);

        create function dolphin_catalog.dolphin_uint2div (
        uint2,
        uint2
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint2div';
        create operator dolphin_catalog./(leftarg = uint2, rightarg = uint2, procedure = dolphin_catalog.dolphin_uint2div);

        /* uint4 */
        create function dolphin_catalog.dolphin_uint4pl (
        uint4,
        uint4
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4pl';
        create operator dolphin_catalog.+(leftarg = uint4, rightarg = uint4, procedure = dolphin_catalog.dolphin_uint4pl);

        create function dolphin_catalog.dolphin_uint4mi (
        uint4,
        uint4
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4mi';
        create operator dolphin_catalog.-(leftarg = uint4, rightarg = uint4, procedure = dolphin_catalog.dolphin_uint4mi);

        create function dolphin_catalog.dolphin_uint4mul (
        uint4,
        uint4
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4mul';
        create operator dolphin_catalog.*(leftarg = uint4, rightarg = uint4, procedure = dolphin_catalog.dolphin_uint4mul);

        create function dolphin_catalog.dolphin_uint4div (
        uint4,
        uint4
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4div';
        create operator dolphin_catalog./(leftarg = uint4, rightarg = uint4, procedure = dolphin_catalog.dolphin_uint4div);

        /* uint4_int4 */
        create function dolphin_catalog.dolphin_uint4_pl_int4 (
        uint4,
        int4
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4_pl_int4';
        create operator dolphin_catalog.+(leftarg = uint4, rightarg = int4, procedure = dolphin_catalog.dolphin_uint4_pl_int4);

        create function dolphin_catalog.dolphin_uint4_mi_int4 (
        uint4,
        int4
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4_mi_int4';
        create operator dolphin_catalog.-(leftarg = uint4, rightarg = int4, procedure = dolphin_catalog.dolphin_uint4_mi_int4);

        create function dolphin_catalog.dolphin_uint4_mul_int4 (
        uint4,
        int4
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4_mul_int4';
        create operator dolphin_catalog.*(leftarg = uint4, rightarg = int4, procedure = dolphin_catalog.dolphin_uint4_mul_int4);

        create function dolphin_catalog.dolphin_uint4_div_int4 (
        uint4,
        int4
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint4_div_int4';
        create operator dolphin_catalog./(leftarg = uint4, rightarg = int4, procedure = dolphin_catalog.dolphin_uint4_div_int4);

        /* float4 */
        create function dolphin_catalog.dolphin_float4pl (
        float4,
        float4
        ) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_float4pl';
        create operator dolphin_catalog.+(leftarg = float4, rightarg = float4, procedure = dolphin_catalog.dolphin_float4pl);

        create function dolphin_catalog.dolphin_float4mi (
        float4,
        float4
        ) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_float4mi';
        create operator dolphin_catalog.-(leftarg = float4, rightarg = float4, procedure = dolphin_catalog.dolphin_float4mi);

        create function dolphin_catalog.dolphin_float4mul (
        float4,
        float4
        ) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_float4mul';
        create operator dolphin_catalog.*(leftarg = float4, rightarg = float4, procedure = dolphin_catalog.dolphin_float4mul);

        create function dolphin_catalog.dolphin_float4div (
        float4,
        float4
        ) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_float4div';
        create operator dolphin_catalog./(leftarg = float4, rightarg = float4, procedure = dolphin_catalog.dolphin_float4div);

        /* float4_float8 */
        create function dolphin_catalog.dolphin_float48pl (
        float4,
        float8
        ) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float48pl';
        create operator dolphin_catalog.+(leftarg = float4, rightarg = float8, procedure = dolphin_catalog.dolphin_float48pl);

        create function dolphin_catalog.dolphin_float48mi (
        float4,
        float8
        ) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float48mi';
        create operator dolphin_catalog.-(leftarg = float4, rightarg = float8, procedure = dolphin_catalog.dolphin_float48mi);

        create function dolphin_catalog.dolphin_float48mul (
        float4,
        float8
        ) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float48mul';
        create operator dolphin_catalog.*(leftarg = float4, rightarg = float8, procedure = dolphin_catalog.dolphin_float48mul);

        create function dolphin_catalog.dolphin_float48div (
        float4,
        float8
        ) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float48div';
        create operator dolphin_catalog./(leftarg = float4, rightarg = float8, procedure = dolphin_catalog.dolphin_float48div);

        /* float8_float4 */
        create function dolphin_catalog.dolphin_float84pl (
        float8,
        float4
        ) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float84pl';
        create operator dolphin_catalog.+(leftarg = float8, rightarg = float4, procedure = dolphin_catalog.dolphin_float84pl);

        create function dolphin_catalog.dolphin_float84mi (
        float8,
        float4
        ) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float84mi';
        create operator dolphin_catalog.-(leftarg = float8, rightarg = float4, procedure = dolphin_catalog.dolphin_float84mi);

        create function dolphin_catalog.dolphin_float84mul (
        float8,
        float4
        ) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float84mul';
        create operator dolphin_catalog.*(leftarg = float8, rightarg = float4, procedure = dolphin_catalog.dolphin_float84mul);

        create function dolphin_catalog.dolphin_float84div (
        float8,
        float4
        ) RETURNS float8 LANGUAGE INTERNAL IMMUTABLE STRICT as 'float84div';
        create operator dolphin_catalog./(leftarg = float8, rightarg = float4, procedure = dolphin_catalog.dolphin_float84div);

        /* uint8_int8 */
        CREATE FUNCTION dolphin_catalog.dolphin_uint8_pl_int8 (
        uint8,
        int8
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_pl_int8';
        CREATE OPERATOR dolphin_catalog.+(leftarg = uint8, rightarg = int8, procedure = dolphin_catalog.dolphin_uint8_pl_int8);

        CREATE FUNCTION dolphin_catalog.dolphin_uint8_mi_int8 (
        uint8,
        int8
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_mi_int8';
        CREATE OPERATOR dolphin_catalog.-(leftarg = uint8, rightarg = int8, procedure = dolphin_catalog.dolphin_uint8_mi_int8);

        CREATE FUNCTION dolphin_catalog.dolphin_uint8_mul_int8 (
        uint8,
        int8
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_mul_int8';
        CREATE OPERATOR dolphin_catalog.*(leftarg = uint8, rightarg = int8, procedure = dolphin_catalog.dolphin_uint8_mul_int8);

        CREATE FUNCTION dolphin_catalog.dolphin_uint8_div_int8 (
        uint8,
        int8
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_uint8_div_int8';
        CREATE OPERATOR dolphin_catalog./(leftarg = uint8, rightarg = int8, procedure = dolphin_catalog.dolphin_uint8_div_int8);

        /* int8_uint8 */
        CREATE FUNCTION dolphin_catalog.dolphin_int8_pl_uint8 (
        int8,
        uint8
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_pl_uint8';
        CREATE OPERATOR dolphin_catalog.+(leftarg = int8, rightarg = uint8, procedure = dolphin_catalog.dolphin_int8_pl_uint8);

        CREATE FUNCTION dolphin_catalog.dolphin_int8_mi_uint8 (
        int8,
        uint8
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_mi_uint8';
        CREATE OPERATOR dolphin_catalog.-(leftarg = int8, rightarg = uint8, procedure = dolphin_catalog.dolphin_int8_mi_uint8);

        CREATE FUNCTION dolphin_catalog.dolphin_int8_mul_uint8 (
        int8,
        uint8
        ) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_mul_uint8';
        CREATE OPERATOR dolphin_catalog.*(leftarg = int8, rightarg = uint8, procedure = dolphin_catalog.dolphin_int8_mul_uint8);

        create function dolphin_catalog.dolphin_int8_div_uint8 (
        int8,
        uint8
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_int8_div_uint8';
        create operator dolphin_catalog./(leftarg = int8, rightarg = uint8, procedure = dolphin_catalog.dolphin_int8_div_uint8);

        /* float8 */
        create operator dolphin_catalog.+(leftarg = float8, rightarg = float8, procedure = float8pl);
        create operator dolphin_catalog.-(leftarg = float8, rightarg = float8, procedure = float8mi);
        create operator dolphin_catalog.*(leftarg = float8, rightarg = float8, procedure = float8mul);
        create operator dolphin_catalog./(leftarg = float8, rightarg = float8, procedure = float8div);

        /* uint8 */
        create operator dolphin_catalog.+(leftarg = uint8, rightarg = uint8, procedure = uint8pl);
        create operator dolphin_catalog.-(leftarg = uint8, rightarg = uint8, procedure = uint8mi);
        create operator dolphin_catalog.*(leftarg = uint8, rightarg = uint8, procedure = uint8mul);
        create function dolphin_catalog.dolphin_uint8div (
        uint8,
        uint8
        ) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_uint8div';
        create operator dolphin_catalog./(leftarg = uint8, rightarg = uint8, procedure = dolphin_catalog.dolphin_uint8div);

        /* numeric */
        create operator dolphin_catalog.+(leftarg = numeric, rightarg = numeric, procedure = numeric_add);
        create operator dolphin_catalog.-(leftarg = numeric, rightarg = numeric, procedure = numeric_sub);
        create operator dolphin_catalog.*(leftarg = numeric, rightarg = numeric, procedure = numeric_mul);
        create operator dolphin_catalog./(leftarg = numeric, rightarg = numeric, procedure = numeric_div);

        DROP FUNCTION IF EXISTS pg_catalog.uuid_short();
        CREATE OR REPLACE FUNCTION pg_catalog.uuid_short()
        RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uuid_short';

    end if;
END
$for_og_310$;

GRANT USAGE ON schema dolphin_catalog TO PUBLIC;

DO $for_upgrade_only$
DECLARE
  ans boolean;
  v_isinplaceupgrade boolean;
BEGIN
    select case when count(*)=1 then true else false end as ans from (select setting from pg_settings where name = 'upgrade_mode' and setting != '0') into ans;
    show isinplaceupgrade into v_isinplaceupgrade;
    -- we can do drop operator only during upgrade
    if ans = true and v_isinplaceupgrade = true then
        drop operator IF EXISTS pg_catalog./(int1, int1);
        create operator pg_catalog./(leftarg = int1, rightarg = int1, procedure = dolphin_catalog.dolphin_int1div);
        COMMENT ON OPERATOR pg_catalog./(int1, int1) IS 'dolphin_int1div';

        drop operator IF EXISTS pg_catalog.-(NONE, int1);
        CREATE OPERATOR pg_catalog.-(rightarg = int1, procedure = pg_catalog.int1um);
    end if;
END
$for_upgrade_only$;

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.dolphin_invoke();
CREATE FUNCTION pg_catalog.dolphin_invoke()
    RETURNS VOID AS '$libdir/dolphin','dolphin_invoke' LANGUAGE C STRICT;

DROP FUNCTION IF EXISTS pg_catalog.bit_count(numeric) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bit_count (numeric)  RETURNS int LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_numeric';
DROP FUNCTION IF EXISTS pg_catalog.bit_count(text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bit_count (text)  RETURNS int LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_text';
DROP FUNCTION IF EXISTS pg_catalog.bit_count_bit(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bit_count(date) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bit_count (date)  RETURNS int LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_date';
DROP FUNCTION IF EXISTS pg_catalog.bit_count(bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bit_count(bit) RETURNS int LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bit_count_bit';

DROP FUNCTION IF EXISTS pg_catalog.connection_id() CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.connection_id() RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'connection_id';

DROP FUNCTION IF EXISTS pg_catalog.system_user() CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.system_user(
) RETURNS name LANGUAGE C STABLE STRICT AS '$libdir/dolphin','get_b_session_user';
DROP FUNCTION IF EXISTS pg_catalog.schema() CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.schema(
) RETURNS name LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'get_b_schema';

DROP FUNCTION IF EXISTS pg_catalog.from_base64 (text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.from_base64 (bool) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.from_base64 (boolean) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.from_base64 (bit) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.from_base64 (text)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_decode_text';
CREATE OR REPLACE FUNCTION pg_catalog.from_base64 (boolean)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_decode_bool';
CREATE OR REPLACE FUNCTION pg_catalog.from_base64 (bit)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_decode_bit';

DROP FUNCTION IF EXISTS pg_catalog.atan2 (boolean, boolean);
CREATE OR REPLACE FUNCTION pg_catalog.atan2 (boolean, boolean)  RETURNS float8 AS $$ SELECT pg_catalog.atan2($1::int4, $2::int4) $$ LANGUAGE SQL;
DROP FUNCTION IF EXISTS pg_catalog.atan2 (boolean, float8);
CREATE OR REPLACE FUNCTION pg_catalog.atan2 (boolean, float8)  RETURNS float8 AS $$ SELECT pg_catalog.atan2($1::int4, $2) $$ LANGUAGE SQL;
DROP FUNCTION IF EXISTS pg_catalog.atan2 (float8, boolean);
CREATE OR REPLACE FUNCTION pg_catalog.atan2 (float8, boolean)  RETURNS float8 AS $$ SELECT pg_catalog.atan2($1, $2::int4) $$ LANGUAGE SQL;
DROP FUNCTION IF EXISTS pg_catalog.atan (float8, float8);
CREATE OR REPLACE FUNCTION pg_catalog.atan (float8, float8)  RETURNS float8 AS $$ SELECT pg_catalog.atan2($1, $2) $$ LANGUAGE SQL;
DROP FUNCTION IF EXISTS pg_catalog.atan (boolean, boolean);
CREATE OR REPLACE FUNCTION pg_catalog.atan (boolean, boolean)  RETURNS float8 AS $$ SELECT pg_catalog.atan2($1::int4, $2::int4) $$ LANGUAGE SQL;
DROP FUNCTION IF EXISTS pg_catalog.atan (boolean, float8);
CREATE OR REPLACE FUNCTION pg_catalog.atan (boolean, float8)  RETURNS float8 AS $$ SELECT pg_catalog.atan2($1::int4, $2) $$ LANGUAGE SQL;
DROP FUNCTION IF EXISTS pg_catalog.atan (float8, boolean);
CREATE OR REPLACE FUNCTION pg_catalog.atan (float8, boolean)  RETURNS float8 AS $$ SELECT pg_catalog.atan2($1, $2::int4) $$ LANGUAGE SQL;
DROP FUNCTION IF EXISTS pg_catalog.atan (boolean);
CREATE OR REPLACE FUNCTION pg_catalog.atan (boolean)  RETURNS float8 AS $$ SELECT pg_catalog.atan($1::int4) $$ LANGUAGE SQL;

DROP FUNCTION IF EXISTS pg_catalog.oct(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.oct(boolean) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.oct(bit) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.oct(numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.oct(date) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.oct(timestamp without time zone) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.oct(timestamptz) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.oct(time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.oct(text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'oct_str';
CREATE OR REPLACE FUNCTION pg_catalog.oct(numeric) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'oct_num';

CREATE OR REPLACE FUNCTION pg_catalog.oct(date) RETURNS text AS $$ SELECT pg_catalog.oct($1::text) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.oct(timestamp without time zone) RETURNS text AS $$ SELECT pg_catalog.oct($1::text) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.oct(timestamptz) RETURNS text AS $$ SELECT pg_catalog.oct($1::text) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.oct(time) RETURNS text AS $$ SELECT pg_catalog.oct($1::text) $$ LANGUAGE SQL;

DROP FUNCTION IF EXISTS pg_catalog.conv(date, int4, int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.conv(timestamp without time zone, int4, int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.conv(timestamptz, int4, int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.conv(time, int4, int4) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.conv (
date, int4, int4
) RETURNS text AS $$ SELECT pg_catalog.conv($1::text, $2, $3) $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.conv (
timestamp without time zone, int4, int4
) RETURNS text AS $$ SELECT pg_catalog.conv($1::text, $2, $3) $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.conv (
timestamptz, int4, int4
) RETURNS text AS $$ SELECT pg_catalog.conv($1::text, $2, $3) $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.conv (
time, int4, int4
) RETURNS text AS $$ SELECT pg_catalog.conv($1::text, $2, $3) $$ LANGUAGE SQL;

DROP FUNCTION IF EXISTS pg_catalog.to_base64 (bytea) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.to_base64 (numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.to_base64 (text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.to_base64 (boolean) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.to_base64 (bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (bytea)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode';
CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (text)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode_text';
CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (boolean)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode_bool';
CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (bit)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode_bit';

DROP FUNCTION IF EXISTS pg_catalog.unhex ("timestamp") CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.unhex (numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.unhex (text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.unhex (boolean) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.unhex (bytea) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.unhex (bit) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.unhex (text)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'hex_decode_text';
CREATE OR REPLACE FUNCTION pg_catalog.unhex (boolean)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'hex_decode_bool';
CREATE OR REPLACE FUNCTION pg_catalog.unhex (bytea)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'hex_decode_bytea';
CREATE OR REPLACE FUNCTION pg_catalog.unhex (bit)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'hex_decode_bit';

--bit_functions.sql
DROP FUNCTION IF EXISTS pg_catalog.bittoint1(bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bittoint1 (
bit
) RETURNS int1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittoint1';
DROP FUNCTION IF EXISTS pg_catalog.bittoint2(bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bittoint2 (
bit
) RETURNS int2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittoint2';
DROP FUNCTION IF EXISTS pg_catalog.bitfromint1(int1, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bitfromint1 (
int1, int4
) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromint1';
DROP FUNCTION IF EXISTS pg_catalog.bitfromint2(int2, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bitfromint2 (
int2, int4
) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromint2';

drop CAST IF EXISTS (bit AS int1) CASCADE;
drop CAST IF EXISTS (bit AS int2) CASCADE;
drop CAST IF EXISTS (int1 AS bit) CASCADE;
drop CAST IF EXISTS (int2 AS bit) CASCADE;

CREATE CAST (bit AS int1) WITH FUNCTION bittoint1(bit) AS ASSIGNMENT;
CREATE CAST (bit AS int2) WITH FUNCTION bittoint2(bit) AS ASSIGNMENT;
CREATE CAST (int1 AS bit) WITH FUNCTION bitfromint1(int1, int4) AS ASSIGNMENT;
CREATE CAST (int2 AS bit) WITH FUNCTION bitfromint2(int2, int4) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bittotext(bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bittotext(bit) 
RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittotext';
DROP CAST IF EXISTS (bit AS text) CASCADE;
CREATE CAST (bit AS text) WITH FUNCTION bittotext(bit) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bittochar(bit, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bittochar(bit, int4) 
RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittobpchar';
DROP CAST IF EXISTS (bit AS char) CASCADE;
CREATE CAST (bit AS char) WITH FUNCTION bittochar(bit, int4) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bittovarchar(bit, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bittovarchar(bit, int4) 
RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittovarchar';
DROP CAST IF EXISTS (bit AS varchar) CASCADE;
CREATE CAST (bit AS varchar) WITH FUNCTION bittovarchar(bit, int4) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bitfromnumeric(numeric, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bitfromnumeric(numeric, int4) 
RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromnumeric';
DROP CAST IF EXISTS (numeric as bit) CASCADE;
CREATE CAST (numeric as bit) WITH FUNCTION bitfromnumeric(numeric, int4) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bitfromfloat4(float4, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bitfromfloat4(float4, int4) 
RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromfloat4';
DROP CAST IF EXISTS (float4 as bit) CASCADE;
CREATE CAST (float4 as bit) WITH FUNCTION bitfromfloat4(float4, int4) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bitfromfloat8(float8, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bitfromfloat8(float8, int4) 
RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromfloat8';
DROP CAST IF EXISTS (float8 as bit) CASCADE;
CREATE CAST (float8 as bit) WITH FUNCTION bitfromfloat8(float8, int4) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bitfromdate(date, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bitfromdate(date, int4) 
RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromdate';
DROP CAST IF EXISTS (date as bit) CASCADE;
CREATE CAST (date as bit) WITH FUNCTION bitfromdate(date, int4) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bitfromdatetime(timestamp without time zone, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bitfromdatetime(timestamp without time zone, int4) 
RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromdatetime';
DROP CAST IF EXISTS (timestamp without time zone as bit) CASCADE;
CREATE CAST (timestamp without time zone as bit) WITH FUNCTION bitfromdatetime(timestamp without time zone, int4) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bitfromtimestamp(timestamptz, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bitfromtimestamp(timestamptz, int4) 
RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromtimestamp';
DROP CAST IF EXISTS (timestamptz as bit) CASCADE;
CREATE CAST (timestamptz as bit) WITH FUNCTION bitfromtimestamp(timestamptz, int4) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bitfromtime(time, int4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bitfromtime(time, int4) 
RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromtime';
DROP CAST IF EXISTS (time as bit) CASCADE;
CREATE CAST (time as bit) WITH FUNCTION bitfromtime(time, int4) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.set(bit, int4) CASCADE; 
CREATE OR REPLACE FUNCTION pg_catalog.set (bit, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittoset';
DROP CAST IF EXISTS (bit AS anyset) CASCADE;
CREATE CAST (bit AS anyset) WITH FUNCTION pg_catalog.set(bit, int4) AS ASSIGNMENT;

--dolphin_time_functions.sql
DROP FUNCTION IF EXISTS pg_catalog.int8_year (int1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int16_year (int2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int64_year (int8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.year_int8 (year) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.year_int16 (year) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.year_int64 (year) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.numeric_year (numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.float4_year (float4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.float8_year (float8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bit_year (bit) CASCADE;

DROP CAST IF EXISTS (int1 AS year) CASCADE;
DROP CAST IF EXISTS (int2 AS year) CASCADE;
DROP CAST IF EXISTS (int8 AS year) CASCADE;
DROP CAST IF EXISTS (year AS int1) CASCADE;
DROP CAST IF EXISTS (year AS int2) CASCADE;
DROP CAST IF EXISTS (year AS int8) CASCADE;
DROP CAST IF EXISTS (numeric AS year) CASCADE;
DROP CAST IF EXISTS (float4 AS year) CASCADE;
DROP CAST IF EXISTS (float8 AS year) CASCADE;
DROP CAST IF EXISTS (bit AS year) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.int8_year (int1) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_year';
CREATE CAST(int1 AS year) WITH FUNCTION int8_year(int1) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.int16_year (int2) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_year';
CREATE CAST(int2 AS year) WITH FUNCTION int16_year(int2) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.int64_year (int8) RETURNS year LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_year';
CREATE CAST(int8 AS year) WITH FUNCTION int64_year(int8) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.year_int8 (year) RETURNS int1 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_int8';
CREATE CAST(year AS int1) WITH FUNCTION year_int8(year) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.year_int16 (year) RETURNS int2 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_int16';
CREATE CAST(year AS int2) WITH FUNCTION year_int16(year) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.year_int64 (year) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'year_int64';
CREATE CAST(year AS int8) WITH FUNCTION year_int64(year) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.numeric_year (numeric) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST(numeric AS year) WITH FUNCTION numeric_year(numeric) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.float4_year (float4) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST(float4 AS year) WITH FUNCTION float4_year(float4) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.float8_year (float8) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST(float8 AS year) WITH FUNCTION float8_year(float8) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.bit_year (bit) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST(bit AS year) WITH FUNCTION bit_year(bit) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_date (int1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_date (int2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int64_b_format_date (int8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.numeric_b_format_date (numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.float8_b_format_date (float8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.float4_b_format_date (float4) CASCADE;

DROP CAST IF EXISTS (int1 AS date) CASCADE;
DROP CAST IF EXISTS (int2 AS date) CASCADE;
DROP CAST IF EXISTS (int8 AS date) CASCADE;
DROP CAST IF EXISTS (numeric AS date) CASCADE;
DROP CAST IF EXISTS (float8 AS date) CASCADE;
DROP CAST IF EXISTS (float4 AS date) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_date (int1) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_b_format_date';
CREATE CAST(int1 AS date) WITH FUNCTION int8_b_format_date(int1) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_date (int2) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_b_format_date';
CREATE CAST(int2 AS date) WITH FUNCTION int16_b_format_date(int2) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_date (int8) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_b_format_date';
CREATE CAST(int8 AS date) WITH FUNCTION int64_b_format_date(int8) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.numeric_b_format_date (numeric) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_b_format_date';
CREATE CAST(numeric AS date) WITH FUNCTION numeric_b_format_date(numeric) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.float8_b_format_date (float8) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float8_b_format_date';
CREATE CAST(float8 AS date) WITH FUNCTION float8_b_format_date(float8) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.float4_b_format_date (float4) RETURNS date LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as float8) as date)';
CREATE CAST(float4 AS date) WITH FUNCTION float4_b_format_date(float4) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bittodate(bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bittodate(bit) 
RETURNS date LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as int8) as date)';
DROP CAST IF EXISTS (bit AS date) CASCADE;
CREATE CAST (bit AS date) WITH FUNCTION bittodate(bit) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bittodatetime(bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bittodatetime(bit) 
RETURNS timestamp without time zone LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as int8) as timestamp without time zone)';
DROP CAST IF EXISTS (bit AS timestamp without time zone) CASCADE;
CREATE CAST (bit AS timestamp without time zone) WITH FUNCTION bittodatetime(bit) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bittotimestamp(bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bittotimestamp(bit) 
RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as int8) as timestamptz)';
DROP CAST IF EXISTS (bit AS timestamptz) CASCADE;
CREATE CAST (bit AS timestamptz) WITH FUNCTION bittotimestamp(bit) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bittotime(bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bittotime(bit) 
RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as int8) as time)';
DROP CAST IF EXISTS (bit AS time) CASCADE;
CREATE CAST (bit AS time) WITH FUNCTION bittotime(bit) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_time (int1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_time (int2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.float8_b_format_time (float8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.float4_b_format_time (float4) CASCADE;

DROP CAST IF EXISTS (int1 AS time) CASCADE;
DROP CAST IF EXISTS (int2 AS time) CASCADE;
DROP CAST IF EXISTS (float8 AS time) CASCADE;
DROP CAST IF EXISTS (float4 AS time) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_time (int1) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_b_format_time';
CREATE CAST(int1 AS time) WITH FUNCTION int8_b_format_time(int1) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_time (int2) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_b_format_time';
CREATE CAST(int2 AS time) WITH FUNCTION int16_b_format_time(int2) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.float8_b_format_time (float8) RETURNS time LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float8_b_format_time';
CREATE CAST(float8 AS time) WITH FUNCTION float8_b_format_time(float8) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.float4_b_format_time (float4) RETURNS time LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as float8) as time)';
CREATE CAST(float4 AS time) WITH FUNCTION float4_b_format_time(float4) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_datetime (int1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_datetime (int2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.float8_b_format_datetime (float8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.float4_b_format_datetime (float4) CASCADE;

DROP CAST IF EXISTS (int1 AS timestamp(0) without time zone) CASCADE;
DROP CAST IF EXISTS (int2 AS timestamp(0) without time zone) CASCADE;
DROP CAST IF EXISTS (float8 AS timestamp(0) without time zone) CASCADE;
DROP CAST IF EXISTS (float4 AS timestamp(0) without time zone) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_datetime (int1) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_b_format_datetime';
CREATE CAST(int1 AS timestamp(0) without time zone) WITH FUNCTION int8_b_format_datetime(int1) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_datetime (int2) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_b_format_datetime';
CREATE CAST(int2 AS timestamp(0) without time zone) WITH FUNCTION int16_b_format_datetime(int2) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.float8_b_format_datetime (float8) RETURNS timestamp(0) without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float8_b_format_datetime';
CREATE CAST(float8 AS timestamp(0) without time zone) WITH FUNCTION float8_b_format_datetime(float8) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.float4_b_format_datetime (float4) RETURNS timestamp(0) without time zone LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as float8) as timestamp(0) without time zone)';
CREATE CAST(float4 AS timestamp(0) without time zone) WITH FUNCTION float4_b_format_datetime(float4) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_timestamp (int1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_timestamp (int2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.float8_b_format_timestamp (float8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.float4_b_format_timestamp (float4) CASCADE;


DROP CAST IF EXISTS (int1 AS timestamptz) CASCADE;
DROP CAST IF EXISTS (int2 AS timestamptz) CASCADE;
DROP CAST IF EXISTS (float8 AS timestamptz) CASCADE;
DROP CAST IF EXISTS (float4 AS timestamptz) CASCADE;


CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_timestamp (int1) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_b_format_timestamp';
CREATE CAST(int1 AS timestamptz) WITH FUNCTION int8_b_format_timestamp(int1) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_timestamp (int2) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_b_format_timestamp';
CREATE CAST(int2 AS timestamptz) WITH FUNCTION int16_b_format_timestamp(int2) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.float8_b_format_timestamp (float8) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float8_b_format_timestamp';
CREATE CAST(float8 AS timestamptz) WITH FUNCTION float8_b_format_timestamp(float8) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.float4_b_format_timestamp (float4) RETURNS timestamptz LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as float8) as timestamptz)';
CREATE CAST(float4 AS timestamptz) WITH FUNCTION float4_b_format_timestamp(float4) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.time_int1 (time) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.time_int2 (time) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.time_float4 (time) CASCADE;

DROP CAST IF EXISTS (time AS int1) CASCADE;
DROP CAST IF EXISTS (time AS int2) CASCADE;
DROP CAST IF EXISTS (time AS float4) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.time_int1 (time) RETURNS int1 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.time_float($1) as int1)';
CREATE CAST(time AS int1) WITH FUNCTION time_int1(time) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.time_int2 (time) RETURNS int2 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.time_float($1) as int2)';
CREATE CAST(time AS int2) WITH FUNCTION time_int2(time) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.time_float4 (time) RETURNS float4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.time_float($1) as float4)';
CREATE CAST(time AS float4) WITH FUNCTION time_float4(time) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.datetime_int1 (timestamp(0) without time zone) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.datetime_int2 (timestamp(0) without time zone) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.datetime_int4 (timestamp(0) without time zone) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.datetime_float4 (timestamp(0) without time zone) CASCADE;

DROP CAST IF EXISTS (timestamp(0) without time zone AS int1) CASCADE;
DROP CAST IF EXISTS (timestamp(0) without time zone AS int2) CASCADE;
DROP CAST IF EXISTS (timestamp(0) without time zone AS int4) CASCADE;
DROP CAST IF EXISTS (timestamp(0) without time zone AS float4) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.datetime_int1 (timestamp(0) without time zone) RETURNS int1 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as int1)';
CREATE CAST(timestamp(0) without time zone AS int1) WITH FUNCTION datetime_int1(timestamp(0) without time zone) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.datetime_int2 (timestamp(0) without time zone) RETURNS int2 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as int2)';
CREATE CAST(timestamp(0) without time zone AS int2) WITH FUNCTION datetime_int2(timestamp(0) without time zone) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.datetime_int4 (timestamp(0) without time zone) RETURNS int4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as int4)';
CREATE CAST(timestamp(0) without time zone AS int4) WITH FUNCTION datetime_int4(timestamp(0) without time zone) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.datetime_float4 (timestamp(0) without time zone) RETURNS float4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as float4)';
CREATE CAST(timestamp(0) without time zone AS float4) WITH FUNCTION datetime_float4(timestamp(0) without time zone) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int1 ("timestamptz") CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int2 ("timestamptz") CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int4 ("timestamptz") CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_float4 ("timestamptz") CASCADE;

DROP CAST IF EXISTS ("timestamptz" AS int1) CASCADE;
DROP CAST IF EXISTS ("timestamptz" AS int2) CASCADE;
DROP CAST IF EXISTS ("timestamptz" AS int4) CASCADE;
DROP CAST IF EXISTS ("timestamptz" AS float4) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_int1 ("timestamptz") RETURNS int1 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as int1)';
CREATE CAST("timestamptz" AS int1) WITH FUNCTION timestamptz_int1("timestamptz") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_int2 ("timestamptz") RETURNS int2 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as int2)';
CREATE CAST("timestamptz" AS int2) WITH FUNCTION timestamptz_int2("timestamptz") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_int4 ("timestamptz") RETURNS int4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as int4)';
CREATE CAST("timestamptz" AS int4) WITH FUNCTION timestamptz_int4("timestamptz") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_float4 ("timestamptz") RETURNS float4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as float4)';
CREATE CAST("timestamptz" AS float4) WITH FUNCTION timestamptz_float4("timestamptz") AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.date2int1("date") cascade;
DROP FUNCTION IF EXISTS pg_catalog.date2int2("date") cascade;
DROP FUNCTION IF EXISTS pg_catalog.date2float4("date") cascade;
DROP FUNCTION IF EXISTS pg_catalog.year_float4("year") cascade;

DROP CAST IF EXISTS ("date" as int1) CASCADE;
DROP CAST IF EXISTS ("date" as int2) CASCADE;
DROP CAST IF EXISTS ("date" as float4) CASCADE;
DROP CAST IF EXISTS (year AS float4) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.date2int1("date") RETURNS int1 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::int1; $$;
CREATE CAST ("date" as int1) with function pg_catalog.date2int1("date") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.date2int2("date") RETURNS int2 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::int2; $$;
CREATE CAST ("date" as int2) with function pg_catalog.date2int2("date") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.date2float4("date") RETURNS float4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::float4; $$;
CREATE CAST ("date" as float4) with function pg_catalog.date2float4("date") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.year_float4("year") RETURNS float4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_float4';
CREATE CAST ("year" as float4) with function pg_catalog.year_float4("year") AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.year_date("year") cascade;
DROP FUNCTION IF EXISTS pg_catalog.year_datetime("year") cascade;
DROP FUNCTION IF EXISTS pg_catalog.year_timestamp("year") cascade;
DROP FUNCTION IF EXISTS pg_catalog.year_time("year") cascade;
DROP FUNCTION IF EXISTS pg_catalog.datetime_year(timestamp(0) without time zone) cascade;
DROP FUNCTION IF EXISTS pg_catalog.timestamp_year(timestamptz) cascade;
DROP FUNCTION IF EXISTS pg_catalog.time_year(time) cascade;
DROP FUNCTION IF EXISTS pg_catalog.date_year(date) cascade;
DROP FUNCTION IF EXISTS pg_catalog.date_time (date) cascade;
DROP FUNCTION IF EXISTS pg_catalog.time_date (time) cascade;
DROP FUNCTION IF EXISTS pg_catalog.time_datetime (time) cascade;
DROP FUNCTION IF EXISTS pg_catalog.time_timestamp (time) cascade;
DROP FUNCTION IF EXISTS pg_catalog.bpchar_timestamptz (char) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varchar_timestamptz (varchar) cascade;
DROP FUNCTION IF EXISTS pg_catalog.bpchar_time (char) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varchar_time (varchar) cascade;
DROP FUNCTION IF EXISTS pg_catalog.timestamp_bpchar (timestamp without time zone) cascade;
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_varchar (timestamptz) cascade;
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_bpchar (timestamptz) cascade;
DROP FUNCTION IF EXISTS pg_catalog.time_varchar (time) cascade;
DROP FUNCTION IF EXISTS pg_catalog.time_bpchar (time) cascade;
DROP FUNCTION IF EXISTS pg_catalog.bitfromyear(year, int4) cascade;
DROP FUNCTION IF EXISTS pg_catalog.set_date (anyset) cascade;
DROP FUNCTION IF EXISTS pg_catalog.set_datetime (anyset) cascade;
DROP FUNCTION IF EXISTS pg_catalog.set_timestamp (anyset) cascade;
DROP FUNCTION IF EXISTS pg_catalog.set_time (anyset) cascade;
DROP FUNCTION IF EXISTS pg_catalog.set_year (anyset) cascade;
DROP FUNCTION IF EXISTS pg_catalog.set (date, int4) cascade; 
DROP FUNCTION IF EXISTS pg_catalog.set(timestamp without time zone, int4) cascade; 
DROP FUNCTION IF EXISTS pg_catalog.set(timestamptz, int4) cascade; 
DROP FUNCTION IF EXISTS pg_catalog.set(time, int4) cascade; 
DROP FUNCTION IF EXISTS pg_catalog.set(year, int4) cascade;

DROP CAST IF EXISTS (year AS date) CASCADE;
DROP CAST IF EXISTS (year AS timestamp(0) without time zone) CASCADE;
DROP CAST IF EXISTS (year AS timestamptz) CASCADE;
DROP CAST IF EXISTS (year AS time) CASCADE;
DROP CAST IF EXISTS (timestamp(0) without time zone AS year) CASCADE;
DROP CAST IF EXISTS (timestamptz AS year) CASCADE;
DROP CAST IF EXISTS (time AS year) CASCADE;
DROP CAST IF EXISTS (date AS year) CASCADE;
DROP CAST IF EXISTS (date AS time) CASCADE;
DROP CAST IF EXISTS (time AS date) CASCADE;
DROP CAST IF EXISTS (time AS timestamp without time zone) CASCADE;
DROP CAST IF EXISTS (time AS timestamptz) CASCADE;
DROP CAST IF EXISTS (char AS timestamptz) CASCADE;
DROP CAST IF EXISTS (varchar AS timestamptz) CASCADE;
DROP CAST IF EXISTS (char as time) CASCADE;
DROP CAST IF EXISTS (varchar as time) CASCADE;
DROP CAST IF EXISTS (timestamp without time zone AS char) CASCADE;
DROP CAST IF EXISTS (timestamptz AS varchar) CASCADE;
DROP CAST IF EXISTS (timestamptz AS char) CASCADE;
DROP CAST IF EXISTS (time AS varchar) CASCADE;
DROP CAST IF EXISTS (time AS char) CASCADE;
DROP CAST IF EXISTS (year AS bit) CASCADE;
DROP CAST IF EXISTS (anyset as date) CASCADE;
DROP CAST IF EXISTS (anyset as timestamp without time zone) CASCADE;
DROP CAST IF EXISTS (anyset as timestamptz) CASCADE;
DROP CAST IF EXISTS (anyset as time) CASCADE;
DROP CAST IF EXISTS (anyset as year) CASCADE;
DROP CAST IF EXISTS (date AS anyset) CASCADE;
DROP CAST IF EXISTS (timestamp without time zone AS anyset) CASCADE;
DROP CAST IF EXISTS (timestamptz AS anyset) CASCADE;
DROP CAST IF EXISTS (time AS anyset) CASCADE;
DROP CAST IF EXISTS (year AS anyset) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.year_date("year") RETURNS date LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int4) as date)';
CREATE CAST ("year" as date) with function pg_catalog.year_date("year") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.year_datetime("year") RETURNS timestamp(0) without time zone LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int4) as timestamp(0) without time zone)';
CREATE CAST ("year" as timestamp(0) without time zone) with function pg_catalog.year_datetime("year") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.year_timestamp("year") RETURNS timestamptz LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int4) as timestamptz)';
CREATE CAST ("year" as timestamptz) with function pg_catalog.year_timestamp("year") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.year_time("year") RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int4) as time)';
CREATE CAST ("year" as time) with function pg_catalog.year_time("year") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.datetime_year(timestamp(0) without time zone) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST (timestamp(0) without time zone AS year) with function pg_catalog.datetime_year(timestamp(0) without time zone) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.timestamp_year(timestamptz) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST (timestamptz AS year) with function pg_catalog.timestamp_year(timestamptz) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.time_year(time) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST (time AS year) with function pg_catalog.time_year(time) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.date_year(date) RETURNS year LANGUAGE SQL STABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST (date AS year) with function pg_catalog.date_year(date) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.date_time (date) RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as timestamptz) as time)';
CREATE CAST(date AS time) WITH FUNCTION date_time(date) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.time_date (time) RETURNS date LANGUAGE SQL IMMUTABLE STRICT as 'select addtime(curdate()::timestamptz, $1)::date';
CREATE CAST(time AS date) WITH FUNCTION time_date(time) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.time_datetime (time) RETURNS timestamp without time zone LANGUAGE SQL IMMUTABLE STRICT as 'select addtime(curdate()::timestamp without time zone, $1)::timestamp without time zone';
CREATE CAST(time AS timestamp without time zone) WITH FUNCTION time_datetime(time) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.time_timestamp (time) RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as 'select addtime(curdate()::timestamptz, $1)::timestamptz';
CREATE CAST(time AS timestamptz) WITH FUNCTION time_timestamp(time) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.bpchar_timestamptz (char) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bpchar_timestamptz';
CREATE CAST(char AS timestamptz) WITH FUNCTION bpchar_timestamptz(char) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.varchar_timestamptz (varchar) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'varchar_timestamptz';
CREATE CAST(varchar AS timestamptz) WITH FUNCTION varchar_timestamptz(varchar) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.bpchar_time (char) RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as time)';
CREATE CAST(char as time) WITH FUNCTION bpchar_time(char) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.varchar_time (varchar) RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as time)';
CREATE CAST(varchar as time) WITH FUNCTION varchar_time(varchar) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.timestamp_bpchar (timestamp without time zone) RETURNS char LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_bpchar';
CREATE CAST(timestamp without time zone AS char) WITH FUNCTION timestamp_bpchar(timestamp without time zone) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_varchar (timestamptz) RETURNS varchar LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_varchar';
CREATE CAST(timestamptz AS varchar) WITH FUNCTION timestamptz_varchar(timestamptz) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_bpchar (timestamptz) RETURNS char LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_bpchar';
CREATE CAST(timestamptz AS char) WITH FUNCTION timestamptz_bpchar(timestamptz) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.time_varchar (time) RETURNS varchar LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_varchar';
CREATE CAST(time AS varchar) WITH FUNCTION time_varchar(time) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.time_bpchar (time) RETURNS char LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_bpchar';
CREATE CAST(time AS char) WITH FUNCTION time_bpchar(time) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.bitfromyear(year, int4) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromyear';
CREATE CAST (year as bit) WITH FUNCTION bitfromyear(year, int4) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set_date (anyset) RETURNS date LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as date)';
CREATE CAST(anyset as date) WITH FUNCTION set_date(anyset) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set_datetime (anyset) RETURNS timestamp without time zone LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as timestamp without time zone)';
CREATE CAST(anyset as timestamp without time zone) WITH FUNCTION set_datetime(anyset) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set_timestamp (anyset) RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as timestamptz)';
CREATE CAST(anyset as timestamptz) WITH FUNCTION set_timestamp(anyset) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set_time (anyset) RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as time)';
CREATE CAST(anyset as time) WITH FUNCTION set_time(anyset) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set_year (anyset) RETURNS year LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST(anyset as year) WITH FUNCTION set_year(anyset) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set (date, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'datetoset';
CREATE CAST (date AS anyset) WITH FUNCTION pg_catalog.set(date, int4) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set (timestamp without time zone, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'datetimetoset';
CREATE CAST (timestamp without time zone AS anyset) WITH FUNCTION pg_catalog.set(timestamp without time zone, int4) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set (timestamptz, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamptoset';
CREATE CAST (timestamptz AS anyset) WITH FUNCTION pg_catalog.set(timestamptz, int4) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set (time, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timetoset';
CREATE CAST (time AS anyset) WITH FUNCTION pg_catalog.set(time, int4) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set (year, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'yeartoset';
CREATE CAST (year AS anyset) WITH FUNCTION pg_catalog.set(year, int4) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.time_timestamptz_xor(time, timestamptz) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.timestamptz_time_xor(timestamptz, time) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.bool_date_xor(boolean, date) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.bool_timestamptz_xor(boolean, timestamptz) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_bool_xor(date, boolean) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.timestamptz_bool_xor(timestamptz, boolean) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_mi_time(nvarchar2, time) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_pl_time(nvarchar2, time) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_add_numeric(date, numeric) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_sub_numeric(date, numeric) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_mul_numeric(time, numeric) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_div_numeric(time, numeric) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.datetime_mul_numeric(timestamp without time zone, numeric) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.datetime_div_numeric(timestamp without time zone, numeric) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.datetime_mul_int4(timestamp without time zone, int4) CASCADE;

create function pg_catalog.time_timestamptz_xor(
    time,
    timestamptz
) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int8_timestamptz_xor($1::int8, $2) $$;

create function pg_catalog.timestamptz_time_xor(
    timestamptz,
    time
) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int8_timestamptz_xor($2::int8, $1) $$;

create function pg_catalog.bool_date_xor(
    boolean,
    date
) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int8_date_xor($1::int8, $2) $$;

create function pg_catalog.bool_timestamptz_xor(
    boolean,
    timestamptz
) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int8_timestamptz_xor($1::int8, $2) $$;

create function pg_catalog.date_bool_xor(
    date,
    boolean
) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.date_int8_xor($1, $2::int8) $$;

create function pg_catalog.timestamptz_bool_xor(
    timestamptz,
    boolean
) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.timestamptz_int8_xor($1, $2::int8) $$;

create function pg_catalog.nvarchar2_mi_time(
    nvarchar2,
    time
) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.datetime_mi_float($1::timestamp without time zone, $2::float8) $$;

create function pg_catalog.nvarchar2_pl_time(
    nvarchar2,
    time
) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.datetime_pl_float($1::timestamp without time zone, $2::float8) $$;

create function pg_catalog.date_add_numeric(
    date,
    numeric
) RETURNS date LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.date_pli($1, $2::int4) $$;

create function pg_catalog.date_sub_numeric(
    date,
    numeric
) RETURNS date LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.date_mii($1, $2::int4) $$;

create function pg_catalog.time_mul_numeric(
    time,
    numeric
) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8mul($1::float8, $2::float8) $$;

create function pg_catalog.time_div_numeric(
    time,
    numeric
) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8div($1::float8, $2::float8) $$;

create function pg_catalog.datetime_mul_numeric(
    timestamp without time zone,
    numeric
) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8mul($1::float8, $2::float8) $$;

create function pg_catalog.datetime_div_numeric(
    timestamp without time zone,
    numeric
) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8div($1::float8, $2::float8) $$;

create function pg_catalog.datetime_mul_int4(
    timestamp without time zone,
    int4
) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8mul($1::float8, $2::float8) $$;

create operator pg_catalog.^(leftarg = time, rightarg = timestampTz, procedure = pg_catalog.time_timestamptz_xor);
create operator pg_catalog.^(leftarg = timestampTz, rightarg = time, procedure = pg_catalog.timestamptz_time_xor);
create operator pg_catalog.^(leftarg = boolean, rightarg = date, procedure = pg_catalog.bool_date_xor);
create operator pg_catalog.^(leftarg = boolean, rightarg = timestamptz, procedure = pg_catalog.bool_timestamptz_xor);
create operator pg_catalog.^(leftarg = date, rightarg = boolean, procedure = pg_catalog.date_bool_xor);
create operator pg_catalog.^(leftarg = timestamptz, rightarg = boolean, procedure = pg_catalog.timestamptz_bool_xor);
create operator pg_catalog.-(leftarg = nvarchar2, rightarg = time, procedure = pg_catalog.nvarchar2_mi_time);
create operator pg_catalog.+(leftarg = nvarchar2, rightarg = time, procedure = pg_catalog.nvarchar2_pl_time);
create operator pg_catalog.+(leftarg = date, rightarg = numeric, procedure = pg_catalog.date_add_numeric);
create operator pg_catalog.-(leftarg = date, rightarg = numeric, procedure = pg_catalog.date_sub_numeric);
create operator pg_catalog.*(leftarg = time, rightarg = numeric, procedure = pg_catalog.time_mul_numeric);
create operator pg_catalog./(leftarg = time, rightarg = numeric, procedure = pg_catalog.time_div_numeric);
create operator pg_catalog.*(leftarg = timestamp without time zone, rightarg = numeric, procedure = pg_catalog.datetime_mul_numeric);
create operator pg_catalog./(leftarg = timestamp without time zone, rightarg = numeric, procedure = pg_catalog.datetime_div_numeric);
create operator pg_catalog.*(leftarg = timestamp without time zone, rightarg = int4, procedure = pg_catalog.datetime_mul_int4);

DROP FUNCTION IF EXISTS pg_catalog.b_db_date(date) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.dayname(date) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.b_db_last_day(date) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.week(date) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.yearweek(date) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.adddate(date, interval) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.date_add(date, interval) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.date_sub(date, interval) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.b_db_date(date) RETURNS date LANGUAGE SQL STABLE STRICT as 'select pg_catalog.b_db_date($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.dayname(date) RETURNS text LANGUAGE SQL STABLE STRICT as 'select pg_catalog.dayname($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.b_db_last_day(date) RETURNS date LANGUAGE SQL STABLE STRICT as 'select pg_catalog.b_db_last_day($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.week(date) RETURNS int4 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.week($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.yearweek(date) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.yearweek($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.adddate(date, interval) RETURNS text LANGUAGE SQL STABLE STRICT as 'select pg_catalog.adddate($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.date_add(date, interval) RETURNS text LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_add($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.date_sub(date, interval) RETURNS text LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_sub($1::text, $2)';

--enum.sql
DROP CAST IF EXISTS (anyenum as float8) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum2float8(anyenum) cascade;

DROP FUNCTION IF EXISTS pg_catalog.enum_float8(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_int1(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_int2(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_int4(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_int8(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_numeric(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_float4(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_bit(anyenum, int4) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_date(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_timestamp(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_timestamptz(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_time(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_year(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_set(anyenum, int4) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_json(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.text_enum(text, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.bpchar_enum(char, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varchar_enum(varchar, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varlena_enum(anyelement, int4) cascade;
DROP FUNCTION IF EXISTS pg_catalog.set_enum(anyset, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.date_enum(date, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.datetime_enum(timestamp without time zone, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.timestamp_enum(timestamptz, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.time_enum(time, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.int1_enum(int1, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.int2_enum(int2, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.int4_enum(int4, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.int8_enum(int8, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.float4_enum(float4, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.float8_enum(float8, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.numeric_enum(numeric, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.bit_enum(bit, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.year_enum(year, int4, anyelement) cascade;

CREATE OR REPLACE FUNCTION pg_catalog.enum_float8(anyenum) RETURNS float8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'Enum2Float8';

CREATE OR REPLACE FUNCTION pg_catalog.enum_int1(anyenum) RETURNS int1 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int1)';

CREATE OR REPLACE FUNCTION pg_catalog.enum_int2(anyenum) RETURNS int2 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int2)';

CREATE OR REPLACE FUNCTION pg_catalog.enum_int4(anyenum) RETURNS int4 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int4)';

CREATE OR REPLACE FUNCTION pg_catalog.enum_int8(anyenum) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int8)';

CREATE OR REPLACE FUNCTION pg_catalog.enum_numeric(anyenum) RETURNS numeric LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as numeric)';

CREATE OR REPLACE FUNCTION pg_catalog.enum_float4(anyenum) RETURNS float4 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as float4)';

CREATE OR REPLACE FUNCTION pg_catalog.enum_bit(anyenum, int4) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'Enum2Bit';

CREATE OR REPLACE FUNCTION pg_catalog.enum_date(anyenum) RETURNS date LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as date)';

CREATE OR REPLACE FUNCTION pg_catalog.enum_timestamp(anyenum) RETURNS timestamp without time zone LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as text) as timestamp without time zone)';

CREATE OR REPLACE FUNCTION pg_catalog.enum_timestamptz(anyenum) RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as text) as timestaptz)';

CREATE OR REPLACE FUNCTION pg_catalog.enum_time(anyenum) RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as time)';

CREATE OR REPLACE FUNCTION pg_catalog.enum_year(anyenum) RETURNS year LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int8) as year)';

CREATE OR REPLACE FUNCTION pg_catalog.enum_set(anyenum, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'enumtoset';

CREATE OR REPLACE FUNCTION pg_catalog.enum_json(anyenum) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'cast_json';


CREATE OR REPLACE FUNCTION pg_catalog.text_enum(text, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_enum';

CREATE OR REPLACE FUNCTION pg_catalog.bpchar_enum(char, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bpchar_enum';

CREATE OR REPLACE FUNCTION pg_catalog.varchar_enum(varchar, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varchar_enum';

CREATE OR REPLACE FUNCTION pg_catalog.varlena_enum(anyelement, int4) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varlena_enum';

CREATE OR REPLACE FUNCTION pg_catalog.set_enum(anyset, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'set_enum';

CREATE OR REPLACE FUNCTION pg_catalog.date_enum(date, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'date_enum';

CREATE OR REPLACE FUNCTION pg_catalog.datetime_enum(timestamp without time zone, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'datetime_enum';

CREATE OR REPLACE FUNCTION pg_catalog.timestamp_enum(timestamptz, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamp_enum';

CREATE OR REPLACE FUNCTION pg_catalog.time_enum(time, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time_enum';

CREATE OR REPLACE FUNCTION pg_catalog.int1_enum(int1, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_enum';

CREATE OR REPLACE FUNCTION pg_catalog.int2_enum(int2, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_enum';

CREATE OR REPLACE FUNCTION pg_catalog.int4_enum(int4, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_enum';

CREATE OR REPLACE FUNCTION pg_catalog.int8_enum(int8, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_enum';

CREATE OR REPLACE FUNCTION pg_catalog.float4_enum(float4, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'float4_enum';

CREATE OR REPLACE FUNCTION pg_catalog.float8_enum(float8, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'float8_enum';

CREATE OR REPLACE FUNCTION pg_catalog.numeric_enum(numeric, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'numeric_enum';

CREATE OR REPLACE FUNCTION pg_catalog.bit_enum(bit, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bit_enum';

CREATE OR REPLACE FUNCTION pg_catalog.year_enum(year, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'year_enum';

--json.sql
DROP FUNCTION IF EXISTS pg_catalog.int1_json(int1) cascade;
DROP FUNCTION IF EXISTS pg_catalog.int2_json(int2) cascade;
DROP FUNCTION IF EXISTS pg_catalog.int4_json(int4) cascade;
DROP FUNCTION IF EXISTS pg_catalog.int8_json(int8) cascade;
DROP FUNCTION IF EXISTS pg_catalog.float4_json(float4) cascade;
DROP FUNCTION IF EXISTS pg_catalog.float8_json(float8) cascade;
DROP FUNCTION IF EXISTS pg_catalog.numeric_json(numeric) cascade;
DROP FUNCTION IF EXISTS pg_catalog.date_json(date) cascade;
DROP FUNCTION IF EXISTS pg_catalog.datetime_json(timestamp without time zone) cascade;
DROP FUNCTION IF EXISTS pg_catalog.timestamp_json(timestamptz) cascade;
DROP FUNCTION IF EXISTS pg_catalog.time_json(time) cascade;
DROP FUNCTION IF EXISTS pg_catalog.year_json(year) cascade;
DROP FUNCTION IF EXISTS pg_catalog.set_json(anyset) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_varlena(anyenum) cascade;

DROP CAST IF EXISTS (int1 as json) cascade;
DROP CAST IF EXISTS (int2 as json) cascade;
DROP CAST IF EXISTS (int4 as json) cascade;
DROP CAST IF EXISTS (int8 as json) cascade;
DROP CAST IF EXISTS (float4 as json) cascade;
DROP CAST IF EXISTS (float8 as json) cascade;
DROP CAST IF EXISTS (numeric as json) cascade;
DROP CAST IF EXISTS (date as json) cascade;
DROP CAST IF EXISTS (timestamp without time zone as json) cascade;
DROP CAST IF EXISTS (timestamptz as json) cascade;
DROP CAST IF EXISTS (time as json) cascade;
DROP CAST IF EXISTS (year as json) cascade;
DROP CAST IF EXISTS (anyset as json) cascade;



CREATE OR REPLACE FUNCTION pg_catalog.int1_json(int1) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (int1 as json) WITH FUNCTION pg_catalog.int1_json(int1);

CREATE OR REPLACE FUNCTION pg_catalog.int2_json(int2) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (int2 as json) WITH FUNCTION pg_catalog.int2_json(int2);

CREATE OR REPLACE FUNCTION pg_catalog.int4_json(int4) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (int4 as json) WITH FUNCTION pg_catalog.int4_json(int4);

CREATE OR REPLACE FUNCTION pg_catalog.int8_json(int8) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (int8 as json) WITH FUNCTION pg_catalog.int8_json(int8);

CREATE OR REPLACE FUNCTION pg_catalog.float4_json(float4) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (float4 as json) WITH FUNCTION pg_catalog.float4_json(float4);

CREATE OR REPLACE FUNCTION pg_catalog.float8_json(float8) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (float8 as json) WITH FUNCTION pg_catalog.float8_json(float8);

CREATE OR REPLACE FUNCTION pg_catalog.numeric_json(numeric) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (numeric as json) WITH FUNCTION pg_catalog.numeric_json(numeric);

CREATE OR REPLACE FUNCTION pg_catalog.date_json(date) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (date as json) WITH FUNCTION pg_catalog.date_json(date);

CREATE OR REPLACE FUNCTION pg_catalog.datetime_json(timestamp without time zone) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (timestamp without time zone as json) WITH FUNCTION pg_catalog.datetime_json(timestamp without time zone);

CREATE OR REPLACE FUNCTION pg_catalog.timestamp_json(timestamptz) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (timestamptz as json) WITH FUNCTION pg_catalog.timestamp_json(timestamptz);

CREATE OR REPLACE FUNCTION pg_catalog.time_json(time) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (time as json) WITH FUNCTION pg_catalog.time_json(time);

CREATE OR REPLACE FUNCTION pg_catalog.year_json(year) RETURNS json LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int4) as json)';
CREATE CAST (year as json) WITH FUNCTION pg_catalog.year_json(year);

CREATE OR REPLACE FUNCTION pg_catalog.set_json(anyset) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (anyset as json) WITH FUNCTION pg_catalog.set_json(anyset);

CREATE OR REPLACE FUNCTION pg_catalog.enum_varlena(anyenum) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';

--to_base64.sql
DROP FUNCTION IF EXISTS pg_catalog.bit_json (bit) CASCADE;
DROP CAST IF EXISTS (bit as json);

CREATE OR REPLACE FUNCTION pg_catalog.bit_json(bit)
RETURNS json 
AS
$$
BEGIN
    RETURN (SELECT to_json(concat('base64:type16:', to_base64($1))));
END;
$$
LANGUAGE plpgsql;

CREATE CAST (bit as json) WITH FUNCTION pg_catalog.bit_json(bit);

--unsigned_int.sql
DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_date (uint1) cascade;
DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_date (uint2) cascade;

DROP CAST IF EXISTS (uint1 AS date) CASCADE;
DROP CAST IF EXISTS (uint2 AS date) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_date (uint1) 
RETURNS date LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_b_format_date';
CREATE CAST(uint1 AS date) WITH FUNCTION int8_b_format_date(uint1) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_date (uint2) 
RETURNS date LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int16_b_format_date';
CREATE CAST(uint2 AS date) WITH FUNCTION int16_b_format_date(uint2) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.int64_b_format_date (uint8) cascade;
DROP FUNCTION IF EXISTS pg_catalog.date2uint1("date") cascade;
DROP FUNCTION IF EXISTS pg_catalog.date2uint2("date") cascade;
DROP FUNCTION IF EXISTS pg_catalog.date2uint4("date") cascade;
DROP FUNCTION IF EXISTS pg_catalog.date2uint8("date") cascade;
DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_time(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_time(uint2) CASCADE;

DROP CAST IF EXISTS (uint8 AS date) CASCADE;
DROP CAST IF EXISTS ("date" as uint1) CASCADE;
DROP CAST IF EXISTS ("date" as uint2) CASCADE;
DROP CAST IF EXISTS ("date" as uint4) CASCADE;
DROP CAST IF EXISTS ("date" as uint8) CASCADE;
DROP CAST IF EXISTS (uint1 AS time) CASCADE;
DROP CAST IF EXISTS (uint2 AS time) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_date (uint8) 
RETURNS date LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int64_b_format_date';
CREATE CAST(uint8 AS date) WITH FUNCTION int64_b_format_date(uint8) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.date2uint1("date") RETURNS uint1 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::uint1; $$;
CREATE CAST ("date" as uint1) with function pg_catalog.date2uint1("date") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.date2uint2("date") RETURNS uint2 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::uint2; $$;
CREATE CAST ("date" as uint2) with function pg_catalog.date2uint2("date") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.date2uint4("date") RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::uint4; $$;
CREATE CAST ("date" as uint4) with function pg_catalog.date2uint4("date") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.date2uint8("date") RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT date_int8($1)::uint8; $$;
CREATE CAST ("date" as uint8) with function pg_catalog.date2uint8("date") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_time (
uint1
) RETURNS time LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_b_format_time';
CREATE CAST (uint1 AS time) WITH FUNCTION int8_b_format_time(uint1) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_time (
uint2
) RETURNS time LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint16_b_format_time';
CREATE CAST (uint2 AS time) WITH FUNCTION int16_b_format_time(uint2) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.int64_b_format_time(uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.time_uint1 (time) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.time_uint2 (time) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.time_uint4 (time) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.time_uint8 (time) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_datetime(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_datetime(uint2) CASCADE;

DROP CAST IF EXISTS (uint8 AS time) CASCADE;
DROP CAST IF EXISTS (time AS uint1) CASCADE;
DROP CAST IF EXISTS (time AS uint2) CASCADE;
DROP CAST IF EXISTS (time AS uint4) CASCADE;
DROP CAST IF EXISTS (time AS uint8) CASCADE;
DROP CAST IF EXISTS (uint1 AS timestamp(0) without time zone) CASCADE;
DROP CAST IF EXISTS (uint2 AS timestamp(0) without time zone) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.int64_b_format_time (
uint8
) RETURNS time LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint64_b_format_time';
CREATE CAST (uint8 AS time) WITH FUNCTION int64_b_format_time(uint8) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.int32_b_format_time (
uint4
) RETURNS time LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint32_b_format_time';

CREATE OR REPLACE FUNCTION pg_catalog.time_uint1 (time) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time2uint1';
CREATE CAST(time AS uint1) WITH FUNCTION time_uint1(time) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.time_uint2 (time) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time2uint2';
CREATE CAST(time AS uint2) WITH FUNCTION time_uint2(time) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.time_uint4 (time) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time2uint4';
CREATE CAST(time AS uint4) WITH FUNCTION time_uint4(time) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.time_uint8 (time) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time2uint8';
CREATE CAST(time AS uint8) WITH FUNCTION time_uint8(time) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_datetime (
uint1
) RETURNS timestamp(0) without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_b_format_datetime';
CREATE CAST (uint1 AS timestamp(0) without time zone) WITH FUNCTION int8_b_format_datetime(uint1) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_datetime (
uint2
) RETURNS timestamp(0) without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int16_b_format_datetime';
CREATE CAST (uint2 AS timestamp(0) without time zone) WITH FUNCTION int16_b_format_datetime(uint2) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.datetime_uint1 (timestamp(0) without time zone) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.datetime_uint2 (timestamp(0) without time zone) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.datetime_uint4 (timestamp(0) without time zone) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.datetime_uint8 (timestamp(0) without time zone) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int8_b_format_timestamp(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int16_b_format_timestamp(uint2) CASCADE;

DROP CAST IF EXISTS (timestamp(0) without time zone AS uint1) CASCADE;
DROP CAST IF EXISTS (timestamp(0) without time zone AS uint2) CASCADE;
DROP CAST IF EXISTS (timestamp(0) without time zone AS uint4) CASCADE;
DROP CAST IF EXISTS (timestamp(0) without time zone AS uint8) CASCADE;
DROP CAST IF EXISTS (uint1 AS timestamptz) CASCADE;
DROP CAST IF EXISTS (uint2 AS timestamptz) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.datetime_uint1 (timestamp(0) without time zone) RETURNS uint1 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as uint1)';
CREATE CAST(timestamp(0) without time zone AS uint1) WITH FUNCTION datetime_uint1(timestamp(0) without time zone) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.datetime_uint2 (timestamp(0) without time zone) RETURNS uint2 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as uint2)';
CREATE CAST(timestamp(0) without time zone AS uint2) WITH FUNCTION datetime_uint2(timestamp(0) without time zone) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.datetime_uint4 (timestamp(0) without time zone) RETURNS uint4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as uint4)';
CREATE CAST(timestamp(0) without time zone AS uint4) WITH FUNCTION datetime_uint4(timestamp(0) without time zone) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.datetime_uint8 (timestamp(0) without time zone) RETURNS uint8 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.datetime_float($1) as uint8)';
CREATE CAST(timestamp(0) without time zone AS uint8) WITH FUNCTION datetime_uint8(timestamp(0) without time zone) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.int8_b_format_timestamp (
uint1
) RETURNS timestamptz LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_b_format_timestamp';
CREATE CAST (uint1 AS timestamptz) WITH FUNCTION int8_b_format_timestamp(uint1) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.int16_b_format_timestamp (
uint2
) RETURNS timestamptz LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int16_b_format_timestamp';
CREATE CAST (uint2 AS timestamptz) WITH FUNCTION int16_b_format_timestamp(uint2) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.timestamptz_uint1 ("timestamptz") CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_uint2 ("timestamptz") CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_uint4 ("timestamptz") CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int8_year(uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.int16_year(uint2) CASCADE;

DROP CAST IF EXISTS ("timestamptz" AS uint1) CASCADE;
DROP CAST IF EXISTS ("timestamptz" AS uint2) CASCADE;
DROP CAST IF EXISTS ("timestamptz" AS uint4) CASCADE;
DROP CAST IF EXISTS (uint1 AS year) CASCADE;
DROP CAST IF EXISTS (uint2 AS year) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_uint1 ("timestamptz") RETURNS uint1 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as uint1)';
CREATE CAST("timestamptz" AS uint1) WITH FUNCTION timestamptz_uint1("timestamptz") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_uint2 ("timestamptz") RETURNS uint2 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as uint2)';
CREATE CAST("timestamptz" AS uint2) WITH FUNCTION timestamptz_uint2("timestamptz") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_uint4 ("timestamptz") RETURNS uint4 LANGUAGE SQL STABLE STRICT as 'select cast(pg_catalog.timestamptz_float8($1) as uint4)';
CREATE CAST("timestamptz" AS uint4) WITH FUNCTION timestamptz_uint4("timestamptz") AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.int8_year (
uint1
) RETURNS year LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_year';
CREATE CAST (uint1 AS year) WITH FUNCTION int8_year(uint1) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.int16_year (
uint2
) RETURNS year LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int16_year';
CREATE CAST (uint2 AS year) WITH FUNCTION int16_year(uint2) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.int64_year(uint8) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.year_uint1(year) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.year_uint2(year) CASCADE;

DROP CAST IF EXISTS (uint8 AS year) CASCADE;
DROP CAST IF EXISTS (year AS uint1) CASCADE;
DROP CAST IF EXISTS (year AS uint2) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.int64_year (
uint8
) RETURNS year LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int64_year';
CREATE CAST (uint8 AS year) WITH FUNCTION int64_year(uint8) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.year_uint1 (
year
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'year_int8';
CREATE CAST (year AS uint1) WITH FUNCTION year_uint1(year) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.year_uint2 (
year
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'year_int16';
CREATE CAST (year AS uint2) WITH FUNCTION year_uint2(year) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.uint1_json(uint1) cascade;
DROP FUNCTION IF EXISTS pg_catalog.uint2_json(uint2) cascade;
DROP FUNCTION IF EXISTS pg_catalog.uint4_json(uint4) cascade;
DROP FUNCTION IF EXISTS pg_catalog.uint8_json(uint8) cascade;

DROP CAST IF EXISTS (uint1 as json) cascade;
DROP CAST IF EXISTS (uint2 as json) cascade;
DROP CAST IF EXISTS (uint4 as json) cascade;
DROP CAST IF EXISTS (uint8 as json) cascade;

CREATE OR REPLACE FUNCTION pg_catalog.uint1_json(uint1) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (uint1 as json) WITH FUNCTION pg_catalog.uint1_json(uint1);

CREATE OR REPLACE FUNCTION pg_catalog.uint2_json(uint2) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (uint2 as json) WITH FUNCTION pg_catalog.uint2_json(uint2);

CREATE OR REPLACE FUNCTION pg_catalog.uint4_json(uint4) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (uint4 as json) WITH FUNCTION pg_catalog.uint4_json(uint4);

CREATE OR REPLACE FUNCTION pg_catalog.uint8_json(uint8) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';
CREATE CAST (uint8 as json) WITH FUNCTION pg_catalog.uint8_json(uint8);


DROP FUNCTION IF EXISTS pg_catalog.bittouint1(bit) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bittouint2(bit) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bitfromuint1(uint1, int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bitfromuint2(uint2, int4) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.bittouint1 (
bit
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittouint1';
CREATE OR REPLACE FUNCTION pg_catalog.bittouint2 (
bit
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittouint2';

CREATE OR REPLACE FUNCTION pg_catalog.bitfromuint1 (
uint1, int4
) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromuint1';
CREATE OR REPLACE FUNCTION pg_catalog.bitfromuint2 (
uint2, int4
) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bitfromuint2';

DROP CAST IF EXISTS (bit AS uint1) CASCADE;
DROP CAST IF EXISTS (bit AS uint2) CASCADE;
DROP CAST IF EXISTS (uint1 AS bit) CASCADE;
DROP CAST IF EXISTS (uint2 AS bit) CASCADE;

CREATE CAST (bit AS uint1) WITH FUNCTION bittouint1(bit) AS ASSIGNMENT;
CREATE CAST (bit AS uint2) WITH FUNCTION bittouint2(bit) AS ASSIGNMENT;
CREATE CAST (uint1 AS bit) WITH FUNCTION bitfromuint1(uint1, int4) AS ASSIGNMENT;
CREATE CAST (uint2 AS bit) WITH FUNCTION bitfromuint2(uint2, int4) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.bpchar_uint1 (char) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bpchar_uint2 (char) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bpchar_uint4 (char) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bpchar_uint8 (char) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.varchar_uint1 (varchar) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.varchar_uint2 (varchar) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.varchar_uint4 (varchar) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.varchar_uint8 (varchar) CASCADE;

DROP CAST IF EXISTS (char AS uint1) CASCADE;
DROP CAST IF EXISTS (char AS uint2) CASCADE;
DROP CAST IF EXISTS (char AS uint4) CASCADE;
DROP CAST IF EXISTS (char AS uint8) CASCADE;
DROP CAST IF EXISTS (varchar AS uint1) CASCADE;
DROP CAST IF EXISTS (varchar AS uint2) CASCADE;
DROP CAST IF EXISTS (varchar AS uint4) CASCADE;
DROP CAST IF EXISTS (varchar AS uint8) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.bpchar_uint1 (char) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bpchar_uint1';
CREATE CAST(char AS uint1) WITH FUNCTION bpchar_uint1(char) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.bpchar_uint2 (char) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bpchar_uint2';
CREATE CAST(char AS uint2) WITH FUNCTION bpchar_uint2(char) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.bpchar_uint4 (char) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bpchar_uint4';
CREATE CAST(char AS uint4) WITH FUNCTION bpchar_uint4(char) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.bpchar_uint8 (char) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bpchar_uint8';
CREATE CAST(char AS uint8) WITH FUNCTION bpchar_uint8(char) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.varchar_uint1 (varchar) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varchar_uint1';
CREATE CAST(varchar AS uint1) WITH FUNCTION varchar_uint1(varchar) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.varchar_uint2 (varchar) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varchar_uint2';
CREATE CAST(varchar AS uint2) WITH FUNCTION varchar_uint2(varchar) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.varchar_uint4 (varchar) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varchar_uint4';
CREATE CAST(varchar AS uint4) WITH FUNCTION varchar_uint4(varchar) AS IMPLICIT;

CREATE OR REPLACE FUNCTION pg_catalog.varchar_uint8 (varchar) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varchar_uint8';
CREATE CAST(varchar AS uint8) WITH FUNCTION varchar_uint8(varchar) AS IMPLICIT;


DROP FUNCTION IF EXISTS pg_catalog.settobit(anyset, int4) cascade;
DROP FUNCTION IF EXISTS pg_catalog.settoint1(anyset) cascade;
DROP FUNCTION IF EXISTS pg_catalog.settouint1(anyset) cascade;
DROP FUNCTION IF EXISTS pg_catalog.settouint2(anyset) cascade;
DROP FUNCTION IF EXISTS pg_catalog.settouint4(anyset) cascade;
DROP FUNCTION IF EXISTS pg_catalog.settouint8(anyset) cascade;

DROP CAST IF EXISTS (anyset AS bit) CASCADE;
DROP CAST IF EXISTS (anyset AS int1) CASCADE;
DROP CAST IF EXISTS (anyset AS uint1) CASCADE;
DROP CAST IF EXISTS (anyset AS uint2) CASCADE;
DROP CAST IF EXISTS (anyset AS uint4) CASCADE;
DROP CAST IF EXISTS (anyset AS uint8) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.settobit(anyset, int4) 
RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'settobit';
CREATE CAST (anyset AS bit) WITH FUNCTION settobit(anyset, int4) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.settoint1(anyset) 
RETURNS int1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'settoint1';
CREATE CAST (anyset AS int1) WITH FUNCTION settoint1(anyset) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.settouint1(anyset) 
RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'settouint1';
CREATE CAST (anyset AS uint1) WITH FUNCTION settouint1(anyset) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.settouint2(anyset) 
RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'settouint2';
CREATE CAST (anyset AS uint2) WITH FUNCTION settouint2(anyset) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.settouint4(anyset) 
RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'settouint4';
CREATE CAST (anyset AS uint4) WITH FUNCTION settouint4(anyset) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.settouint8(anyset) 
RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'settouint8';
CREATE CAST (anyset AS uint8) WITH FUNCTION settouint8(anyset) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.set(int1, int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.set(uint1, int4) CASCADE; 
DROP FUNCTION IF EXISTS pg_catalog.set(uint2, int4) CASCADE; 
DROP FUNCTION IF EXISTS pg_catalog.set(uint4, int4) CASCADE; 
DROP FUNCTION IF EXISTS pg_catalog.set(uint8, int4) CASCADE; 

DROP CAST IF EXISTS (int1 AS anyset) CASCADE;
DROP CAST IF EXISTS (uint1 AS anyset) CASCADE;
DROP CAST IF EXISTS (uint2 AS anyset) CASCADE;
DROP CAST IF EXISTS (uint4 AS anyset) CASCADE;
DROP CAST IF EXISTS (uint8 AS anyset) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.set (int1, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'i1toset';
CREATE CAST (int1 AS anyset) WITH FUNCTION pg_catalog.set(int1, int4) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set (uint1, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui1toset';
CREATE CAST (uint1 AS anyset) WITH FUNCTION pg_catalog.set(uint1, int4) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set (uint2, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui2toset';
CREATE CAST (uint2 AS anyset) WITH FUNCTION pg_catalog.set(uint2, int4) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set (uint4, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui4toset';
CREATE CAST (uint4 AS anyset) WITH FUNCTION pg_catalog.set(uint4, int4) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.set (uint8, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'ui8toset';
CREATE CAST (uint8 AS anyset) WITH FUNCTION pg_catalog.set(uint8, int4) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.uint1_enum(uint1, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.uint2_enum(uint2, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.uint4_enum(uint4, int4, anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.uint8_enum(uint8, int4, anyelement) cascade;

CREATE OR REPLACE FUNCTION pg_catalog.uint1_enum(uint1, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint1_enum';
CREATE OR REPLACE FUNCTION pg_catalog.uint2_enum(uint2, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint2_enum';
CREATE OR REPLACE FUNCTION pg_catalog.uint4_enum(uint4, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint4_enum';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_enum(uint8, int4, anyelement) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_enum';


DROP FUNCTION IF EXISTS pg_catalog.enum_uint1(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_uint2(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_uint4(anyenum) cascade;
DROP FUNCTION IF EXISTS pg_catalog.enum_uint8(anyenum) cascade;

CREATE OR REPLACE FUNCTION pg_catalog.enum_uint1(anyenum) RETURNS uint1 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as uint1)';
CREATE OR REPLACE FUNCTION pg_catalog.enum_uint2(anyenum) RETURNS uint2 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as uint2)';
CREATE OR REPLACE FUNCTION pg_catalog.enum_uint4(anyenum) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as uint4)';
CREATE OR REPLACE FUNCTION pg_catalog.enum_uint8(anyenum) RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as uint8)';


DROP FUNCTION IF EXISTS pg_catalog.date_int8_xor(
    date,
    uint8
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.int8_date_xor(
    uint8,
    date
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_int8_xor(
    time,
    uint8
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.int8_time_xor(
    uint8,
    time
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.datetime_int8_xor(
    timestamp without time zone,
    uint8
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.int8_datetime_xor(
    uint8,
    timestamp without time zone
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.timestamptz_int8_xor(
    timestampTz,
    uint8
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.int8_timestamptz_xor(
    uint8,
    timestampTz
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_uint1_eq(
    date,
    uint1
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_uint2_eq(
    date,
    uint2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_uint1_eq(
    time,
    uint1
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_uint2_eq(
    time,
    uint2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_uint1_ne(
    date,
    uint1
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_uint2_ne(
    date,
    uint2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_uint1_ne(
    time,
    uint1
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_uint2_ne(
    time,
    uint2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint1_date_ne(
    uint1,
    date
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint2_date_ne(
    uint2,
    date
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint1_time_ne(
    uint1,
    time
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint2_time_ne(
    uint2,
    time
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_uint1_lt(
    date,
    uint1
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_uint2_lt(
    date,
    uint2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_uint1_lt(
    time,
    uint1
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_uint2_lt(
    time,
    uint2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_uint1_gt(
    date,
    uint1
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_uint2_gt(
    date,
    uint2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_uint1_gt(
    time,
    uint1
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_uint2_gt(
    time,
    uint2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_uint1_le(
    date,
    uint1
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_uint2_le(
    date,
    uint2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_uint1_le(
    time,
    uint1
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_uint2_le(
    time,
    uint2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_uint1_ge(
    date,
    uint1
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.date_uint2_ge(
    date,
    uint2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_uint1_ge(
    time,
    uint1
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.time_uint2_ge(
    time,
    uint2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.int8_year_mod(
    int8,
    year
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.int8_or_nvarchar2(
    int8,
    nvarchar2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.int8_or_year(
    int8,
    year
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_or_int8(
    nvarchar2,
    int8
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.year_or_int8(
    year,
    int8
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.int8_xor_nvarchar2(
    int8,
    nvarchar2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.int8_xor_year(
    int8,
    year
) CASCADE;


DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_xor_int8(
    nvarchar2,
    int8
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.year_xor_int8(
    year,
    int8
) CASCADE;


DROP FUNCTION IF EXISTS pg_catalog.int8_and_nvarchar2(
    int8,
    nvarchar2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.int8_and_year(
    int8,
    year
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_and_int8(
    nvarchar2,
    int8
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.year_and_int8(
    year,
    int8
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint4_mod_year(
    uint4,
    year
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_or_uint4(
    nvarchar2,
    uint4
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint4_or_nvarchar2(
    uint4,
    nvarchar2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.year_or_uint4(
    year,
    uint4
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint4_or_year(
    uint4,
    year
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.year_xor_uint4(
    year,
    uint4
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint4_xor_year(
    uint4,
    year
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_and_uint4(
    nvarchar2,
    uint4
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint4_and_nvarchar2(
    uint4,
    nvarchar2
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.year_and_uint4(
    year,
    uint4
) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.uint4_and_year(
    uint4,
    year
) CASCADE;


create function pg_catalog.date_int8_xor(
    date,
    uint8
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_int8_xor';
create operator pg_catalog.^(leftarg = date, rightarg = uint8, procedure = pg_catalog.date_int8_xor);

create function pg_catalog.int8_date_xor(
    uint8,
    date
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_date_xor';
create operator pg_catalog.^(leftarg = uint8, rightarg = date, procedure = pg_catalog.int8_date_xor);

create function pg_catalog.time_int8_xor(
    time,
    uint8
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_int8_xor';
create operator pg_catalog.^(leftarg = time, rightarg = uint8, procedure = pg_catalog.time_int8_xor);

create function pg_catalog.int8_time_xor(
    uint8,
    time
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_time_xor';
create operator pg_catalog.^(leftarg = uint8, rightarg = time, procedure = pg_catalog.int8_time_xor);

create function pg_catalog.datetime_int8_xor(
    timestamp without time zone,
    uint8
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamp_int8_xor';
create operator pg_catalog.^(leftarg = timestamp without time zone, rightarg = uint8, procedure = pg_catalog.datetime_int8_xor);

create function pg_catalog.int8_datetime_xor(
    uint8,
    timestamp without time zone
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_timestamp_xor';
create operator pg_catalog.^(leftarg = uint8, rightarg = timestamp without time zone, procedure = pg_catalog.int8_datetime_xor);

create function pg_catalog.timestamptz_int8_xor(
    timestampTz,
    uint8
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptz_int8_xor';
create operator pg_catalog.^(leftarg = timestampTz, rightarg = uint8, procedure = pg_catalog.timestamptz_int8_xor);

create function pg_catalog.int8_timestamptz_xor(
    uint8,
    timestampTz
) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int8_timestamptz_xor';
create operator pg_catalog.^(leftarg = uint8, rightarg = timestampTz, procedure = pg_catalog.int8_timestamptz_xor);

create function pg_catalog.date_uint1_eq(
    date,
    uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.texteq($1::text, $2::text) $$;
create operator pg_catalog.=(leftarg = date, rightarg = uint1, procedure = pg_catalog.date_uint1_eq);

create function pg_catalog.date_uint2_eq(
    date,
    uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.texteq($1::text, $2::text) $$;
create operator pg_catalog.=(leftarg = date, rightarg = uint2, procedure = pg_catalog.date_uint2_eq);

create function pg_catalog.time_uint1_eq(
    time,
    uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8eq($1::float8, $2::float8) $$;
create operator pg_catalog.=(leftarg = time, rightarg = uint1, procedure = pg_catalog.time_uint1_eq);

create function pg_catalog.time_uint2_eq(
    time,
    uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8eq($1::float8, $2::float8) $$;
create operator pg_catalog.=(leftarg = time, rightarg = uint2, procedure = pg_catalog.time_uint2_eq);

create function pg_catalog.date_uint1_ne(
    date,
    uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textne($1::text, $2::text) $$;
create operator pg_catalog.<>(leftarg = date, rightarg = uint1, procedure = pg_catalog.date_uint1_ne);

create function pg_catalog.date_uint2_ne(
    date,
    uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textne($1::text, $2::text) $$;
create operator pg_catalog.<>(leftarg = date, rightarg = uint2, procedure = pg_catalog.date_uint2_ne);

create function pg_catalog.time_uint1_ne(
    time,
    uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ne($1::float8, $2::float8) $$;
create operator pg_catalog.<>(leftarg = time, rightarg = uint1, procedure = pg_catalog.time_uint1_ne);

create function pg_catalog.time_uint2_ne(
    time,
    uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ne($1::float8, $2::float8) $$;
create operator pg_catalog.<>(leftarg = time, rightarg = uint2, procedure = pg_catalog.time_uint2_ne);

create function pg_catalog.uint1_date_ne(
    uint1,
    date
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textne($1::text, $2::text) $$;
create operator pg_catalog.<>(leftarg = uint1, rightarg = date, procedure = pg_catalog.uint1_date_ne);

create function pg_catalog.uint2_date_ne(
    uint2,
    date
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textne($1::text, $2::text) $$;
create operator pg_catalog.<>(leftarg = uint2, rightarg = date, procedure = pg_catalog.uint2_date_ne);

create function pg_catalog.uint1_time_ne(
    uint1,
    time
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ne($1::text, $2::text) $$;
create operator pg_catalog.<>(leftarg = uint1, rightarg = time, procedure = pg_catalog.uint1_time_ne);

create function pg_catalog.uint2_time_ne(
    uint2,
    time
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ne($1::text, $2::text) $$;
create operator pg_catalog.<>(leftarg = uint2, rightarg = time, procedure = pg_catalog.uint2_time_ne);

create function pg_catalog.date_uint1_lt(
    date,
    uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_lt($1::text, $2::text) $$;
create operator pg_catalog.<(leftarg = date, rightarg = uint1, procedure = pg_catalog.date_uint1_lt);

create function pg_catalog.date_uint2_lt(
    date,
    uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_lt($1::text, $2::text) $$;
create operator pg_catalog.<(leftarg = date, rightarg = uint2, procedure = pg_catalog.date_uint2_lt);

create function pg_catalog.time_uint1_lt(
    time,
    uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
create operator pg_catalog.<(leftarg = time, rightarg = uint1, procedure = pg_catalog.time_uint1_lt);

create function pg_catalog.time_uint2_lt(
    time,
    uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
create operator pg_catalog.<(leftarg = time, rightarg = uint2, procedure = pg_catalog.time_uint2_lt);

create function pg_catalog.date_uint1_gt(
    date,
    uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_gt($1::text, $2::text) $$;
create operator pg_catalog.>(leftarg = date, rightarg = uint1, procedure = pg_catalog.date_uint1_gt);

create function pg_catalog.date_uint2_gt(
    date,
    uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_gt($1::text, $2::text) $$;
create operator pg_catalog.>(leftarg = date, rightarg = uint2, procedure = pg_catalog.date_uint2_gt);

create function pg_catalog.time_uint1_gt(
    time,
    uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
create operator pg_catalog.>(leftarg = time, rightarg = uint1, procedure = pg_catalog.time_uint1_gt);

create function pg_catalog.time_uint2_gt(
    time,
    uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
create operator pg_catalog.>(leftarg = time, rightarg = uint2, procedure = pg_catalog.time_uint2_gt);

create function pg_catalog.date_uint1_le(
    date,
    uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_le($1::text, $2::text) $$;
create operator pg_catalog.<=(leftarg = date, rightarg = uint1, procedure = pg_catalog.date_uint1_le);

create function pg_catalog.date_uint2_le(
    date,
    uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_le($1::text, $2::text) $$;
create operator pg_catalog.<=(leftarg = date, rightarg = uint2, procedure = pg_catalog.date_uint2_le);

create function pg_catalog.time_uint1_le(
    time,
    uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
create operator pg_catalog.<=(leftarg = time, rightarg = uint1, procedure = pg_catalog.time_uint1_le);

create function pg_catalog.time_uint2_le(
    time,
    uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
create operator pg_catalog.<=(leftarg = time, rightarg = uint2, procedure = pg_catalog.time_uint2_le);

create function pg_catalog.date_uint1_ge(
    date,
    uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_ge($1::text, $2::text) $$;
create operator pg_catalog.>=(leftarg = date, rightarg = uint1, procedure = pg_catalog.date_uint1_ge);

create function pg_catalog.date_uint2_ge(
    date,
    uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.text_ge($1::text, $2::text) $$;
create operator pg_catalog.>=(leftarg = date, rightarg = uint2, procedure = pg_catalog.date_uint2_ge);

create function pg_catalog.time_uint1_ge(
    time,
    uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
create operator pg_catalog.>=(leftarg = time, rightarg = uint1, procedure = pg_catalog.time_uint1_ge);

create function pg_catalog.time_uint2_ge(
    time,
    uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
create operator pg_catalog.>=(leftarg = time, rightarg = uint2, procedure = pg_catalog.time_uint2_ge);

create function pg_catalog.int8_year_mod(
    int8,
    year
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_int4_mod($1::uint4, $2::int4) $$;
create operator pg_catalog.%(leftarg = int8, rightarg = year, procedure = pg_catalog.int8_year_mod);

create function pg_catalog.int8_or_nvarchar2(
    int8,
    nvarchar2
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_or_int4($1::uint4, $2::int4) $$;
create operator pg_catalog.|(leftarg = int8, rightarg = nvarchar2, procedure = pg_catalog.int8_or_nvarchar2);

create function pg_catalog.int8_or_year(
    int8,
    year
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_or_int4($1::uint4, $2::int4) $$;
create operator pg_catalog.|(leftarg = int8, rightarg = year, procedure = pg_catalog.int8_or_year);

create function pg_catalog.nvarchar2_or_int8(
    nvarchar2,
    int8
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_or_uint4($1::int4, $2::uint4) $$;
create operator pg_catalog.|(leftarg = nvarchar2, rightarg = int8, procedure = pg_catalog.nvarchar2_or_int8);

create function pg_catalog.year_or_int8(
    year,
    int8
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_or_uint4($1::int4, $2::uint4) $$;
create operator pg_catalog.|(leftarg = year, rightarg = int8, procedure = pg_catalog.year_or_int8);

create function pg_catalog.int8_xor_nvarchar2(
    int8,
    nvarchar2
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_or_int4($1::uint4, $2::int4) $$;
create operator pg_catalog.#(leftarg = int8, rightarg = nvarchar2, procedure = pg_catalog.int8_xor_nvarchar2);

create function pg_catalog.int8_xor_year(
    int8,
    year
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_xor_int4($1::uint4, $2::int4) $$;
create operator pg_catalog.#(leftarg = int8, rightarg = year, procedure = pg_catalog.int8_xor_year);
create operator pg_catalog.^(leftarg = int8, rightarg = year, procedure = pg_catalog.int8_xor_year);

create function pg_catalog.nvarchar2_xor_int8(
    nvarchar2,
    int8
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_xor_uint4($1::int4, $2::uint4) $$;
create operator pg_catalog.#(leftarg = nvarchar2, rightarg = int8, procedure = pg_catalog.nvarchar2_xor_int8);

create function pg_catalog.year_xor_int8(
    year,
    int8
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_xor_uint4($1::int4, $2::uint4) $$;
create operator pg_catalog.#(leftarg = year, rightarg = int8, procedure = pg_catalog.year_xor_int8);
create operator pg_catalog.^(leftarg = year, rightarg = int8, procedure = pg_catalog.year_xor_int8);

create function pg_catalog.int8_and_nvarchar2(
    int8,
    nvarchar2
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_and_int4($1::uint4, $2::int4) $$;
create operator pg_catalog.&(leftarg = int8, rightarg = nvarchar2, procedure = pg_catalog.int8_and_nvarchar2);

create function pg_catalog.int8_and_year(
    int8,
    year
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_and_int4($1::uint4, $2::int4) $$;
create operator pg_catalog.&(leftarg = int8, rightarg = year, procedure = pg_catalog.int8_and_year);

create function pg_catalog.nvarchar2_and_int8(
    nvarchar2,
    int8
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_and_uint4($1::int4, $2::uint4) $$;
create operator pg_catalog.&(leftarg = nvarchar2, rightarg = int8, procedure = pg_catalog.nvarchar2_and_int8);

create function pg_catalog.year_and_int8(
    year,
    int8
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_and_uint4($1::int4, $2::uint4) $$;
create operator pg_catalog.&(leftarg = year, rightarg = int8, procedure = pg_catalog.year_and_int8);

create function pg_catalog.uint4_mod_year(
    uint4,
    year
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_int4_mod($1::uint4, $2::int4) $$;
create operator pg_catalog.%(leftarg = uint4, rightarg = year, procedure = pg_catalog.uint4_mod_year);

create function pg_catalog.nvarchar2_or_uint4(
    nvarchar2,
    uint4
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_or_uint4($1::int4, $2::uint4) $$;
create operator pg_catalog.|(leftarg = nvarchar2, rightarg = uint4, procedure = pg_catalog.nvarchar2_or_uint4);

create function pg_catalog.uint4_or_nvarchar2(
    uint4,
    nvarchar2
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_or_int4($1::uint4, $2::int4) $$;
create operator pg_catalog.|(leftarg = uint4, rightarg = nvarchar2, procedure = pg_catalog.uint4_or_nvarchar2);

create function pg_catalog.year_or_uint4(
    year,
    uint4
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_or_uint4($1::int4, $2::uint4) $$;
create operator pg_catalog.|(leftarg = year, rightarg = uint4, procedure = pg_catalog.year_or_uint4);

create function pg_catalog.uint4_or_year(
    uint4,
    year
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_or_int4($1::uint4, $2::int4) $$;
create operator pg_catalog.|(leftarg = uint4, rightarg = year, procedure = pg_catalog.uint4_or_year);

create function pg_catalog.year_xor_uint4(
    year,
    uint4
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_xor_uint4($1::int4, $2::uint4) $$;
create operator pg_catalog.^(leftarg = year, rightarg = uint4, procedure = pg_catalog.year_xor_uint4);

create function pg_catalog.uint4_xor_year(
    uint4,
    year
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_xor_int4($1::uint4, $2::int4) $$;
create operator pg_catalog.^(leftarg = uint4, rightarg = year, procedure = pg_catalog.uint4_xor_year);

create function pg_catalog.nvarchar2_and_uint4(
    nvarchar2,
    uint4
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_and_uint4($1::int4, $2::uint4) $$;
create operator pg_catalog.&(leftarg = nvarchar2, rightarg = uint4, procedure = pg_catalog.nvarchar2_and_uint4);

create function pg_catalog.uint4_and_nvarchar2(
    uint4,
    nvarchar2
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_and_int4($1::uint4, $2::int4) $$;
create operator pg_catalog.&(leftarg = uint4, rightarg = nvarchar2, procedure = pg_catalog.uint4_and_nvarchar2);

create function pg_catalog.year_and_uint4(
    year,
    uint4
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.int4_and_uint4($1::int4, $2::uint4) $$;
create operator pg_catalog.&(leftarg = year, rightarg = uint4, procedure = pg_catalog.year_and_uint4);

create function pg_catalog.uint4_and_year(
    uint4,
    year
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uint4_and_int4($1::uint4, $2::int4) $$;
create operator pg_catalog.&(leftarg = uint4, rightarg = year, procedure = pg_catalog.uint4_and_year);


--dolphin_binary_functions.sql

--DROP FUNCTION IF EXISTS pg_catalog.varbinary_in (cstring);
CREATE OR REPLACE FUNCTION pg_catalog.varbinary_in (
cstring
) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_binaryin';

--DROP FUNCTION IF EXISTS pg_catalog.bit2float4(bit);
CREATE OR REPLACE FUNCTION pg_catalog.bit2float4 (bit) RETURNS float4 AS
$$
BEGIN
    RETURN (SELECT bittouint8($1));
END;
$$
LANGUAGE plpgsql;

--DROP FUNCTION IF EXISTS pg_catalog.bit2float8(bit);
CREATE OR REPLACE FUNCTION pg_catalog.bit2float8 (bit) RETURNS float8 AS
$$
BEGIN
    RETURN (SELECT bittouint8($1));
END;
$$
LANGUAGE plpgsql;

--DROP FUNCTION IF EXISTS pg_catalog.bit_longblob(uint8,longblob);
CREATE OR REPLACE FUNCTION pg_catalog.bit_longblob (t1 uint8, t2 longblob) RETURNS uint8  AS
$$
DECLARE num NUMBER := to_number(cast(t2 as text));
BEGIN
    IF num > 9223372036854775807 then
        num = 9223372036854775807;
    ELSEIF num < -9223372036854775808 then
        num = 9223372036854775808;
    END IF;
    RETURN (SELECT uint8_xor(t1, num));
END;
$$
LANGUAGE plpgsql;

DROP CAST IF EXISTS (json AS float8) CASCADE;
CREATE CAST (json AS float8) WITH FUNCTION pg_catalog.varlena2float8(anyelement) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.varlena2int1(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varlena2int2(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varlena2int4(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varlena2int8(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varlena2float4(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varlena2numeric(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.Varlena2Bpchar(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.Varlena2Varchar(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.Varlena2Text(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.Varlena2Date(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.Varlena2Timestamptz(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.Varlena2Datetime(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.Varlena2Time(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.Varlena2Year(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.Varlena2Bit(anyelement, int4) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varlenatoset(anyelement, int4) cascade;

DROP CAST IF EXISTS ("binary" AS int1) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS int1) CASCADE;
DROP CAST IF EXISTS (blob AS int1) CASCADE;
DROP CAST IF EXISTS (tinyblob AS int1) CASCADE;
DROP CAST IF EXISTS (mediumblob AS int1) CASCADE;
DROP CAST IF EXISTS (longblob AS int1) CASCADE;
DROP CAST IF EXISTS (json AS int1) CASCADE;
DROP CAST IF EXISTS ("binary" AS int2) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS int2) CASCADE;
DROP CAST IF EXISTS (blob AS int2) CASCADE;
DROP CAST IF EXISTS (tinyblob AS int2) CASCADE;
DROP CAST IF EXISTS (mediumblob AS int2) CASCADE;
DROP CAST IF EXISTS (longblob AS int2) CASCADE;
DROP CAST IF EXISTS (json AS int2) CASCADE;
DROP CAST IF EXISTS ("binary" AS int4) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS int4) CASCADE;
DROP CAST IF EXISTS (blob AS int4) CASCADE;
DROP CAST IF EXISTS (tinyblob AS int4) CASCADE;
DROP CAST IF EXISTS (mediumblob AS int4) CASCADE;
DROP CAST IF EXISTS (longblob AS int4) CASCADE;
DROP CAST IF EXISTS (json AS int4) CASCADE;
DROP CAST IF EXISTS ("binary" AS int8) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS int8) CASCADE;
DROP CAST IF EXISTS (blob AS int8) CASCADE;
DROP CAST IF EXISTS (tinyblob AS int8) CASCADE;
DROP CAST IF EXISTS (mediumblob AS int8) CASCADE;
DROP CAST IF EXISTS (longblob AS int8) CASCADE;
DROP CAST IF EXISTS (json AS int8) CASCADE;
DROP CAST IF EXISTS ("binary" AS float4) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS float4) CASCADE;
DROP CAST IF EXISTS (blob AS float4) CASCADE;
DROP CAST IF EXISTS (tinyblob AS float4) CASCADE;
DROP CAST IF EXISTS (mediumblob AS float4) CASCADE;
DROP CAST IF EXISTS (longblob AS float4) CASCADE;
DROP CAST IF EXISTS (json AS float4) CASCADE;
DROP CAST IF EXISTS ("binary" AS numeric) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS numeric) CASCADE;
DROP CAST IF EXISTS (blob AS numeric) CASCADE;
DROP CAST IF EXISTS (tinyblob AS numeric) CASCADE;
DROP CAST IF EXISTS (mediumblob AS numeric) CASCADE;
DROP CAST IF EXISTS (longblob AS numeric) CASCADE;
DROP CAST IF EXISTS (json AS numeric) CASCADE;
DROP CAST IF EXISTS ("binary" AS char) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS char) CASCADE;
DROP CAST IF EXISTS (blob AS char) CASCADE;
DROP CAST IF EXISTS (tinyblob AS char) CASCADE;
DROP CAST IF EXISTS (mediumblob AS char) CASCADE;
DROP CAST IF EXISTS (longblob AS char) CASCADE;
DROP CAST IF EXISTS (json AS char) CASCADE;
DROP CAST IF EXISTS ("binary" AS varchar) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS varchar) CASCADE;
DROP CAST IF EXISTS (blob AS varchar) CASCADE;
DROP CAST IF EXISTS (tinyblob AS varchar) CASCADE;
DROP CAST IF EXISTS (mediumblob AS varchar) CASCADE;
DROP CAST IF EXISTS (longblob AS varchar) CASCADE;
DROP CAST IF EXISTS (json AS varchar) CASCADE;
DROP CAST IF EXISTS ("binary" AS text) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS text) CASCADE;
DROP CAST IF EXISTS (blob AS text) CASCADE;
DROP CAST IF EXISTS (tinyblob AS text) CASCADE;
DROP CAST IF EXISTS (mediumblob AS text) CASCADE;
DROP CAST IF EXISTS (longblob AS text) CASCADE;
DROP CAST IF EXISTS (json AS text) CASCADE;
DROP CAST IF EXISTS ("binary" AS date) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS date) CASCADE;
DROP CAST IF EXISTS (blob AS date) CASCADE;
DROP CAST IF EXISTS (tinyblob AS date) CASCADE;
DROP CAST IF EXISTS (mediumblob AS date) CASCADE;
DROP CAST IF EXISTS (longblob AS date) CASCADE;
DROP CAST IF EXISTS (json AS date) CASCADE;
DROP CAST IF EXISTS ("binary" AS timestamptz) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS timestamptz) CASCADE;
DROP CAST IF EXISTS (blob AS timestamptz) CASCADE;
DROP CAST IF EXISTS (tinyblob AS timestamptz) CASCADE;
DROP CAST IF EXISTS (mediumblob AS timestamptz) CASCADE;
DROP CAST IF EXISTS (longblob AS timestamptz) CASCADE;
DROP CAST IF EXISTS (json AS timestamptz) CASCADE;
DROP CAST IF EXISTS ("binary" AS timestamp without time zone) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS timestamp without time zone) CASCADE;
DROP CAST IF EXISTS (blob AS timestamp without time zone) CASCADE;
DROP CAST IF EXISTS (tinyblob AS timestamp without time zone) CASCADE;
DROP CAST IF EXISTS (mediumblob AS timestamp without time zone) CASCADE;
DROP CAST IF EXISTS (longblob AS timestamp without time zone) CASCADE;
DROP CAST IF EXISTS (json AS timestamp without time zone)CASCADE;
DROP CAST IF EXISTS ("binary" AS time) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS time) CASCADE;
DROP CAST IF EXISTS (blob AS time) CASCADE;
DROP CAST IF EXISTS (tinyblob AS time) CASCADE;
DROP CAST IF EXISTS (mediumblob AS time) CASCADE;
DROP CAST IF EXISTS (longblob AS time) CASCADE;
DROP CAST IF EXISTS (json AS time) CASCADE;
DROP CAST IF EXISTS ("binary" AS year) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS year) CASCADE;
DROP CAST IF EXISTS (blob AS year) CASCADE;
DROP CAST IF EXISTS (tinyblob AS year) CASCADE;
DROP CAST IF EXISTS (mediumblob AS year) CASCADE;
DROP CAST IF EXISTS (longblob AS year) CASCADE;
DROP CAST IF EXISTS (json AS year) CASCADE;
DROP CAST IF EXISTS ("binary" AS bit) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS bit) CASCADE;
DROP CAST IF EXISTS (blob AS bit) CASCADE;
DROP CAST IF EXISTS (tinyblob AS bit) CASCADE;
DROP CAST IF EXISTS (mediumblob AS bit) CASCADE;
DROP CAST IF EXISTS (longblob AS bit) CASCADE;
DROP CAST IF EXISTS (json AS bit) CASCADE;
DROP CAST IF EXISTS ("binary" AS anyset) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS anyset) CASCADE;
DROP CAST IF EXISTS (blob AS anyset) CASCADE;
DROP CAST IF EXISTS (tinyblob AS anyset) CASCADE;
DROP CAST IF EXISTS (mediumblob AS anyset) CASCADE;
DROP CAST IF EXISTS (longblob AS anyset) CASCADE;
DROP CAST IF EXISTS (json AS anyset) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.varlena2int1(anyelement) RETURNS int1 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int1)';

CREATE CAST ("binary" AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS int1) WITH FUNCTION pg_catalog.varlena2int1(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.varlena2int2(anyelement) RETURNS int2 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int2)';

CREATE CAST ("binary" AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS int2) WITH FUNCTION pg_catalog.varlena2int2(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.varlena2int4(anyelement) RETURNS int4 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int4)';

CREATE CAST ("binary" AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS int4) WITH FUNCTION pg_catalog.varlena2int4(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.varlena2int8(anyelement) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as int8)';

CREATE CAST ("binary" AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS int8) WITH FUNCTION pg_catalog.varlena2int8(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.varlena2float4(anyelement) RETURNS float4 LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as float8) as float4)';

CREATE CAST ("binary" AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS float4) WITH FUNCTION pg_catalog.varlena2float4(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.varlena2numeric(anyelement) RETURNS numeric LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'Varlena2Numeric';

CREATE CAST ("binary" AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS numeric) WITH FUNCTION pg_catalog.varlena2numeric(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Bpchar(anyelement) RETURNS char LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'Varlena2Bpchar';

CREATE CAST ("binary" AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Varchar(anyelement) RETURNS varchar LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'Varlena2Varchar';

CREATE CAST ("binary" AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Text(anyelement) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'Varlena2Text';

DROP CAST IF EXISTS (raw AS text);
CREATE CAST ("binary" AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS IMPLICIT;
CREATE CAST ("varbinary" AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS IMPLICIT;
CREATE CAST (raw AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS IMPLICIT;
CREATE CAST (blob AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS text) WITH FUNCTION pg_catalog.Varlena2Text(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Date(anyelement) RETURNS date LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as date)';

CREATE CAST ("binary" AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS date) WITH FUNCTION pg_catalog.Varlena2Date(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as text) as timestamptz)';

CREATE CAST ("binary" AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS timestamptz) WITH FUNCTION pg_catalog.Varlena2Timestamptz(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Datetime(anyelement) RETURNS timestamp without time zone LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as text) as timestamp without time zone)';

CREATE CAST ("binary" AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS timestamp without time zone) WITH FUNCTION pg_catalog.Varlena2Datetime(anyelement);


CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Time(anyelement) RETURNS time LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as text) as time)';

CREATE CAST ("binary" AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS time) WITH FUNCTION pg_catalog.Varlena2Time(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Year(anyelement) RETURNS year LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as text) as year)';

CREATE CAST ("binary" AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS year) WITH FUNCTION pg_catalog.Varlena2Year(anyelement) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'Varlena2Bit';

CREATE CAST ("binary" AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT;
CREATE CAST (blob AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT;
CREATE CAST (tinyblob AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT;
CREATE CAST (mediumblob AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT;
CREATE CAST (longblob AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT;
CREATE CAST (json AS bit) WITH FUNCTION pg_catalog.Varlena2Bit(anyelement, int4) AS ASSIGNMENT;


CREATE OR REPLACE FUNCTION pg_catalog.varlenatoset(anyelement, int4) RETURNS anyset LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varlenatoset';

CREATE CAST ("binary" AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT;
CREATE CAST (blob AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT;
CREATE CAST (tinyblob AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT;
CREATE CAST (mediumblob AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT;
CREATE CAST (longblob AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT;
CREATE CAST (json AS anyset) WITH FUNCTION pg_catalog.varlenatoset(anyelement, int4) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.varlena_json(anyelement) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.varlena_json(anyelement) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cast_json';

DROP FUNCTION IF EXISTS pg_catalog.to_base64 (tinyblob) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.to_base64 (blob) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.to_base64 (mediumblob) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.to_base64 (longblob) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (tinyblob)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode';
CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (blob)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode';
CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (mediumblob)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode';
CREATE OR REPLACE FUNCTION pg_catalog.to_base64 (longblob)  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'base64_encode';

DROP CAST IF EXISTS (binary as json) CASCADE;
DROP CAST IF EXISTS (varbinary as json) CASCADE;
DROP CAST IF EXISTS (tinyblob as json) CASCADE;
DROP CAST IF EXISTS (blob as json) CASCADE;
DROP CAST IF EXISTS (mediumblob as json) CASCADE;
DROP CAST IF EXISTS (longblob as json) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.binary_json(binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.varbinary_json(varbinary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.tinyblob_json(tinyblob) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.blob_json(blob) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.mediumblob_json(mediumblob) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.longblob_json(longblob) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.binary_json(binary)
RETURNS json 
AS
$$
BEGIN
    RETURN (SELECT to_json(concat('base64:type254:', to_base64($1))));
END;
$$
LANGUAGE plpgsql;
CREATE CAST (binary as json) WITH FUNCTION pg_catalog.binary_json(binary);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_json(varbinary)
RETURNS json 
AS
$$
BEGIN
    RETURN (SELECT to_json(concat('base64:type15:', to_base64($1))));
END;
$$
LANGUAGE plpgsql;
CREATE CAST (varbinary as json) WITH FUNCTION pg_catalog.varbinary_json(varbinary);

CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_json(tinyblob)
RETURNS json 
AS
$$
BEGIN
    RETURN (SELECT to_json(concat('base64:type249:', to_base64($1))));
END;
$$
LANGUAGE plpgsql;
CREATE CAST (tinyblob as json) WITH FUNCTION pg_catalog.tinyblob_json(tinyblob);

CREATE OR REPLACE FUNCTION pg_catalog.blob_json(blob)
RETURNS json 
AS
$$
BEGIN
    RETURN (SELECT to_json(concat('base64:type252:', to_base64($1))));
END;
$$
LANGUAGE plpgsql;
CREATE CAST (blob as json) WITH FUNCTION pg_catalog.blob_json(blob);

CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_json(mediumblob)
RETURNS json 
AS
$$
BEGIN
    RETURN (SELECT to_json(concat('base64:type250:', to_base64($1))));
END;
$$
LANGUAGE plpgsql;
CREATE CAST (mediumblob as json) WITH FUNCTION pg_catalog.mediumblob_json(mediumblob);

CREATE OR REPLACE FUNCTION pg_catalog.longblob_json(longblob)
RETURNS json 
AS
$$
BEGIN
    RETURN (SELECT to_json(concat('base64:type251:', to_base64($1))));
END;
$$
LANGUAGE plpgsql;
CREATE CAST (longblob as json) WITH FUNCTION pg_catalog.longblob_json(longblob);


DROP FUNCTION IF EXISTS pg_catalog.bittobinary(bit) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bittovarbinary(bit) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bittotinyblob(bit) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bittomediumblob(bit) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bittoblob(bit) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bittolongblob(bit) CASCADE;

DROP CAST IF EXISTS (bit AS binary) CASCADE;
DROP CAST IF EXISTS (bit AS varbinary) CASCADE;
DROP CAST IF EXISTS (bit AS tinyblob) CASCADE;
DROP CAST IF EXISTS (bit AS mediumblob) CASCADE;
DROP CAST IF EXISTS (bit AS blob) CASCADE;
DROP CAST IF EXISTS (bit AS longblob) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.bittobinary(bit) 
RETURNS binary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittobinary';
CREATE CAST (bit AS binary) WITH FUNCTION bittobinary(bit) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.bittovarbinary(bit) 
RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittovarbinary';
CREATE CAST (bit AS varbinary) WITH FUNCTION bittovarbinary(bit) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.bittotinyblob(bit) 
RETURNS tinyblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittotinyblob';
CREATE CAST (bit AS tinyblob) WITH FUNCTION bittotinyblob(bit) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.bittomediumblob(bit) 
RETURNS mediumblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittomediumblob';
CREATE CAST (bit AS mediumblob) WITH FUNCTION bittomediumblob(bit) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.bittoblob(bit) 
RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittoblob';
CREATE CAST (bit AS blob) WITH FUNCTION bittoblob(bit) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.bittolongblob(bit) 
RETURNS longblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bittolongblob';
CREATE CAST (bit AS longblob) WITH FUNCTION bittolongblob(bit) AS ASSIGNMENT;


DROP FUNCTION IF EXISTS pg_catalog.blob_date_xor(
    blob,
    date
) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.date_blob_xor(
    date,
    blob
) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.blob_timestamptz_xor(
    blob,
    timestamptz
) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_blob_xor(
    timestamptz,
    blob
) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.time_xor_bit(
    time,
    bit
) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bit_xor_time(
    bit,
    time
) CASCADE;

create function pg_catalog.blob_date_xor(
    blob,
    date
) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8_date_xor($1::float8, $2) $$;
create operator pg_catalog.^(leftarg = blob, rightarg = date, procedure = pg_catalog.blob_date_xor);

create function pg_catalog.date_blob_xor(
    date,
    blob
) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.date_float8_xor($1, $2::float8) $$;
create operator pg_catalog.^(leftarg = date, rightarg = blob, procedure = pg_catalog.date_blob_xor);

create function pg_catalog.blob_timestamptz_xor(
    blob,
    timestamptz
) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8_timestamptz_xor($1::float8, $2) $$;
create operator pg_catalog.^(leftarg = blob, rightarg = timestamptz, procedure = pg_catalog.blob_timestamptz_xor);

create function pg_catalog.timestamptz_blob_xor(
    timestamptz,
    blob
) RETURNS int16 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.timestamptz_float8_xor($1, $2::float8) $$;
create operator pg_catalog.^(leftarg = timestamptz, rightarg = blob, procedure = pg_catalog.timestamptz_blob_xor);

create function pg_catalog.time_xor_bit(
    time,
    bit
) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.dpow($1::float8, $2::float8) $$;
create operator pg_catalog.^(leftarg = time, rightarg = bit, procedure = pg_catalog.time_xor_bit);

create function pg_catalog.bit_xor_time(
    bit,
    time
) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.dpow($1::float8, $2::float8) $$;
create operator pg_catalog.^(leftarg = bit, rightarg = time, procedure = pg_catalog.bit_xor_time);

--update_castcontext
DROP FUNCTION IF EXISTS pg_catalog.update_castcontext(varchar, varchar) CASCADE;
CREATE FUNCTION pg_catalog.update_castcontext(varchar, varchar) RETURNS varchar AS
$$
DECLARE
    s_type ALIAS FOR $1;
    t_type ALIAS FOR $2;
BEGIN
    update pg_cast set castcontext='i', castowner=10 where castsource=(select oid from pg_type where typname=s_type) and casttarget=(select oid from pg_type where typname=t_type);
    RETURN 'SUCCESS';
END;
$$
LANGUAGE plpgsql;

DO
$$
BEGIN
    PERFORM pg_catalog.update_castcontext('int8', 'int1');
    PERFORM pg_catalog.update_castcontext('int8', 'int2');
    PERFORM pg_catalog.update_castcontext('int8', 'int4');

    PERFORM pg_catalog.update_castcontext('date', 'int4');
    PERFORM pg_catalog.update_castcontext('date', 'int8');
    PERFORM pg_catalog.update_castcontext('date', 'uint4');
    PERFORM pg_catalog.update_castcontext('date', 'uint8');
    PERFORM pg_catalog.update_castcontext('date', 'float4');
    PERFORM pg_catalog.update_castcontext('date', 'float8');
    PERFORM pg_catalog.update_castcontext('date', 'numeric');
    PERFORM pg_catalog.update_castcontext('timestamp', 'int8');
    PERFORM pg_catalog.update_castcontext('timestamp', 'uint8');
    PERFORM pg_catalog.update_castcontext('timestamp', 'float4');
    PERFORM pg_catalog.update_castcontext('timestamp', 'numeric');
    PERFORM pg_catalog.update_castcontext('timestamptz', 'int8');
    PERFORM pg_catalog.update_castcontext('timestamptz', 'uint8');
    PERFORM pg_catalog.update_castcontext('timestamptz', 'float4');
    PERFORM pg_catalog.update_castcontext('timestamptz', 'float8');
    PERFORM pg_catalog.update_castcontext('timestamptz', 'numeric');
    PERFORM pg_catalog.update_castcontext('time', 'int4');
    PERFORM pg_catalog.update_castcontext('time', 'int8');
    PERFORM pg_catalog.update_castcontext('time', 'uint4');
    PERFORM pg_catalog.update_castcontext('time', 'uint8');
    PERFORM pg_catalog.update_castcontext('time', 'float4');
    PERFORM pg_catalog.update_castcontext('time', 'numeric');
END
$$
LANGUAGE plpgsql;
DROP FUNCTION IF EXISTS pg_catalog.oct(bit);
CREATE OR REPLACE FUNCTION pg_catalog.oct(bit) RETURNS text AS
$$
BEGIN
    RETURN 0;
END;
$$
LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.update_castcontext(varchar, varchar) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.ord(varbit);
CREATE FUNCTION pg_catalog.ord (varbit) RETURNS int16 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'ord_bit';

DROP FUNCTION IF EXISTS pg_catalog.substring_index (text, text, numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.substring_index (boolean, text, numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.substring_index (text, boolean, numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.substring_index (boolean, boolean, numeric) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.substring_index ("any", "any", text) CASCADE;
CREATE FUNCTION pg_catalog.substring_index (
"any",
"any",
text
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_text';

DROP FUNCTION IF EXISTS pg_catalog.substring_index ("any", "any", numeric) CASCADE;
CREATE FUNCTION pg_catalog.substring_index (
"any",
"any",
numeric
) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'substring_index_numeric';
DROP FUNCTION IF EXISTS pg_catalog.export_set (numeric, text, text, text, numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.export_set (numeric, text, text, text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.export_set (numeric, text, text) CASCADE;

DROP FUNCTION IF EXISTS pg_catalog.export_set (int16, "any", "any", "any", int8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.export_set (int16, "any", "any", "any", int8) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_5args_any';

DROP FUNCTION IF EXISTS pg_catalog.export_set (int16, "any", "any", "any") CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.export_set (int16, "any", "any", "any") RETURNS text LANGUAGE C STABLE STRICT  as '$libdir/dolphin', 'export_set_4args_any';

DROP FUNCTION IF EXISTS pg_catalog.export_set (int16, "any", "any") CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.export_set (int16, "any", "any")  RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_3args_any';

DROP FUNCTION IF EXISTS pg_catalog.export_set (bit, "any", "any", "any", bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.export_set (bit, "any", "any", "any", bit) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_5args_bits';

DROP FUNCTION IF EXISTS pg_catalog.export_set (bit, "any", "any", "any", int8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.export_set (bit, "any", "any", "any", int8) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_5args_bit_1';

DROP FUNCTION IF EXISTS pg_catalog.export_set (int16, "any", "any", "any", bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.export_set (int16, "any", "any", "any", bit) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_5args_bit_5';

DROP FUNCTION IF EXISTS pg_catalog.export_set (bit, "any", "any", "any") CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.export_set (bit, "any", "any", "any") RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_4args_bit';

DROP FUNCTION IF EXISTS pg_catalog.export_set (bit, "any", "any") CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.export_set (bit, "any", "any") RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'export_set_3args_bit';

DROP FUNCTION IF EXISTS pg_catalog.sleep(d date) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.sleep(d date)
RETURNS int AS
$$
BEGIN
    RETURN (select sleep(date_int(d)));
END;
$$
LANGUAGE plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.pg_open_tables() CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.pg_open_tables(TEXT) CASCADE;
CREATE FUNCTION pg_catalog.pg_open_tables()
    RETURNS TABLE ("oid" Oid, "relname" TEXT, "relnamespace" TEXT, "refcnt" int4, "lockcnt" int4, "accessexclusive_lockcnt" int4)
    LANGUAGE C VOLATILE STRICT as '$libdir/dolphin', 'pg_open_tables';
CREATE FUNCTION pg_catalog.pg_open_tables(TEXT)
    RETURNS TABLE ("oid" Oid, "relname" TEXT, "relnamespace" TEXT, "refcnt" int4, "lockcnt" int4, "accessexclusive_lockcnt" int4)
    LANGUAGE C VOLATILE STRICT as '$libdir/dolphin', 'pg_open_tables';

DROP FUNCTION IF EXISTS pg_catalog.compress (text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.compress (text)  RETURNS bytea LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'compress_text';

DROP FUNCTION IF EXISTS pg_catalog.compress (bytea) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.compress (bytea)  RETURNS bytea LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'compress_bytea';

DROP FUNCTION IF EXISTS pg_catalog.compress (boolean) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.compress (boolean) RETURNS bytea LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'compress_boolean';

DROP FUNCTION IF EXISTS pg_catalog.compress (bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.compress (bit) RETURNS bytea LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'compress_bit';

DROP FUNCTION IF EXISTS pg_catalog.uncompress (text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uncompress (text) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompress_text';

DROP FUNCTION IF EXISTS pg_catalog.uncompress (bytea) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uncompress (bytea) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompress_bytea';

DROP FUNCTION IF EXISTS pg_catalog.uncompress (boolean) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uncompress (boolean) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompress_boolean';

DROP FUNCTION IF EXISTS pg_catalog.uncompress (bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uncompress (bit) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompress_bit';

DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length (text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uncompressed_length (text) RETURNS uint4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompressed_length_text';

DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length (bytea) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uncompressed_length (bytea) RETURNS uint4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompressed_length_bytea';

DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length (boolean) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uncompressed_length (boolean) RETURNS uint4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompressed_length_boolean';

DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length (bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uncompressed_length (bit) RETURNS uint4 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uncompressed_length_bit';

DROP FUNCTION IF EXISTS  pg_catalog.weight_string(TEXT, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(TEXT, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_single';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(bytea, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(bytea, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_bytea';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(boolean, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(boolean, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_boolean';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(numeric, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(numeric, uint4) RETURNS text AS
$$
BEGIN
    RETURN NULL;
END;
$$
LANGUAGE plpgsql;
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(date, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(date, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_date';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(time, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(time, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_time';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(timestamp without time zone, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(timestamp without time zone, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_timestamp';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(timestamptz, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(timestamptz, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_timestamptz';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(interval, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(interval, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_interval';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(bit, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(bit, uint4) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_bit';

DROP FUNCTION IF EXISTS  pg_catalog.weight_string(TEXT, TEXT, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(TEXT, TEXT, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string';
DROP FUNCTION IF EXISTS pg_catalog.weight_string (bytea, text, uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(bytea, TEXT, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_bytea';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(boolean, TEXT, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(boolean, TEXT, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_boolean';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(numeric, TEXT, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(numeric, TEXT, uint4) RETURNS text AS
$$
BEGIN
    RETURN NULL;
END;
$$
LANGUAGE plpgsql;
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(date, TEXT, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(date, TEXT, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_date';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(time, TEXT, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(time, TEXT, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_time';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(timestamp without time zone, TEXT, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(timestamp without time zone, TEXT, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_timestamp';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(timestamptz, TEXT, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(timestamptz, TEXT, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_timestamptz';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(interval, TEXT, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(interval, TEXT, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_interval';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(bit, TEXT, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(bit, TEXT, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_bit';

DROP FUNCTION IF EXISTS  pg_catalog.weight_string(TEXT, TEXT, uint4, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(TEXT, TEXT, uint4, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string';
DROP FUNCTION IF EXISTS pg_catalog.weight_string (bytea, text, uint4, uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(bytea, TEXT, uint4, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_bytea';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(boolean, TEXT, uint4, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(boolean, TEXT, uint4, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_boolean';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(numeric, TEXT, uint4, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(numeric, TEXT, TEXT, uint4) RETURNS text AS
$$
BEGIN
    RETURN NULL;
END;
$$
LANGUAGE plpgsql;
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(date, TEXT, uint4, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(date, TEXT, uint4, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_date';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(time, TEXT, uint4, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(time, TEXT, uint4, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_time';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(timestamp without time zone, TEXT, uint4, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(timestamp without time zone, TEXT, uint4, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_timestamp';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(timestamptz, TEXT, uint4, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(timestamptz, TEXT, uint4, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_timestamptz';
DROP FUNCTION IF EXISTS  pg_catalog.weight_string(interval, TEXT, uint4, uint4) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(interval, TEXT, uint4, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_interval';
DROP FUNCTION IF EXISTS pg_catalog.weight_string (bit, text, uint4, uint4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(bit, TEXT, uint4, uint4)  RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'weight_string_bit';

drop aggregate if exists pg_catalog.bit_xor(text);
DROP FUNCTION IF EXISTS pg_catalog.text_xor(uint8,text) CASCADE;

CREATE FUNCTION pg_catalog.text_xor (t1 uint8,t2 text) RETURNS uint8 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'uint8_xor_text';
create aggregate pg_catalog.bit_xor(text) (SFUNC=text_xor, STYPE= uint8);

drop schema if exists performance_schema CASCADE;
create schema performance_schema;

CREATE OR REPLACE FUNCTION pg_catalog.get_statement_history(
OUT schema_name name,OUT unique_query_id bigint,OUT debug_query_id bigint,OUT query text,
OUT start_time timestamp with time zone, OUT finish_time timestamp with time zone,OUT thread_id bigint,
OUT session_id bigint, OUT n_returned_rows bigint, OUT n_tuples_inserted bigint,OUT n_tuples_updated bigint,
OUT n_tuples_deleted bigint,OUT cpu_time bigint,OUT lock_time bigint)
RETURNS setof record
AS $$
DECLARE
  row_data record;
  port text;
  query_str text;
  query_str_nodes text;
  user_name text;
  dblink_ext int;
  BEGIN
    --check privileges only sysadm or omsysadm can access the dbe_perf.statement table;
    SELECT SESSION_USER INTO user_name;
    IF pg_catalog.has_schema_privilege(user_name, 'dbe_perf', 'USAGE') = false 
    THEN 
       RAISE EXCEPTION 'user % has no privilege to use schema dbe_perf',user_name;
    END IF;

    IF pg_catalog.has_table_privilege(user_name, 'dbe_perf.statement_history', 'SELECT') = false 
    THEN 
       RAISE EXCEPTION 'user % has no privilege to access dbe_perf.statement_history',user_name;
    END IF;

    --check if dblink exists, lite mode does not have dblink
    EXECUTE('SELECT count(*) from pg_extension where extname=''dblink''') into dblink_ext;
    IF dblink_ext = 0
    THEN
        RAISE EXCEPTION 'dblink is needed by this function, please load dblink extension first';
    END IF;

    --get the port number 
    EXECUTE('SELECT setting FROM pg_settings WHERE name = ''port''') into port;
    
    query_str := concat(concat('select * from public.dblink(''dbname=postgres port=',port),''',''select schema_name,unique_query_id,debug_query_id,query ,start_time,finish_time, thread_id ,session_id ,n_returned_rows ,n_tuples_inserted ,n_tuples_updated ,n_tuples_deleted ,cpu_time , lock_time from dbe_perf.statement_history'') as t(schema_name name,unique_query_id bigint,debug_query_id bigint,query text,start_time timestamp with time zone, finish_time timestamp with time zone,thread_id bigint,session_id bigint, n_returned_rows bigint, n_tuples_inserted bigint, n_tuples_updated bigint,n_tuples_deleted bigint,cpu_time bigint,lock_time bigint)');
    FOR row_data IN EXECUTE(query_str) LOOP
        schema_name :=row_data.schema_name;
    unique_query_id := row_data.unique_query_id;
    debug_query_id := row_data.debug_query_id;
    query := row_data.query;
    start_time := row_data.start_time;
    finish_time := row_data.finish_time;
    thread_id := row_data.thread_id;
    session_id := row_data.session_id;
    n_returned_rows := row_data.n_returned_rows;
    n_tuples_inserted := row_data.n_tuples_inserted;
    n_tuples_updated := row_data.n_tuples_updated;
    n_tuples_deleted := row_data.n_tuples_deleted;
    cpu_time := row_data.cpu_time;
    lock_time:= row_data.lock_time;
    return next;
    END LOOP;
    return;
  END; $$
LANGUAGE 'plpgsql'
SECURITY DEFINER;

CREATE VIEW performance_schema.statement_history AS 
select * from pg_catalog.get_statement_history();

create view performance_schema.events_statements_current as 
select
  s.pid as THREAD_ID,
  NULL as EVENT_ID,  
  NULL as END_EVENT_ID,  
  NULL AS EVENT_NAME,   
  s.application_name AS SOURCE,  
  s.query_start AS TIMER_START,
  CASE
    WHEN s.state = 'active' THEN CURRENT_TIMESTAMP
    ELSE s.state_change
  END AS TIMER_END,
  CASE
    WHEN s.state = 'active' THEN CURRENT_TIMESTAMP - s.query_start
    ELSE s.state_change - s.query_start
  END AS TIMER_WAIT,
  NULL AS LOCK_TIME,   
  s.QUERY AS SQL_TEXT,
  SHA2(t.QUERY,256) AS DIGEST, 
  t.QUERY AS DIGEST_TEXT,
  h.schema_name AS SCHEMA_NAME, 
  NULL AS OBJECT_TYPE, 
  NULL AS OBJECT_SCHEMA, 
  NULL AS OBJECT_NAME, 
  NULL AS OBJECT_INSTANCE_BEGIN, 
  NULL AS MYSQL_ERRNO, 
  NULL AS RETURNED_SQLSTATE, 
  NULL AS MESSAGE_TEXT, 
  NULL AS ERRORS,      
  NULL AS WARNING_COUNT,
  (h.n_tuples_deleted+h.n_tuples_inserted+h.n_tuples_inserted)  AS ROW_AFFECTED,
  h.n_returned_rows AS ROW_SENT,
  NULL AS ROW_EXAMINED, 
  NULL AS CREATED_TMP_DISK_TABLES, 
  NULL AS CREATED_TMP_TABLES, 
  NULL AS SELECT_FULL_JOIN, 
  NULL AS SELECT_FULL_RANGE_JOIN, 
  NULL AS SELECT_RANGE, 
  NULL AS SELECT_RANGE_CHECK, 
  NULL AS SELECT_SCAN, 
  NULL AS SORT_MERGE_PASSES, 
  NULL AS SORT_RANGE, 
  NULL AS SORT_ROWS, 
  NULL AS SORT_SCAN, 
  NULL AS NO_INDEX_USED, 
  NULL AS NO_GOOD_INDEX_USED, 
  NULL AS NESTING_EVENT_ID, 
  NULL AS NESTING_EVENT_TYPE, 
  NULL AS NESTING_EVENT_LEVEL, 
  h.debug_query_id AS STATEMENT_ID,
  h.CPU_TIME AS CPU_TIME,    
  NULL AS MAX_CONTROLLED_MEMORY, 
  NULL AS MAX_TOTAL_MEMORY, 
  NULL AS EXECUTION_ENGINE 
  FROM pg_catalog.pg_stat_activity s
  left outer join performance_schema.statement_history h
  on s.query_id = h.debug_query_id
  and h.session_id = s.sessionid
  left outer join dbe_perf.statement t 
  on s.unique_sql_id = t.unique_sql_id
  where s.query_start IS NOT NULL
;
/* ----------------------
 *    Create performance_schema.events_statements_history
 * ----------------------
 */
create view performance_schema.events_statements_history as 
select
  h.thread_id as THREAD_ID,
  NULL as EVENT_ID,  
  NULL as END_EVENT_ID,  
  NULL AS EVENT_NAME,   
  s.application_name AS SOURCE,  
  h.start_time AS TIMER_START,
  h.finish_time AS TIMER_END,
  h.finish_time - h.start_time AS TIMER_WAIT,
  h.lock_time AS LOCK_TIME,   
  h.QUERY AS SQL_TEXT,
  SHA2(t.QUERY,256) AS DIGEST,
  t.QUERY AS DIGEST_TEXT,
  h.schema_name AS SCHEMA_NAME, 
  NULL AS OBJECT_TYPE, 
  NULL AS OBJECT_SCHEMA, 
  NULL AS OBJECT_NAME, 
  NULL AS OBJECT_INSTANCE_BEGIN, 
  NULL AS MYSQL_ERRNO, 
  NULL AS RETURNED_SQLSTATE, 
  NULL AS MESSAGE_TEXT, 
  0    AS ERRORS, 
  NULL AS WARNING_COUNT,
  (h.n_tuples_deleted+h.n_tuples_inserted+h.n_tuples_inserted)  AS ROW_AFFECTED,
  h.n_returned_rows AS ROW_SENT,
  NULL AS ROW_EXAMINED, 
  NULL AS CREATED_TMP_DISK_TABLES, 
  NULL AS CREATED_TMP_TABLES, 
  NULL AS SELECT_FULL_JOIN, 
  NULL AS SELECT_FULL_RANGE_JOIN, 
  NULL AS SELECT_RANGE, 
  NULL AS SELECT_RANGE_CHECK, 
  NULL AS SELECT_SCAN, 
  NULL AS SORT_MERGE_PASSES, 
  NULL AS SORT_RANGE, 
  NULL AS SORT_ROWS, 
  NULL AS SORT_SCAN, 
  NULL AS NO_INDEX_USED, 
  NULL AS NO_GOOD_INDEX_USED, 
  NULL AS NESTING_EVENT_ID, 
  NULL AS NESTING_EVENT_TYPE, 
  NULL AS NESTING_EVENT_LEVEL, 
  h.debug_query_id AS STATEMENT_ID, 
  h.CPU_TIME AS CPU_TIME,    
  NULL AS MAX_CONTROLLED_MEMORY, 
  NULL AS MAX_TOTAL_MEMORY, 
  NULL AS EXECUTION_ENGINE 
  FROM performance_schema.statement_history h 
  left outer join dbe_perf.statement t
  on h.unique_query_id = t.unique_sql_id
  inner join pg_catalog.pg_stat_activity s
  on h.session_id = s.sessionid
;
/* ----------------------
 *    Create performance_schema.events_statements_summary_by_digest
 * ----------------------
 */
create view performance_schema.events_statements_summary_by_digest as 
SELECT 
  h.schema_name AS SCHEMA_NAME, 
  SHA2(t.QUERY,256) AS DIGEST,
  t.QUERY AS DIGEST_TEXT,
  t.N_CALLS AS COUNT_STAR,
  t.TOTAL_ELAPSE_TIME AS SUM_TIMER_WAIT,
  t.MIN_ELAPSE_TIME AS MIN_TIMER_WAIT,
  CASE
    WHEN t.N_CALLS THEN round(t.TOTAL_ELAPSE_TIME/t.N_CALLS)
    ELSE 0
  END AS AVG_TIMER_WAIT,
  t.MAX_ELAPSE_TIME AS MAX_TIMER_WAIT,
  NULL AS SUM_LOCK_TIME,  
  NULL AS SUM_ERRORS,  
  NULL AS SUM_WARNINGS, 
  (t.n_tuples_deleted+t.n_tuples_inserted+t.n_tuples_inserted) AS SUM_ROWS_AFFECTED,
  t.N_RETURNED_ROWS AS SUM_ROWS_SENT,
  NULL AS SUM_ROWS_EXAMINED,
  NULL AS SUM_CREATED_TMP_DISK_TABLES,
  NULL AS SUM_CREATED_TMP_TABLES,
  NULL AS SUM_SELECT_FULL_JOIN,
  NULL AS SUM_SELECT_FULL_RANGE_JOIN,
  NULL AS SUM_SELECT_RANGE,
  NULL AS SUM_SELECT_RANGE_CHECK,
  NULL AS SUM_SELECT_SCAN,
  NULL AS SUM_SORT_MERGE_PASSES,
  NULL AS SUM_SORT_RANGE,
  NULL AS SUM_SORT_ROWS,
  t.sort_count AS SUM_SORT_SCAN,
  NULL AS SUM_NO_INDEX_USED,
  NULL AS SUM_NO_GOOD_INDEX_USED,
  t.CPU_TIME AS SUM_CPU_TIME,
  NULL AS MAX_CONTROLLED_MEMORY,
  NULL AS MAX_TOTAL_MEMORY,
  NULL AS COUNT_SECONDARY,
  NULL AS FIRST_SEEN,
  t.last_updated AS LAST_SEEN,
  NULL AS QUANTILE_95,
  NULL AS QUANTILE_99,
  NULL AS QUANTILE_999,
  NULL AS QUERY_SAMPLE_TEXT,
  NULL AS QUERY_SAMPLE_SEEN,
  NULL AS QUERY_SAMPLE_TIMER_WAIT
FROM dbe_perf.statement t
left outer join performance_schema.statement_history h
on h.unique_query_id = t.unique_sql_id
;
  
  
create view performance_schema.events_waits_current as 
SELECT 
  t.tid AS THREAD_ID,
  NULL AS EVENT_ID,
  NULL AS END_EVENT_ID,
  concat(concat(concat(concat(t.thread_name,'/'),t.WAIT_STATUS),'/'),t.WAIT_EVENT) AS EVENT_NAME,
  s.application_name AS SOURCE,
  s.query_start AS TIMER_START,
  CASE
    WHEN s.state = 'active' THEN CURRENT_TIMESTAMP
    ELSE s.state_change
  END AS TIMER_END,
  CASE
    WHEN s.state = 'active' THEN CURRENT_TIMESTAMP - s.query_start
    ELSE s.state_change - s.query_start
  END AS TIMER_WAIT,
  NULL AS SPINS,
  n.nspname AS OBJECT_SCHEMA,
  CASE
    WHEN c.reltype !=0 THEN c.relname
    ELSE NULL 
  END AS OBJECT_NAME,
  CASE
    WHEN c.reltype = 0 THEN c.relname
    ELSE NULL
  END AS INDEX_NAME,
  l.locktype AS OBJECT_TYPE,
  NULL AS OBJECT_INSTANCE_BEGIN,
  NULL AS NESTING_EVENT_ID,
  NULL AS NESTING_EVENT_TYPE,
  NULL AS OPERATION,
  NULL AS NUMBER_OF_BYTES,
  NULL AS FLAGS
FROM pg_catalog.pg_thread_wait_status t
inner join pg_catalog.pg_stat_activity s
  on t.sessionid = s.sessionid
  LEFT OUTER join pg_catalog.pg_locks l
  on t.locktag = l.locktag and l.pid = s.pid
  LEFT OUTER join pg_catalog.pg_class c
  on l.relation = c.oid 
  LEFT OUTER join pg_catalog.pg_namespace n
  on c.relnamespace = n.oid;
      

  
CREATE VIEW performance_schema.events_waits_summary_global_by_event_name AS
SELECT 
  concat(concat(w.type,''),w.event) AS EVENT_NAME,
  w.wait AS COUNT_STAR,
  w.total_wait_time as SUM_TIMER_WAIT,
  w.min_wait_time as MIN_TIMER_WAIT,
  w.avg_wait_time as AVG_TIMER_WAIT,
  w.max_wait_time as MAX_TIMER_WAIT
FROM dbe_perf.wait_events as w;


CREATE VIEW performance_schema.file_summary_by_instance AS
SELECT 
f.filenum AS FILE_NAME,
NULL AS EVENT_NAME,
NULL AS OBJECT_INSTANCE_BEGIN,
NULL AS COUNT_STAR,
NULL AS SUM_TIMER_WAIT,
NULL AS MIN_TIMER_WAIT,
NULL AS AVG_TIMER_WAIT,
NULL AS MAX_TIMER_WAIT,
f.phyrds AS COUNT_READ,
f.readtim AS SUM_TIMER_READ,
f.miniotim AS MIN_TIMER_READ, 
f.avgiotim AS AVG_TIMER_READ,
f.maxiowtm AS MAX_TIMER_READ,
f.phyblkrd*8192 AS SUM_NUMBER_OF_BYTES_READ, 
f.phywrts AS COUNT_WRITE,
f.writetim AS SUM_TIMER_WRITE,
f.miniotim AS MIN_TIMER_WRITE, 
f.avgiotim AVG_TIMER_WRITE,
f.maxiowtm AS MAX_TIMER_WRITE,
f.phyblkwrt*8192 AS SUM_NUMBER_OF_BYTES_WRITE,
NULL AS COUNT_MISC,
NULL AS SUM_TIMER_MISC,
NULL AS MIN_TIMER_MISC,
NULL AS AVG_TIMER_MISC,
NULL AS MAX_TIMER_MISC
FROM dbe_perf.file_iostat f;

CREATE VIEW performance_schema.table_io_waits_summary_by_table AS
SELECT
'TABLE' AS OBJECT_TYPE,  
n.nspname AS OBJECT_SCHEMA,
c.relname AS OBJECT_NAME,
NULL AS       COUNT_STAR,
NULL AS   SUM_TIMER_WAIT,
NULL AS   MIN_TIMER_WAIT,
NULL AS   AVG_TIMER_WAIT,
NULL AS   MAX_TIMER_WAIT,
SUM(f.phyrds) AS       COUNT_READ,
SUM(f.readtim) AS   SUM_TIMER_READ,
MIN(f.miniotim) AS   MIN_TIMER_READ,
AVG(f.avgiotim) AS   AVG_TIMER_READ,
MAX(f.maxiowtm) AS   MAX_TIMER_READ,
SUM(f.phywrts) AS      COUNT_WRITE,
SUM(f.writetim) AS  SUM_TIMER_WRITE,
MIN(f.miniotim) AS  MIN_TIMER_WRITE,
AVG(f.avgiotim) AS  AVG_TIMER_WRITE,
MAX(f.maxiowtm) AS  MAX_TIMER_WRITE,
NULL AS      COUNT_FETCH,
NULL AS  SUM_TIMER_FETCH,
NULL AS  MIN_TIMER_FETCH,
NULL AS  AVG_TIMER_FETCH,
NULL AS  MAX_TIMER_FETCH,
NULL AS     COUNT_INSERT,
NULL AS SUM_TIMER_INSERT,
NULL AS MIN_TIMER_INSERT,
NULL AS AVG_TIMER_INSERT,
NULL AS MAX_TIMER_INSERT,
NULL AS     COUNT_UPDATE,
NULL AS SUM_TIMER_UPDATE,
NULL AS MIN_TIMER_UPDATE,
NULL AS AVG_TIMER_UPDATE,
NULL AS MAX_TIMER_UPDATE,
NULL AS     COUNT_DELETE,
NULL AS SUM_TIMER_DELETE,
NULL AS MIN_TIMER_DELETE,
NULL AS AVG_TIMER_DELETE,
NULL AS MAX_TIMER_DELETE
FROM dbe_perf.file_iostat f, pg_class c, pg_namespace n
WHERE f.filenum = c.relfilenode
and c.relnamespace = n.oid
and c.relkind = 'r'
GROUP BY OBJECT_SCHEMA,OBJECT_NAME;

CREATE VIEW performance_schema.table_io_waits_summary_by_index_usage AS
SELECT
'TABLE' AS OBJECT_TYPE,  
n.nspname AS OBJECT_SCHEMA,
t.relname AS OBJECT_NAME,
c.relname AS INDEX_NAME,
NULL AS       COUNT_STAR,
NULL AS   SUM_TIMER_WAIT,
NULL AS   MIN_TIMER_WAIT,
NULL AS   AVG_TIMER_WAIT,
NULL AS   MAX_TIMER_WAIT,
SUM(f.phyrds) AS       COUNT_READ,
SUM(f.readtim) AS   SUM_TIMER_READ,
MIN(f.miniotim) AS   MIN_TIMER_READ,
AVG(f.avgiotim) AS   AVG_TIMER_READ,
MAX(f.maxiowtm) AS   MAX_TIMER_READ,
SUM(f.phywrts) AS      COUNT_WRITE,
SUM(f.writetim) AS  SUM_TIMER_WRITE,
MIN(f.miniotim) AS  MIN_TIMER_WRITE,
AVG(f.avgiotim) AS  AVG_TIMER_WRITE,
MAX(f.maxiowtm) AS  MAX_TIMER_WRITE,
NULL AS      COUNT_FETCH,
NULL AS  SUM_TIMER_FETCH,
NULL AS  MIN_TIMER_FETCH,
NULL AS  AVG_TIMER_FETCH,
NULL AS  MAX_TIMER_FETCH,
NULL AS     COUNT_INSERT,
NULL AS SUM_TIMER_INSERT,
NULL AS MIN_TIMER_INSERT,
NULL AS AVG_TIMER_INSERT,
NULL AS MAX_TIMER_INSERT,
NULL AS     COUNT_UPDATE,
NULL AS SUM_TIMER_UPDATE,
NULL AS MIN_TIMER_UPDATE,
NULL AS AVG_TIMER_UPDATE,
NULL AS MAX_TIMER_UPDATE,
NULL AS     COUNT_DELETE,
NULL AS SUM_TIMER_DELETE,
NULL AS MIN_TIMER_DELETE,
NULL AS AVG_TIMER_DELETE,
NULL AS MAX_TIMER_DELETE
FROM dbe_perf.file_iostat f, pg_class c, pg_namespace n,pg_index i, pg_class t
WHERE f.filenum = c.relfilenode
and c.relnamespace = n.oid
and c.relkind in ( 'i','I') 
and c.oid = i.indexrelid
and t.oid = i.indrelid
GROUP BY OBJECT_SCHEMA,OBJECT_NAME,INDEX_NAME;

GRANT USAGE ON schema performance_schema TO PUBLIC; 

GRANT SELECT,REFERENCES on all tables in schema performance_schema to public;

-- bool cast bit/float/double
DROP FUNCTION IF EXISTS pg_catalog.booltobit(bool, int4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.booltofloat4(bool) CASCADE;

DROP CAST IF EXISTS (bool AS bit) CASCADE;
DROP CAST IF EXISTS (bool AS float4) CASCADE;
DROP CAST IF EXISTS (bool AS float8) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.booltobit(bool, int4) RETURNS bit LANGUAGE C STRICT AS  '$libdir/dolphin',  'bool_bit';
CREATE CAST (bool AS bit) WITH FUNCTION pg_catalog.booltobit(bool, int4) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.booltofloat4(bool) RETURNS float4 LANGUAGE C STRICT AS  '$libdir/dolphin',  'bool_float4';
CREATE CAST (bool AS float4) WITH FUNCTION pg_catalog.booltofloat4(bool) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.booltofloat8(bool) RETURNS float8 LANGUAGE C STRICT AS  '$libdir/dolphin',  'bool_float8';
CREATE CAST (bool AS float8) WITH FUNCTION pg_catalog.booltofloat8(bool) AS ASSIGNMENT;

-- binary/varbinary -> text implicit
DROP FUNCTION IF EXISTS pg_catalog.hex(binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.hex(varbinary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uncompress(binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uncompress(varbinary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length(binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uncompressed_length(varbinary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.weight_string(binary, uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.weight_string(varbinary, uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.weight_string(binary, text, uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.weight_string(varbinary, text, uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.weight_string(binary, text, uint4, uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.weight_string(varbinary, text, uint4, uint4) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.hex(binary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.hex($1::bytea) $$;
CREATE OR REPLACE FUNCTION pg_catalog.hex(varbinary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.hex($1::bytea) $$;

CREATE OR REPLACE FUNCTION pg_catalog.uncompress(binary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uncompress($1::bytea) $$;
CREATE OR REPLACE FUNCTION pg_catalog.uncompress(varbinary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uncompress($1::bytea) $$;

CREATE OR REPLACE FUNCTION pg_catalog.uncompressed_length(binary) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uncompressed_length($1::bytea) $$;
CREATE OR REPLACE FUNCTION pg_catalog.uncompressed_length(varbinary) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.uncompressed_length($1::bytea) $$;

CREATE OR REPLACE FUNCTION pg_catalog.weight_string(binary, uint4) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.weight_string($1::bytea, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(varbinary, uint4) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.weight_string($1::bytea, $2) $$;

CREATE OR REPLACE FUNCTION pg_catalog.weight_string(binary, text, uint4) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.weight_string($1::bytea, $2, $3) $$;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(varbinary, text, uint4) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.weight_string($1::bytea, $2, $3) $$;

CREATE OR REPLACE FUNCTION pg_catalog.weight_string(binary, text, uint4, uint4) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.weight_string($1::bytea, $2, $3, $4) $$;
CREATE OR REPLACE FUNCTION pg_catalog.weight_string(varbinary, text, uint4, uint4) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.weight_string($1::bytea, $2, $3, $4) $$;

DROP FUNCTION IF EXISTS pg_catalog.bpcharbinarylike(char, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bpcharbinarynlike(char, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.namebinarylike(name, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.namebinarynlike(name, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binarylike(binary, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binarynlike(binary, binary) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.bpcharbinarylike(
char,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textbinarylike($1::text, $2) $$;

CREATE OPERATOR pg_catalog.~~(leftarg = char, rightarg = binary, procedure = pg_catalog.bpcharbinarylike);
CREATE OPERATOR pg_catalog.~~*(leftarg = char, rightarg = binary, procedure = pg_catalog.bpcharbinarylike);

CREATE OR REPLACE FUNCTION pg_catalog.bpcharbinarynlike(
char,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textbinarynlike($1::text, $2) $$;

CREATE OPERATOR pg_catalog.!~~(leftarg = char, rightarg = binary, procedure = pg_catalog.bpcharbinarynlike);
CREATE OPERATOR pg_catalog.!~~*(leftarg = char, rightarg = binary, procedure = pg_catalog.bpcharbinarynlike);

CREATE OR REPLACE FUNCTION pg_catalog.namebinarylike(
name,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textbinarylike($1::text, $2) $$;

CREATE OPERATOR pg_catalog.~~(leftarg = name, rightarg = binary, procedure = pg_catalog.namebinarylike);
CREATE OPERATOR pg_catalog.~~*(leftarg = name, rightarg = binary, procedure = pg_catalog.namebinarylike);

CREATE OR REPLACE FUNCTION pg_catalog.namebinarynlike(
name,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.textbinarynlike($1::text, $2) $$;

CREATE OPERATOR pg_catalog.!~~(leftarg = name, rightarg = binary, procedure = pg_catalog.namebinarynlike);
CREATE OPERATOR pg_catalog.!~~*(leftarg = name, rightarg = binary, procedure = pg_catalog.namebinarynlike);

CREATE OR REPLACE FUNCTION pg_catalog.binarylike(
binary,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.bytealike($1::bytea, $2::bytea) $$;

CREATE OPERATOR pg_catalog.~~(leftarg = binary, rightarg = binary, procedure = pg_catalog.binarylike);
CREATE OPERATOR pg_catalog.~~*(leftarg = binary, rightarg = binary, procedure = pg_catalog.binarylike);

CREATE OR REPLACE FUNCTION pg_catalog.binarynlike(
binary,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.byteanlike($1::bytea, $2::bytea) $$;

CREATE OPERATOR pg_catalog.!~~(leftarg = binary, rightarg = binary, procedure = pg_catalog.binarynlike);
CREATE OPERATOR pg_catalog.!~~*(leftarg = binary, rightarg = binary, procedure = pg_catalog.binarynlike);

-- lt
DROP FUNCTION IF EXISTS pg_catalog.time_binary_lt(time, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.numeric_binary_lt(numeric, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1_binary_lt(uint1, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2_binary_lt(uint2, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4_binary_lt(uint4, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8_binary_lt(uint8, binary) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.time_binary_lt(
time,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<(leftarg = time, rightarg = binary, procedure = pg_catalog.time_binary_lt);

CREATE OR REPLACE FUNCTION pg_catalog.numeric_binary_lt(
numeric,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<(leftarg = numeric, rightarg = binary, procedure = pg_catalog.numeric_binary_lt);

CREATE OR REPLACE FUNCTION pg_catalog.uint1_binary_lt(
uint1,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<(leftarg = uint1, rightarg = binary, procedure = pg_catalog.uint1_binary_lt);

CREATE OR REPLACE FUNCTION pg_catalog.uint2_binary_lt(
uint2,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<(leftarg = uint2, rightarg = binary, procedure = pg_catalog.uint2_binary_lt);

CREATE OR REPLACE FUNCTION pg_catalog.uint4_binary_lt(
uint4,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<(leftarg = uint4, rightarg = binary, procedure = pg_catalog.uint4_binary_lt);

CREATE OR REPLACE FUNCTION pg_catalog.uint8_binary_lt(
uint8,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<(leftarg = uint8, rightarg = binary, procedure = pg_catalog.uint8_binary_lt);

DROP FUNCTION IF EXISTS pg_catalog.binary_time_lt(binary, time) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_numeric_lt(binary, numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint1_lt(binary, uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint2_lt(binary, uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint4_lt(binary, uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint8_lt(binary, uint8) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.binary_time_lt(
binary,
time
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = time, procedure = pg_catalog.binary_time_lt);

CREATE OR REPLACE FUNCTION pg_catalog.binary_numeric_lt(
binary,
numeric
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = numeric, procedure = pg_catalog.binary_numeric_lt);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint1_lt(
binary,
uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = uint1, procedure = pg_catalog.binary_uint1_lt);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint2_lt(
binary,
uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = uint2, procedure = pg_catalog.binary_uint2_lt);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint4_lt(
binary,
uint4
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = uint4, procedure = pg_catalog.binary_uint4_lt);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint8_lt(
binary,
uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8lt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = uint8, procedure = pg_catalog.binary_uint8_lt);

-- gt
DROP FUNCTION IF EXISTS pg_catalog.time_binary_gt(time, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.numeric_binary_gt(numeric, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1_binary_gt(uint1, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2_binary_gt(uint2, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4_binary_gt(uint4, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8_binary_gt(uint8, binary) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.time_binary_gt(
time,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>(leftarg = time, rightarg = binary, procedure = pg_catalog.time_binary_gt);

CREATE OR REPLACE FUNCTION pg_catalog.numeric_binary_gt(
numeric,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>(leftarg = numeric, rightarg = binary, procedure = pg_catalog.numeric_binary_gt);

CREATE OR REPLACE FUNCTION pg_catalog.uint1_binary_gt(
uint1,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>(leftarg = uint1, rightarg = binary, procedure = pg_catalog.uint1_binary_gt);

CREATE OR REPLACE FUNCTION pg_catalog.uint2_binary_gt(
uint2,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>(leftarg = uint2, rightarg = binary, procedure = pg_catalog.uint2_binary_gt);

CREATE OR REPLACE FUNCTION pg_catalog.uint4_binary_gt(
uint4,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>(leftarg = uint4, rightarg = binary, procedure = pg_catalog.uint4_binary_gt);

CREATE OR REPLACE FUNCTION pg_catalog.uint8_binary_gt(
uint8,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>(leftarg = uint8, rightarg = binary, procedure = pg_catalog.uint8_binary_gt);

DROP FUNCTION IF EXISTS pg_catalog.binary_time_gt(binary, time) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_numeric_gt(binary, numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint1_gt(binary, uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint2_gt(binary, uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint4_gt(binary, uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint8_gt(binary, uint8) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.binary_time_gt(
binary,
time
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = time, procedure = pg_catalog.binary_time_gt);

CREATE OR REPLACE FUNCTION pg_catalog.binary_numeric_gt(
binary,
numeric
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = numeric, procedure = pg_catalog.binary_numeric_gt);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint1_gt(
binary,
uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = uint1, procedure = pg_catalog.binary_uint1_gt);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint2_gt(
binary,
uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = uint2, procedure = pg_catalog.binary_uint2_gt);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint4_gt(
binary,
uint4
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = uint4, procedure = pg_catalog.binary_uint4_gt);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint8_gt(
binary,
uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8gt($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = uint8, procedure = pg_catalog.binary_uint8_gt);

-- le
DROP FUNCTION IF EXISTS pg_catalog.time_binary_le(time, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.numeric_binary_le(numeric, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1_binary_le(uint1, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2_binary_le(uint2, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4_binary_le(uint4, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8_binary_le(uint8, binary) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.time_binary_le(
time,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<=(leftarg = time, rightarg = binary, procedure = pg_catalog.time_binary_le);

CREATE OR REPLACE FUNCTION pg_catalog.numeric_binary_le(
numeric,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<=(leftarg = numeric, rightarg = binary, procedure = pg_catalog.numeric_binary_le);

CREATE OR REPLACE FUNCTION pg_catalog.uint1_binary_le(
uint1,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<=(leftarg = uint1, rightarg = binary, procedure = pg_catalog.uint1_binary_le);

CREATE OR REPLACE FUNCTION pg_catalog.uint2_binary_le(
uint2,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<=(leftarg = uint2, rightarg = binary, procedure = pg_catalog.uint2_binary_le);

CREATE OR REPLACE FUNCTION pg_catalog.uint4_binary_le(
uint4,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<=(leftarg = uint4, rightarg = binary, procedure = pg_catalog.uint4_binary_le);

CREATE OR REPLACE FUNCTION pg_catalog.uint8_binary_le(
uint8,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<=(leftarg = uint8, rightarg = binary, procedure = pg_catalog.uint8_binary_le);

DROP FUNCTION IF EXISTS pg_catalog.binary_time_le(binary, time) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_numeric_le(binary, numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint1_le(binary, uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint2_le(binary, uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint4_le(binary, uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint8_le(binary, uint8) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.binary_time_le(
binary,
time
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = time, procedure = pg_catalog.binary_time_le);

CREATE OR REPLACE FUNCTION pg_catalog.binary_numeric_le(
binary,
numeric
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = numeric, procedure = pg_catalog.binary_numeric_le);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint1_le(
binary,
uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = uint1, procedure = pg_catalog.binary_uint1_le);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint2_le(
binary,
uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = uint2, procedure = pg_catalog.binary_uint2_le);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint4_le(
binary,
uint4
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = uint4, procedure = pg_catalog.binary_uint4_le);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint8_le(
binary,
uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8le($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = uint8, procedure = pg_catalog.binary_uint8_le);

-- ge
DROP FUNCTION IF EXISTS pg_catalog.time_binary_ge(time, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.numeric_binary_ge(numeric, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint1_binary_ge(uint1, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2_binary_ge(uint2, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4_binary_ge(uint4, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint8_binary_ge(uint8, binary) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.time_binary_ge(
time,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>=(leftarg = time, rightarg = binary, procedure = pg_catalog.time_binary_ge);

CREATE OR REPLACE FUNCTION pg_catalog.numeric_binary_ge(
numeric,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>=(leftarg = numeric, rightarg = binary, procedure = pg_catalog.numeric_binary_ge);

CREATE OR REPLACE FUNCTION pg_catalog.uint1_binary_ge(
uint1,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>=(leftarg = uint1, rightarg = binary, procedure = pg_catalog.uint1_binary_ge);

CREATE OR REPLACE FUNCTION pg_catalog.uint2_binary_ge(
uint2,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>=(leftarg = uint2, rightarg = binary, procedure = pg_catalog.uint2_binary_ge);

CREATE OR REPLACE FUNCTION pg_catalog.uint4_binary_ge(
uint4,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>=(leftarg = uint4, rightarg = binary, procedure = pg_catalog.uint4_binary_ge);

CREATE OR REPLACE FUNCTION pg_catalog.uint8_binary_ge(
uint8,
binary
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>=(leftarg = uint8, rightarg = binary, procedure = pg_catalog.uint8_binary_ge);

DROP FUNCTION IF EXISTS pg_catalog.binary_time_ge(binary, time) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_numeric_ge(binary, numeric) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint1_ge(binary, uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint2_ge(binary, uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint4_ge(binary, uint4) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_uint8_ge(binary, uint8) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.binary_time_ge(
binary,
time
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = time, procedure = pg_catalog.binary_time_ge);

CREATE OR REPLACE FUNCTION pg_catalog.binary_numeric_ge(
binary,
numeric
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = numeric, procedure = pg_catalog.binary_numeric_ge);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint1_ge(
binary,
uint1
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = uint1, procedure = pg_catalog.binary_uint1_ge);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint2_ge(
binary,
uint2
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = uint2, procedure = pg_catalog.binary_uint2_ge);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint4_ge(
binary,
uint4
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = uint4, procedure = pg_catalog.binary_uint4_ge);

CREATE OR REPLACE FUNCTION pg_catalog.binary_uint8_ge(
binary,
uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.float8ge($1::float8, $2::float8) $$;
CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = uint8, procedure = pg_catalog.binary_uint8_ge);
-- uint explicit cast
-- time
DROP FUNCTION IF EXISTS pg_catalog.time_cast_ui1(time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_cast_ui1 (
time
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time_cast_ui1';

DROP FUNCTION IF EXISTS pg_catalog.time_cast_ui2(time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_cast_ui2 (
time
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time_cast_ui2';

DROP FUNCTION IF EXISTS pg_catalog.time_cast_ui4(time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_cast_ui4 (
time
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time_cast_ui4';

DROP FUNCTION IF EXISTS pg_catalog.time_cast_ui8(time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_cast_ui8 (
time
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time_cast_ui8';
-- char
DROP FUNCTION IF EXISTS pg_catalog.char_cast_ui1(char) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.char_cast_ui1 (
char
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'char_cast_ui1';

DROP FUNCTION IF EXISTS pg_catalog.char_cast_ui2(char) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.char_cast_ui2 (
char
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'char_cast_ui2';

DROP FUNCTION IF EXISTS pg_catalog.char_cast_ui4(char) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.char_cast_ui4 (
char
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'char_cast_ui4';

DROP FUNCTION IF EXISTS pg_catalog.char_cast_ui8(char) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.char_cast_ui8 (
char
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'char_cast_ui8';
-- varchar
DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_ui1(char) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varchar_cast_ui1 (
char
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varchar_cast_ui1';

DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_ui2(char) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varchar_cast_ui2 (
char
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varchar_cast_ui2';

DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_ui4(char) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varchar_cast_ui4 (
char
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varchar_cast_ui4';

DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_ui8(char) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varchar_cast_ui8 (
char
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varchar_cast_ui8';
--varlena
DROP FUNCTION IF EXISTS pg_catalog.varlena2ui1(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varlena2ui2(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varlena2ui4(anyelement) cascade;
DROP FUNCTION IF EXISTS pg_catalog.varlena2ui8(anyelement) cascade;

DROP CAST IF EXISTS ("binary" AS uint1) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS uint1) CASCADE;
DROP CAST IF EXISTS (blob AS uint1) CASCADE;
DROP CAST IF EXISTS (tinyblob AS uint1) CASCADE;
DROP CAST IF EXISTS (mediumblob AS uint1) CASCADE;
DROP CAST IF EXISTS (longblob AS uint1) CASCADE;
DROP CAST IF EXISTS (json AS uint1) CASCADE;
DROP CAST IF EXISTS ("binary" AS uint2) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS uint2) CASCADE;
DROP CAST IF EXISTS (blob AS uint2) CASCADE;
DROP CAST IF EXISTS (tinyblob AS uint2) CASCADE;
DROP CAST IF EXISTS (mediumblob AS uint2) CASCADE;
DROP CAST IF EXISTS (longblob AS uint2) CASCADE;
DROP CAST IF EXISTS (json AS uint2) CASCADE;
DROP CAST IF EXISTS ("binary" AS uint4) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS uint4) CASCADE;
DROP CAST IF EXISTS (blob AS uint4) CASCADE;
DROP CAST IF EXISTS (tinyblob AS uint4) CASCADE;
DROP CAST IF EXISTS (mediumblob AS uint4) CASCADE;
DROP CAST IF EXISTS (longblob AS uint4) CASCADE;
DROP CAST IF EXISTS (json AS uint4) CASCADE;
DROP CAST IF EXISTS ("binary" AS uint8) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS uint8) CASCADE;
DROP CAST IF EXISTS (blob AS uint8) CASCADE;
DROP CAST IF EXISTS (tinyblob AS uint8) CASCADE;
DROP CAST IF EXISTS (mediumblob AS uint8) CASCADE;
DROP CAST IF EXISTS (longblob AS uint8) CASCADE;
DROP CAST IF EXISTS (json AS uint8) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.varlena2ui1 (
anyelement
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varlena2ui1';

CREATE OR REPLACE FUNCTION pg_catalog.varlena2ui2 (
anyelement
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varlena2ui2';

CREATE OR REPLACE FUNCTION pg_catalog.varlena2ui4 (
anyelement
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varlena2ui4';

CREATE OR REPLACE FUNCTION pg_catalog.varlena2ui8 (
anyelement
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varlena2ui8';

CREATE CAST ("binary" AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS uint1) WITH FUNCTION pg_catalog.varlena2ui1(anyelement) AS ASSIGNMENT;

CREATE CAST ("binary" AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS uint2) WITH FUNCTION pg_catalog.varlena2ui2(anyelement) AS ASSIGNMENT;

CREATE CAST ("binary" AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS uint4) WITH FUNCTION pg_catalog.varlena2ui4(anyelement) AS ASSIGNMENT;

CREATE CAST ("binary" AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT;
CREATE CAST (blob AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT;
CREATE CAST (json AS uint8) WITH FUNCTION pg_catalog.varlena2ui8(anyelement) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_ui1(anyelement) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_ui1 (
anyelement
) RETURNS uint1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varlena_cast_ui1';

DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_ui2(anyelement) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_ui2 (
anyelement
) RETURNS uint2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varlena_cast_ui2';

DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_ui4(anyelement) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_ui4 (
anyelement
) RETURNS uint4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varlena_cast_ui4';

DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_ui8(anyelement) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_ui8 (
anyelement
) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varlena_cast_ui8';


DROP FUNCTION IF EXISTS pg_catalog.time_format(timestamp without time zone, text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_format (timestamp without time zone, text) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.time_format($1::text, $2) $$;

DROP FUNCTION IF EXISTS pg_catalog.timestamp_add (text, timestamptz, "any") CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_add (text, timestamptz, "any") RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_add_timestamptz';

create function pg_catalog.timestamp_pl_int4(
    timestamptz,
    int4
) RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.timestamptz_pl_interval($1, $2::interval) $$;
create operator pg_catalog.+(leftarg = timestamptz, rightarg = int4, procedure = pg_catalog.timestamp_pl_int4);

create function pg_catalog.timestamp_mi_int4(
    timestamptz,
    int4
) RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.timestamptz_mi_interval($1, $2::interval) $$;
create operator pg_catalog.-(leftarg = timestamptz, rightarg = int4, procedure = pg_catalog.timestamp_mi_int4);

create function pg_catalog.datetime_pl_int4(
    timestamp without time zone,
    int4
) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.datetime_pl_float($1, $2::float8) $$;
create operator pg_catalog.+(leftarg = timestamp without time zone, rightarg = int4, procedure = pg_catalog.datetime_pl_int4);

create function pg_catalog.datetime_mi_int4(
    timestamp without time zone,
    int4
) RETURNS float8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.datetime_mi_float($1, $2::float8) $$;
create operator pg_catalog.-(leftarg = timestamp without time zone, rightarg = int4, procedure = pg_catalog.datetime_mi_int4);

DROP FUNCTION IF EXISTS pg_catalog.bit_cast_int8(bit) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bit_cast_int8 (
bit
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bit_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.float4_cast_int8(float4) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.float4_cast_int8 (
float4
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'float4_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.float8_cast_int8(float8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.float8_cast_int8 (
float8
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'float8_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.numeric_cast_int8(numeric) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.numeric_cast_int8 (
numeric
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'numeric_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.date_cast_int8(date) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.date_cast_int8 (
date
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'date_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.timestamp_cast_int8(timestamp without time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_cast_int8 (
timestamp without time zone
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamp_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.timestamptz_cast_int8(timestamptz) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_cast_int8 (
timestamptz
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timestamptz_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.time_cast_int8(time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_cast_int8 (
time
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'time_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.timetz_cast_int8(timetz) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timetz_cast_int8 (
timetz
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'timetz_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.set_cast_int8(anyset) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.set_cast_int8 (
anyset
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'set_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.uint8_cast_int8(uint8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint8_cast_int8 (
uint8
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'uint8_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.year_cast_int8(year) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.year_cast_int8 (
year
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'year_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.bpchar_cast_int8(char) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bpchar_cast_int8 (
char
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'bpchar_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.varchar_cast_int8(varchar) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varchar_cast_int8 (
varchar
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varchar_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.text_cast_int8(text) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.text_cast_int8 (
text
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'text_cast_int8';

DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_int8(anyelement) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_int8 (
anyelement
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'varlena_cast_int8';

-- left operator
DROP FUNCTION IF EXISTS pg_catalog.json_uplus(json);
CREATE OR REPLACE FUNCTION pg_catalog.json_uplus(json) RETURNS json LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_uplus';
CREATE OPERATOR pg_catalog.+(rightarg = json, procedure = pg_catalog.json_uplus);

-- binary cmp operator
DROP FUNCTION IF EXISTS pg_catalog.json_eq(json, "any");
CREATE OR REPLACE FUNCTION pg_catalog.json_eq(json, "any") RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_eq';
CREATE OPERATOR pg_catalog.=(leftarg = json, rightarg = "any", procedure = pg_catalog.json_eq);
DROP FUNCTION IF EXISTS pg_catalog.json_eq(text, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_eq(text, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_eq';
CREATE OPERATOR pg_catalog.=(leftarg = text, rightarg = json, procedure = pg_catalog.json_eq);
DROP FUNCTION IF EXISTS pg_catalog.json_eq(bit, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_eq(bit, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_eq';
CREATE OPERATOR pg_catalog.=(leftarg = bit, rightarg = json, procedure = pg_catalog.json_eq);
DROP FUNCTION IF EXISTS pg_catalog.json_eq(boolean, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_eq(boolean, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_eq';
CREATE OPERATOR pg_catalog.=(leftarg = boolean, rightarg = json, procedure = pg_catalog.json_eq);
DROP FUNCTION IF EXISTS pg_catalog.json_eq(year, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_eq(year, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_eq';
CREATE OPERATOR pg_catalog.=(leftarg = year, rightarg = json, procedure = pg_catalog.json_eq);

DROP FUNCTION IF EXISTS pg_catalog.json_ne(json, "any");
CREATE OR REPLACE FUNCTION pg_catalog.json_ne(json, "any") RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ne';
CREATE OPERATOR pg_catalog.!=(leftarg = json, rightarg = "any", procedure = pg_catalog.json_ne);
DROP FUNCTION IF EXISTS pg_catalog.json_ne(text, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_ne(text, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ne';
CREATE OPERATOR pg_catalog.!=(leftarg = text, rightarg = json, procedure = pg_catalog.json_ne);
DROP FUNCTION IF EXISTS pg_catalog.json_ne(bit, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_ne(bit, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ne';
CREATE OPERATOR pg_catalog.!=(leftarg = bit, rightarg = json, procedure = pg_catalog.json_ne);
DROP FUNCTION IF EXISTS pg_catalog.json_ne(boolean, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_ne(boolean, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ne';
CREATE OPERATOR pg_catalog.!=(leftarg = boolean, rightarg = json, procedure = pg_catalog.json_ne);
DROP FUNCTION IF EXISTS pg_catalog.json_ne(year, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_ne(year, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ne';
CREATE OPERATOR pg_catalog.!=(leftarg = year, rightarg = json, procedure = pg_catalog.json_ne);

DROP FUNCTION IF EXISTS pg_catalog.json_gt(json, "any");
CREATE OR REPLACE FUNCTION pg_catalog.json_gt(json, "any") RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_gt';
CREATE OPERATOR pg_catalog.>(leftarg = json, rightarg = "any", procedure = pg_catalog.json_gt);
DROP FUNCTION IF EXISTS pg_catalog.json_gt(text, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_gt(text, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_gt';
CREATE OPERATOR pg_catalog.>(leftarg = text, rightarg = json, procedure = pg_catalog.json_gt);
DROP FUNCTION IF EXISTS pg_catalog.json_gt(bit, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_gt(bit, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_gt';
CREATE OPERATOR pg_catalog.>(leftarg = bit, rightarg = json, procedure = pg_catalog.json_gt);
DROP FUNCTION IF EXISTS pg_catalog.json_gt(boolean, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_gt(boolean, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_gt';
CREATE OPERATOR pg_catalog.>(leftarg = boolean, rightarg = json, procedure = pg_catalog.json_gt);
DROP FUNCTION IF EXISTS pg_catalog.json_gt(year, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_gt(year, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_gt';
CREATE OPERATOR pg_catalog.>(leftarg = year, rightarg = json, procedure = pg_catalog.json_gt);

DROP FUNCTION IF EXISTS pg_catalog.json_ge(json, "any");
CREATE OR REPLACE FUNCTION pg_catalog.json_ge(json, "any") RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ge';
CREATE OPERATOR pg_catalog.>=(leftarg = json, rightarg = "any", procedure = pg_catalog.json_ge);
DROP FUNCTION IF EXISTS pg_catalog.json_ge(text, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_ge(text, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ge';
CREATE OPERATOR pg_catalog.>=(leftarg = text, rightarg = json, procedure = pg_catalog.json_ge);
DROP FUNCTION IF EXISTS pg_catalog.json_ge(bit, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_ge(bit, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ge';
CREATE OPERATOR pg_catalog.>=(leftarg = bit, rightarg = json, procedure = pg_catalog.json_ge);
DROP FUNCTION IF EXISTS pg_catalog.json_ge(boolean, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_ge(boolean, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ge';
CREATE OPERATOR pg_catalog.>=(leftarg = boolean, rightarg = json, procedure = pg_catalog.json_ge);
DROP FUNCTION IF EXISTS pg_catalog.json_ge(year, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_ge(year, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_ge';
CREATE OPERATOR pg_catalog.>=(leftarg = year, rightarg = json, procedure = pg_catalog.json_ge);

DROP FUNCTION IF EXISTS pg_catalog.json_lt(json, "any");
CREATE OR REPLACE FUNCTION pg_catalog.json_lt(json, "any") RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_lt';
CREATE OPERATOR pg_catalog.<(leftarg = json, rightarg = "any", procedure = pg_catalog.json_lt);
DROP FUNCTION IF EXISTS pg_catalog.json_lt(text, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_lt(text, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_lt';
CREATE OPERATOR pg_catalog.<(leftarg = text, rightarg = json, procedure = pg_catalog.json_lt);
DROP FUNCTION IF EXISTS pg_catalog.json_lt(bit, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_lt(bit, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_lt';
CREATE OPERATOR pg_catalog.<(leftarg = bit, rightarg = json, procedure = pg_catalog.json_lt);
DROP FUNCTION IF EXISTS pg_catalog.json_lt(boolean, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_lt(boolean, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_lt';
CREATE OPERATOR pg_catalog.<(leftarg = boolean, rightarg = json, procedure = pg_catalog.json_lt);
DROP FUNCTION IF EXISTS pg_catalog.json_lt(year, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_lt(year, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_lt';
CREATE OPERATOR pg_catalog.<(leftarg = year, rightarg = json, procedure = pg_catalog.json_lt);

DROP FUNCTION IF EXISTS pg_catalog.json_le(json, "any");
CREATE OR REPLACE FUNCTION pg_catalog.json_le(json, "any") RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_le';
CREATE OPERATOR pg_catalog.<=(leftarg = json, rightarg = "any", procedure = pg_catalog.json_le);
DROP FUNCTION IF EXISTS pg_catalog.json_le(text, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_le(text, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_le';
CREATE OPERATOR pg_catalog.<=(leftarg = text, rightarg = json, procedure = pg_catalog.json_le);
DROP FUNCTION IF EXISTS pg_catalog.json_le(bit, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_le(bit, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_le';
CREATE OPERATOR pg_catalog.<=(leftarg = bit, rightarg = json, procedure = pg_catalog.json_le);
DROP FUNCTION IF EXISTS pg_catalog.json_le(boolean, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_le(boolean, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_le';
CREATE OPERATOR pg_catalog.<=(leftarg = boolean, rightarg = json, procedure = pg_catalog.json_le);
DROP FUNCTION IF EXISTS pg_catalog.json_le(year, json);
CREATE OR REPLACE FUNCTION pg_catalog.json_le(year, json) RETURNS bool LANGUAGE C IMMUTABLE as '$libdir/dolphin','json_le';
CREATE OPERATOR pg_catalog.<=(leftarg = year, rightarg = json, procedure = pg_catalog.json_le);

DROP FUNCTION IF EXISTS pg_catalog.b_mod(json, anyelement);
CREATE OR REPLACE FUNCTION pg_catalog.b_mod(json, anyelement)
returns numeric
as
$$
begin
    return $1::double % $2::double;
end;
$$
language plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.b_mod(anyelement, json);
CREATE OR REPLACE FUNCTION pg_catalog.b_mod(anyelement, json)
returns numeric
as
$$
begin
    return $1::double % $2::double;
end;
$$
language plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.b_mod(json, json);
CREATE OR REPLACE FUNCTION pg_catalog.b_mod(json, json)
returns numeric
as
$$
begin
    return $1::double % $2::double;
end;
$$
language plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.div(json, anyelement);
CREATE OR REPLACE FUNCTION pg_catalog.div(json, anyelement)
returns numeric
as
$$
begin
    return $1::double / $2::double;
end;
$$
language plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.div(anyelement, json);
CREATE OR REPLACE FUNCTION pg_catalog.div(anyelement, json)
returns numeric
as
$$
begin
    return $1::double / $2::double;
end;
$$
language plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.div(json, json);
CREATE OR REPLACE FUNCTION pg_catalog.div(json, json)
returns numeric
as
$$
begin
    return $1::double / $2::double;
end;
$$
language plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.xor(a json, b anyelement);
CREATE OR REPLACE FUNCTION pg_catalog.xor(a json, b anyelement)
returns integer
as
$$
begin
    return (select a ^ b);
end;
$$
language plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.xor(a anyelement, b json);
CREATE OR REPLACE FUNCTION pg_catalog.xor(a anyelement, b json)
returns integer
as
$$
begin
    return (select a ^ b);
end;
$$
language plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.xor(a json, b json);
CREATE OR REPLACE FUNCTION pg_catalog.xor(a json, b json)
returns integer
as
$$
begin
    return (select a ^ b);
end;
$$
language plpgsql;

DROP FUNCTION IF EXISTS pg_catalog.a_sysdate();
CREATE OR REPLACE FUNCTION pg_catalog.a_sysdate()
returns timestamp without time zone LANGUAGE SQL
VOLATILE as $$ SELECT CURRENT_TIMESTAMP::timestamp(0) without time zone$$;

DROP CAST IF EXISTS (json AS boolean);
DROP FUNCTION IF EXISTS pg_catalog.json_to_bool(json);
CREATE OR REPLACE FUNCTION pg_catalog.json_to_bool(json) 
RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as text) as boolean)';
CREATE CAST (json AS boolean) WITH FUNCTION json_to_bool(json) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.hex(int8);
DROP FUNCTION IF EXISTS pg_catalog.hex(int16);
CREATE OR REPLACE FUNCTION pg_catalog.hex(int16) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'int_to_hex';

DROP FUNCTION IF EXISTS pg_catalog.bit_bin_in(cstring, oid, integer);
CREATE OR REPLACE FUNCTION pg_catalog.bit_bin_in(cstring, oid, integer) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','bit_bin_in';

DROP FUNCTION IF EXISTS pg_catalog.b_mod(a numeric, b numeric);
CREATE OR REPLACE FUNCTION pg_catalog.b_mod(a numeric, b numeric) returns numeric LANGUAGE SQL IMMUTABLE STRICT as 'select a % b';
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);
CREATE OR REPLACE FUNCTION pg_catalog.date_cast(cstring, boolean) RETURNS date LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_cast';

DROP FUNCTION IF EXISTS pg_catalog.timestamp_cast(cstring, oid, integer, boolean);
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_cast(cstring, oid, integer, boolean) RETURNS timestamp without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamp_cast';

DROP FUNCTION IF EXISTS pg_catalog.timestamptz_cast(cstring, oid, integer, boolean);
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_cast(cstring, oid, integer, boolean) RETURNS timestamp with time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptz_cast';

DROP FUNCTION IF EXISTS pg_catalog.time_cast(cstring, boolean);
CREATE OR REPLACE FUNCTION pg_catalog.time_cast(cstring, boolean) RETURNS time without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_cast';

DROP CAST IF EXISTS (TEXT AS time);
DROP FUNCTION IF EXISTS pg_catalog.time_cast_implicit(TEXT);
CREATE OR REPLACE FUNCTION pg_catalog.time_cast_implicit(TEXT) RETURNS time without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'time_cast_implicit';

DROP FUNCTION IF EXISTS pg_catalog.text_time_explicit(TEXT);
CREATE OR REPLACE FUNCTION pg_catalog.text_time_explicit(TEXT) RETURNS time without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_time_explicit';

CREATE CAST(TEXT AS time) WITH FUNCTION time_cast_implicit(TEXT) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.date_cast_datetime(date) RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'date_cast_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.date_cast_timestamptz(date) RETURNS timestamp LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'date_cast_timestamptz';

DROP FUNCTION IF EXISTS pg_catalog.day(time without time zone);
CREATE OR REPLACE FUNCTION pg_catalog.day(time without time zone) RETURNS int4 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'dayofmonth_time';

DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(text);
CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(text) RETURNS int8 LANGUAGE C STABLE RETURNS NULL ON NULL INPUT as '$libdir/dolphin', 'time_to_sec';

DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(int8);
CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(int8) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_time_to_sec';

DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(numeric);
CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(numeric) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_time_to_sec';

DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(timestamp without time zone);
CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(timestamp without time zone) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_time_to_sec';

DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(timestamp with time zone);
CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(timestamp with time zone) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_time_to_sec';

DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(date);
CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(date) RETURNS int8 AS $$ SELECT pg_catalog.time_to_sec(cast($1 as timestamp without time zone)) $$ LANGUAGE SQL;

DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(year);
CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(year) RETURNS int8 AS $$ SELECT pg_catalog.time_to_sec(cast($1 as int8)) $$ LANGUAGE SQL;

DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(longblob);
CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(longblob) RETURNS int8 AS $$ SELECT pg_catalog.time_to_sec(cast($1 as text)) $$ LANGUAGE SQL;

DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(bit);
CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(bit) RETURNS int8 AS $$ SELECT pg_catalog.time_to_sec(cast($1 as text)) $$ LANGUAGE SQL;

DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(anyset);
CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(anyset) RETURNS int8 AS $$ SELECT pg_catalog.time_to_sec(cast($1 as text)) $$ LANGUAGE SQL;

DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(anyenum);
CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(anyenum) RETURNS int8 AS $$ SELECT pg_catalog.time_to_sec(cast($1 as text)) $$ LANGUAGE SQL;

DROP FUNCTION IF EXISTS pg_catalog.time_to_sec(json);
CREATE OR REPLACE FUNCTION pg_catalog.time_to_sec(json) RETURNS int8 AS $$ SELECT pg_catalog.time_to_sec(cast($1 as timestamp without time zone)) $$ LANGUAGE SQL;

--CREATE TIME_TIMESTAMP'S COMPARATION FUNCTION
DROP FUNCTION IF EXISTS pg_catalog.time_eq_timestamp (time, timestamp without time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_eq_timestamp (time, timestamp without time zone) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_eq_timestamp';
DROP FUNCTION IF EXISTS pg_catalog.time_ne_timestamp (time, timestamp without time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_ne_timestamp (time, timestamp without time zone) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_ne_timestamp';
DROP FUNCTION IF EXISTS pg_catalog.time_le_timestamp (time, timestamp without time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_le_timestamp (time, timestamp without time zone) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_le_timestamp';
DROP FUNCTION IF EXISTS pg_catalog.time_lt_timestamp (time, timestamp without time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_lt_timestamp (time, timestamp without time zone) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_lt_timestamp';
DROP FUNCTION IF EXISTS pg_catalog.time_ge_timestamp (time, timestamp without time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_ge_timestamp (time, timestamp without time zone) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_ge_timestamp';
DROP FUNCTION IF EXISTS pg_catalog.time_gt_timestamp (time, timestamp without time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_gt_timestamp (time, timestamp without time zone) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_gt_timestamp';
--CREATE TIME_TIMESTAMP CMP OPERATOR

CREATE OPERATOR pg_catalog.=(leftarg = time, rightarg = timestamp without time zone, procedure = time_eq_timestamp, restrict = eqsel, join = eqjoinsel, MERGES);

CREATE OPERATOR pg_catalog.<>(leftarg = time, rightarg = timestamp without time zone, procedure = time_ne_timestamp, restrict = neqsel, join = neqjoinsel);

CREATE OPERATOR pg_catalog.<=(leftarg = time, rightarg = timestamp without time zone, procedure = time_le_timestamp, COMMUTATOR  = >=, NEGATOR  = >, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.<(leftarg = time, rightarg = timestamp without time zone, procedure = time_lt_timestamp, COMMUTATOR  = >, NEGATOR  = >=, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.>=(leftarg = time, rightarg = timestamp without time zone, procedure = time_ge_timestamp, COMMUTATOR  = <=, NEGATOR  = <, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.>(leftarg = time, rightarg = timestamp without time zone, procedure = time_gt_timestamp, COMMUTATOR  = <, NEGATOR  = <=, restrict = scalarltsel, join = scalarltjoinsel);
--CREATE TIMESTAMP_TIME'S COMPARATION FUNCTION
DROP FUNCTION IF EXISTS pg_catalog.timestamp_eq_time (timestamp without time zone, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_eq_time (timestamp without time zone, time) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_eq_time';
DROP FUNCTION IF EXISTS pg_catalog.timestamp_ne_time (timestamp without time zone, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_ne_time (timestamp without time zone, time) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_ne_time';
DROP FUNCTION IF EXISTS pg_catalog.timestamp_le_time (timestamp without time zone, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_le_time (timestamp without time zone, time) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_le_time';
DROP FUNCTION IF EXISTS pg_catalog.timestamp_lt_time (timestamp without time zone, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_lt_time (timestamp without time zone, time) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_lt_time';
DROP FUNCTION IF EXISTS pg_catalog.timestamp_ge_time (timestamp without time zone, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_ge_time (timestamp without time zone, time) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_ge_time';
DROP FUNCTION IF EXISTS pg_catalog.timestamp_gt_time (timestamp without time zone, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_gt_time (timestamp without time zone, time) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamp_gt_time';
--CREATE TIMESTAMP_TIME CMP OPERATOR

CREATE OPERATOR pg_catalog.=(leftarg = timestamp without time zone, rightarg = time, procedure = timestamp_eq_time, restrict = eqsel, join = eqjoinsel, MERGES);

CREATE OPERATOR pg_catalog.<>(leftarg = timestamp without time zone, rightarg = time, procedure = timestamp_ne_time, restrict = neqsel, join = neqjoinsel);

CREATE OPERATOR pg_catalog.<=(leftarg = timestamp without time zone, rightarg = time, procedure = timestamp_le_time, COMMUTATOR  = >=, NEGATOR  = >, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.<(leftarg = timestamp without time zone, rightarg = time, procedure = timestamp_lt_time, COMMUTATOR  = >, NEGATOR  = >=, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.>=(leftarg = timestamp without time zone, rightarg = time, procedure = timestamp_ge_time, COMMUTATOR  = <=, NEGATOR  = <, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.>(leftarg = timestamp without time zone, rightarg = time, procedure = timestamp_gt_time, COMMUTATOR  = <, NEGATOR  = <=, restrict = scalarltsel, join = scalarltjoinsel);

--CREATE TIME_TIMESTAMPTZ'S COMPARATION FUNCTION
DROP FUNCTION IF EXISTS pg_catalog.time_eq_timestamptz (time, timestamp with time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_eq_timestamptz (time, timestamp with time zone) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_eq_timestamptz';
DROP FUNCTION IF EXISTS pg_catalog.time_ne_timestamptz (time, timestamp with time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_ne_timestamptz (time, timestamp with time zone) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_ne_timestamptz';
DROP FUNCTION IF EXISTS pg_catalog.time_le_timestamptz (time, timestamp with time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_le_timestamptz (time, timestamp with time zone) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_le_timestamptz';
DROP FUNCTION IF EXISTS pg_catalog.time_lt_timestamptz (time, timestamp with time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_lt_timestamptz (time, timestamp with time zone) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_lt_timestamptz';
DROP FUNCTION IF EXISTS pg_catalog.time_ge_timestamptz (time, timestamp with time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_ge_timestamptz (time, timestamp with time zone) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_ge_timestamptz';
DROP FUNCTION IF EXISTS pg_catalog.time_gt_timestamptz (time, timestamp with time zone) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.time_gt_timestamptz (time, timestamp with time zone) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'time_gt_timestamptz';
--CREATE TIME_TIMESTAMPTZ CMP OPERATOR

CREATE OPERATOR pg_catalog.=(leftarg = time, rightarg = timestamp with time zone, procedure = time_eq_timestamptz, restrict = eqsel, join = eqjoinsel, MERGES);

CREATE OPERATOR pg_catalog.<>(leftarg = time, rightarg = timestamp with time zone, procedure = time_ne_timestamptz, restrict = neqsel, join = neqjoinsel);

CREATE OPERATOR pg_catalog.<=(leftarg = time, rightarg = timestamp with time zone, procedure = time_le_timestamptz, COMMUTATOR  = >=, NEGATOR  = >, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.<(leftarg = time, rightarg = timestamp with time zone, procedure = time_lt_timestamptz, COMMUTATOR  = >, NEGATOR  = >=, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.>=(leftarg = time, rightarg = timestamp with time zone, procedure = time_ge_timestamptz, COMMUTATOR  = <=, NEGATOR  = <, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.>(leftarg = time, rightarg = timestamp with time zone, procedure = time_gt_timestamptz, COMMUTATOR  = <, NEGATOR  = <=, restrict = scalarltsel, join = scalarltjoinsel);
--CREATE TIMESTAMPTZ_TIME'S COMPARATION FUNCTION
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_eq_time (timestamp with time zone, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_eq_time (timestamp with time zone, time) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_eq_time';
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_ne_time (timestamp with time zone, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_ne_time (timestamp with time zone, time) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_ne_time';
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_le_time (timestamp with time zone, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_le_time (timestamp with time zone, time) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_le_time';
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_lt_time (timestamp with time zone, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_lt_time (timestamp with time zone, time) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_lt_time';
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_ge_time (timestamp with time zone, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_ge_time (timestamp with time zone, time) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_ge_time';
DROP FUNCTION IF EXISTS pg_catalog.timestamptz_gt_time (timestamp with time zone, time) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_gt_time (timestamp with time zone, time) RETURNS boolean LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'timestamptz_gt_time';
--CREATE TIMESTAMPTZ_TIME CMP OPERATOR

CREATE OPERATOR pg_catalog.=(leftarg = timestamp with time zone, rightarg = time, procedure = timestamptz_eq_time, restrict = eqsel, join = eqjoinsel, MERGES);

CREATE OPERATOR pg_catalog.<>(leftarg = timestamp with time zone, rightarg = time, procedure = timestamptz_ne_time, restrict = neqsel, join = neqjoinsel);

CREATE OPERATOR pg_catalog.<=(leftarg = timestamp with time zone, rightarg = time, procedure = timestamptz_le_time, COMMUTATOR  = >=, NEGATOR  = >, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.<(leftarg = timestamp with time zone, rightarg = time, procedure = timestamptz_lt_time, COMMUTATOR  = >, NEGATOR  = >=, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.>=(leftarg = timestamp with time zone, rightarg = time, procedure = timestamptz_ge_time, COMMUTATOR  = <=, NEGATOR  = <, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR pg_catalog.>(leftarg = timestamp with time zone, rightarg = time, procedure = timestamptz_gt_time, COMMUTATOR  = <, NEGATOR  = <=, restrict = scalarltsel, join = scalarltjoinsel);

--change bit -> int/bigint castcontext from 'e' to 'a'
do $$
begin
    update pg_cast set castcontext='a', castowner=10 where castsource=1560 and casttarget=20 and castcontext='e';
    update pg_cast set castcontext='a', castowner=10 where castsource=1560 and casttarget=23 and castcontext='e';
    update pg_cast set castcontext='a', castowner=10 where castsource=20 and casttarget=1560 and castcontext='e';
    update pg_cast set castcontext='a', castowner=10 where castsource=23 and casttarget=1560 and castcontext='e';
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) AS ASSIGNMENT;
CREATE CAST (uint8 AS bit) WITH FUNCTION bitfromuint8(uint8, int4) AS ASSIGNMENT;

-- non-strict, accept null input
CREATE OR REPLACE FUNCTION pg_catalog.rand(int16) returns double precision LANGUAGE C volatile as '$libdir/dolphin', 'rand_seed';
CREATE OR REPLACE FUNCTION pg_catalog.rand(uint4) returns double precision LANGUAGE SQL volatile as 'select rand($1::int16)';
CREATE OR REPLACE FUNCTION pg_catalog.rand(timestamp with time zone) returns double precision LANGUAGE SQL volatile as 'select rand($1::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.rand(date) returns double precision LANGUAGE SQL volatile as 'select rand($1::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.rand(year) returns double precision LANGUAGE SQL volatile as 'select rand($1::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.rand(binary) returns double precision LANGUAGE SQL volatile as 'select rand($1::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.rand(blob) returns double precision LANGUAGE SQL volatile as 'select rand($1::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.rand(anyenum) returns double precision LANGUAGE SQL volatile as 'select rand($1::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.rand(anyset) returns double precision LANGUAGE SQL volatile as 'select rand($1::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.rand(json) returns double precision LANGUAGE SQL volatile as 'select rand($1::int8)';

CREATE OR REPLACE FUNCTION pg_catalog.random_bytes(int4) returns blob LANGUAGE C volatile STRICT as '$libdir/dolphin', 'random_bytes';
CREATE OR REPLACE FUNCTION pg_catalog.random_bytes(bit) returns blob LANGUAGE SQL volatile as 'select random_bytes($1::int4)';
CREATE OR REPLACE FUNCTION pg_catalog.random_bytes(timestamp with time zone) returns blob LANGUAGE SQL volatile as 'select random_bytes($1::int4)';
CREATE OR REPLACE FUNCTION pg_catalog.random_bytes(date) returns blob LANGUAGE SQL volatile as 'select random_bytes($1::int4)';
CREATE OR REPLACE FUNCTION pg_catalog.random_bytes(year) returns blob LANGUAGE SQL volatile as 'select random_bytes($1::int4)';
CREATE OR REPLACE FUNCTION pg_catalog.random_bytes(binary) returns blob LANGUAGE SQL volatile as 'select random_bytes($1::int4)';
CREATE OR REPLACE FUNCTION pg_catalog.random_bytes(blob) returns blob LANGUAGE SQL volatile as 'select random_bytes($1::int4)';
CREATE OR REPLACE FUNCTION pg_catalog.random_bytes(anyenum) returns blob LANGUAGE SQL volatile as 'select random_bytes($1::int4)';
CREATE OR REPLACE FUNCTION pg_catalog.random_bytes(anyset) returns blob LANGUAGE SQL volatile as 'select random_bytes($1::int4)';
CREATE OR REPLACE FUNCTION pg_catalog.random_bytes(json) returns blob LANGUAGE SQL volatile as 'select random_bytes($1::int4)';

-- The reason for using replace is because we don't want to change the OID
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_rawout (
tinyblob
) RETURNS cstring LANGUAGE  C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_blob_rawout';

CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_rawout (
mediumblob
) RETURNS cstring LANGUAGE  C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_blob_rawout';

CREATE OR REPLACE FUNCTION pg_catalog.longblob_rawout (
longblob
) RETURNS cstring LANGUAGE  C IMMUTABLE STRICT as '$libdir/dolphin',  'dolphin_blob_rawout';

-- Make the result of oct(bit) and conv(bit) identical to Mysql
DROP FUNCTION IF EXISTS pg_catalog.conv(bit, int4, int4) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.conv(bit, int4, int4) 
RETURNS text AS $$ SELECT pg_catalog.conv($1::int8, 10, $3) $$ LANGUAGE SQL;

DROP FUNCTION IF EXISTS pg_catalog.oct(bit);

CREATE OR REPLACE FUNCTION pg_catalog.oct(t1 bit)
RETURNS text AS $$ SELECT pg_catalog.conv(t1, 10, 8) $$ LANGUAGE SQL;

-- Supplement function dayofmonth to make the function dayofmonth() the same as function day()
DROP FUNCTION IF EXISTS pg_catalog.dayofmonth(text);
DROP FUNCTION IF EXISTS pg_catalog.dayofmonth(numeric);
CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth(text) RETURNS int4 AS $$ SELECT pg_catalog.day($1); $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.dayofmonth(numeric) RETURNS int4 AS $$ SELECT pg_catalog.day($1); $$ LANGUAGE SQL;

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); 
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_bool(timestamptz) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'timestamptz_bool';
CREATE CAST (timestamptz as boolean) WITH FUNCTION timestamptz_bool(timestamptz) AS ASSIGNMENT;

drop function if EXISTS pg_catalog.length(binary);
drop function if EXISTS pg_catalog.length(varbinary);
CREATE OR REPLACE FUNCTION pg_catalog.length(binary) returns int4 LANGUAGE C immutable strict as '$libdir/dolphin', 'binary_length';
CREATE OR REPLACE FUNCTION pg_catalog.length(varbinary) returns int4 LANGUAGE C immutable strict as '$libdir/dolphin', 'binary_length';

CREATE OR REPLACE FUNCTION pg_catalog.timestamp_bool(timestamp(0) without time zone) returns boolean LANGUAGE C immutable strict as '$libdir/dolphin', 'timestamp_bool';
CREATE CAST (timestamp(0) without time zone as boolean) WITH FUNCTION timestamp_bool(timestamp(0) without time zone) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.date_format (time without time zone, text);
CREATE OR REPLACE FUNCTION pg_catalog.date_format (time without time zone, text) RETURNS TEXT LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'date_format_time';

DROP FUNCTION IF EXISTS pg_catalog.to_char(time without time zone, text);
CREATE OR REPLACE FUNCTION pg_catalog.to_char(time without time zone, text) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT pg_catalog.to_char($1::interval, $2) $$;

CREATE OR REPLACE FUNCTION pg_catalog.bit_cast_date(bit) 
RETURNS date LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as text) as date)';

CREATE OR REPLACE FUNCTION pg_catalog.bit_cast_datetime(bit) 
RETURNS timestamp without time zone LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as text) as timestamp without time zone)';

CREATE OR REPLACE FUNCTION pg_catalog.bit_cast_timestamp(bit) 
RETURNS timestamptz LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as text) as timestamptz)';

CREATE OR REPLACE FUNCTION pg_catalog.bit_cast_time(bit) 
RETURNS time without time zone LANGUAGE SQL IMMUTABLE STRICT as 
'select cast(cast($1 as text) as time without time zone)';

CREATE OR REPLACE FUNCTION pg_catalog.int8_cast_time(int1)
RETURNS time without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_cast_time';
CREATE OR REPLACE FUNCTION pg_catalog.int16_cast_time(int2)
RETURNS time without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_cast_time';
CREATE OR REPLACE FUNCTION pg_catalog.int32_cast_time(int4)
RETURNS time without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int32_cast_time';
CREATE OR REPLACE FUNCTION pg_catalog.int64_cast_time(int8)
RETURNS time without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_cast_time';

CREATE OR REPLACE FUNCTION pg_catalog.uint8_cast_time(uint1)
RETURNS time without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint8_cast_time';
CREATE OR REPLACE FUNCTION pg_catalog.uint16_cast_time(uint2)
RETURNS time without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint16_cast_time';
CREATE OR REPLACE FUNCTION pg_catalog.uint32_cast_time(uint4)
RETURNS time without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint32_cast_time';
CREATE OR REPLACE FUNCTION pg_catalog.uint64_cast_time(uint8)
RETURNS time without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint64_cast_time';

CREATE OR REPLACE FUNCTION pg_catalog.float4_cast_time(float4)
RETURNS time without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float4_cast_time';
CREATE OR REPLACE FUNCTION pg_catalog.float8_cast_time(float8)
RETURNS time without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float8_cast_time';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_cast_time(numeric)
RETURNS time without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_cast_time';
create or replace function pg_catalog."user"() returns name as 'select current_user' LANGUAGE 'sql' IMMUTABLE;
create or replace function pg_catalog."user"() returns name as 'select current_user' LANGUAGE 'sql' IMMUTABLE;

DROP FUNCTION IF EXISTS pg_catalog.hour (text);
DROP FUNCTION IF EXISTS pg_catalog.microsecond (text);
DROP FUNCTION IF EXISTS pg_catalog.minute (text);
DROP FUNCTION IF EXISTS pg_catalog.second (text);

CREATE OR REPLACE FUNCTION pg_catalog.hour (text) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetHour';
CREATE OR REPLACE FUNCTION pg_catalog.microsecond (text) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMicrosecond';
CREATE OR REPLACE FUNCTION pg_catalog.minute (text) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMinute';
CREATE OR REPLACE FUNCTION pg_catalog.second (text) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetSecond';


CREATE OR REPLACE FUNCTION pg_catalog.hour (date) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetHourFromDate';
CREATE OR REPLACE FUNCTION pg_catalog.microsecond (date) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMicrosecondFromDate';
CREATE OR REPLACE FUNCTION pg_catalog.minute (date) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMinuteFromDate';
CREATE OR REPLACE FUNCTION pg_catalog.second (date) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetSecondFromDate';

CREATE OR REPLACE FUNCTION pg_catalog.hour (timetz) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetHourFromTimeTz';
CREATE OR REPLACE FUNCTION pg_catalog.microsecond (timetz) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMicrosecondFromTimeTz';
CREATE OR REPLACE FUNCTION pg_catalog.minute (timetz) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMinuteFromTimeTz';
CREATE OR REPLACE FUNCTION pg_catalog.second (timetz) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetSecondFromTimeTz';

CREATE OR REPLACE FUNCTION pg_catalog.hour (timestamptz) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetHourFromTimestampTz';
CREATE OR REPLACE FUNCTION pg_catalog.microsecond (timestamptz) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMicrosecondFromTimestampTz';
CREATE OR REPLACE FUNCTION pg_catalog.minute (timestamptz) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetMinuteFromTimestampTz';
CREATE OR REPLACE FUNCTION pg_catalog.second (timestamptz) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'GetSecondFromTimestampTz';


CREATE OR REPLACE FUNCTION pg_catalog.hour (year) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT hour($1::time)';
CREATE OR REPLACE FUNCTION pg_catalog.minute (year) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT minute($1::time)';
CREATE OR REPLACE FUNCTION pg_catalog.second (year) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT second($1::time)';

DROP FUNCTION IF EXISTS pg_catalog.year(timestamp(0) without time zone);
DROP FUNCTION IF EXISTS pg_catalog.year(text);
CREATE FUNCTION pg_catalog.year (timestamp(0) without time zone) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'datetime_year_part';
CREATE FUNCTION pg_catalog.year (text) RETURNS int8 LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'text_year_part';
CREATE OR REPLACE FUNCTION pg_catalog.year(year) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT year($1::text)';

CREATE OR REPLACE FUNCTION pg_catalog.year(bit) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT year($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.year(boolean) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT year($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.year(int4) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT year($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.year(longblob) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT year($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.year(anyenum) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT year($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.year(json) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT year($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.year(time) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT year($1::timestamp(0) without time zone)';


CREATE OR REPLACE FUNCTION pg_catalog.convert_datetime_double(double precision) RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'convert_datetime_double';
CREATE OR REPLACE FUNCTION pg_catalog.convert_timestamptz_double(double precision) RETURNS timestamp LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'convert_timestamptz_double';
CREATE OR REPLACE FUNCTION pg_catalog.convert_datetime_uint8(uint8) RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'convert_datetime_uint64';
CREATE OR REPLACE FUNCTION pg_catalog.convert_timestamptz_uint8(uint8) RETURNS timestamp LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'convert_timestamptz_uint64';

create or replace function pg_catalog.datetime_double_gt(
    timestamp without time zone,
    double precision
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 > convert_datetime_double($2)) $$;
create operator pg_catalog.>(leftarg = timestamp without time zone, rightarg = double precision, procedure = pg_catalog.datetime_double_gt);
 
create or replace function pg_catalog.datetime_double_ge(
    timestamp without time zone,
    double precision
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 >= convert_datetime_double($2)) $$;
create operator pg_catalog.>=(leftarg = timestamp without time zone, rightarg = double precision, procedure = pg_catalog.datetime_double_ge);

create or replace function pg_catalog.datetime_double_lt(
    timestamp without time zone,
    double precision
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 < convert_datetime_double($2)) $$;
create operator pg_catalog.<(leftarg = timestamp without time zone, rightarg = double precision, procedure = pg_catalog.datetime_double_lt);

create or replace function pg_catalog.datetime_double_le(
    timestamp without time zone,
    double precision
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 <= convert_datetime_double($2)) $$;
create operator pg_catalog.<=(leftarg = timestamp without time zone, rightarg = double precision, procedure = pg_catalog.datetime_double_le);

create or replace function pg_catalog.datetime_double_eq(
    timestamp without time zone,
    double precision
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 = convert_datetime_double($2)) $$;
create operator pg_catalog.=(leftarg = timestamp without time zone, rightarg = double precision, procedure = pg_catalog.datetime_double_eq);

create or replace function pg_catalog.datetime_double_ne(
    timestamp without time zone,
    double precision
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 <> convert_datetime_double($2)) $$;
create operator pg_catalog.<>(leftarg = timestamp without time zone, rightarg = double precision, procedure = pg_catalog.datetime_double_ne);


create or replace function pg_catalog.timestamp_double_gt(
    timestamptz,
    double precision
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 > convert_timestamptz_double($2)) $$;
create operator pg_catalog.>(leftarg = timestamptz, rightarg = double precision, procedure = pg_catalog.timestamp_double_gt);

create or replace function pg_catalog.timestamp_double_ge(
    timestamptz,
    double precision
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 >= convert_timestamptz_double($2)) $$;
create operator pg_catalog.>=(leftarg = timestamptz, rightarg = double precision, procedure = pg_catalog.timestamp_double_ge);

create or replace function pg_catalog.timestamp_double_lt(
    timestamptz,
    double precision
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 < convert_timestamptz_double($2)) $$;
create operator pg_catalog.<(leftarg = timestamptz, rightarg = double precision, procedure = pg_catalog.timestamp_double_lt);

create or replace function pg_catalog.timestamp_double_le(
    timestamptz,
    double precision
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 <= convert_timestamptz_double($2)) $$;
create operator pg_catalog.<=(leftarg = timestamptz, rightarg = double precision, procedure = pg_catalog.timestamp_double_le);

create or replace function pg_catalog.timestamp_double_eq(
    timestamptz,
    double precision
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 = convert_timestamptz_double($2)) $$;
create operator pg_catalog.=(leftarg = timestamptz, rightarg = double precision, procedure = pg_catalog.timestamp_double_eq);

create or replace function pg_catalog.timestamp_double_ne(
    timestamptz,
    double precision
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 <> convert_timestamptz_double($2)) $$;
create operator pg_catalog.<>(leftarg = timestamptz, rightarg = double precision, procedure = pg_catalog.timestamp_double_ne);

create or replace function pg_catalog.datetime_uint8_gt(
    timestamp without time zone,
    uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 > convert_datetime_uint8($2)) $$;
create operator pg_catalog.>(leftarg = timestamp without time zone, rightarg = uint8, procedure = pg_catalog.datetime_uint8_gt);
 
create or replace function pg_catalog.datetime_uint8_ge(
    timestamp without time zone,
    uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 >= convert_datetime_uint8($2)) $$;
create operator pg_catalog.>=(leftarg = timestamp without time zone, rightarg = uint8, procedure = pg_catalog.datetime_uint8_ge);

create or replace function pg_catalog.datetime_uint8_lt(
    timestamp without time zone,
    uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 < convert_datetime_uint8($2)) $$;
create operator pg_catalog.<(leftarg = timestamp without time zone, rightarg = uint8, procedure = pg_catalog.datetime_uint8_lt);

create or replace function pg_catalog.datetime_uint8_le(
    timestamp without time zone,
    uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 <= convert_datetime_uint8($2)) $$;
create operator pg_catalog.<=(leftarg = timestamp without time zone, rightarg = uint8, procedure = pg_catalog.datetime_uint8_le);

create or replace function pg_catalog.datetime_uint8_eq(
    timestamp without time zone,
    uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 = convert_datetime_uint8($2)) $$;
create operator pg_catalog.=(leftarg = timestamp without time zone, rightarg = uint8, procedure = pg_catalog.datetime_uint8_eq);

create or replace function pg_catalog.datetime_uint8_ne(
    timestamp without time zone,
    uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 <> convert_datetime_uint8($2)) $$;
create operator pg_catalog.<>(leftarg = timestamp without time zone, rightarg = uint8, procedure = pg_catalog.datetime_uint8_ne);


create or replace function pg_catalog.timestamp_uint8_gt(
    timestamptz,
    uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 > convert_timestamptz_uint8($2)) $$;
create operator pg_catalog.>(leftarg = timestamptz, rightarg = uint8, procedure = pg_catalog.timestamp_uint8_gt);

create or replace function pg_catalog.timestamp_uint8_ge(
    timestamptz,
    uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 >= convert_timestamptz_uint8($2)) $$;
create operator pg_catalog.>=(leftarg = timestamptz, rightarg = uint8, procedure = pg_catalog.timestamp_uint8_ge);

create or replace function pg_catalog.timestamp_uint8_lt(
    timestamptz,
    uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 < convert_timestamptz_uint8($2)) $$;
create operator pg_catalog.<(leftarg = timestamptz, rightarg = uint8, procedure = pg_catalog.timestamp_uint8_lt);

create or replace function pg_catalog.timestamp_uint8_le(
    timestamptz,
    uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 <= convert_timestamptz_uint8($2)) $$;
create operator pg_catalog.<=(leftarg = timestamptz, rightarg = uint8, procedure = pg_catalog.timestamp_uint8_le);

create or replace function pg_catalog.timestamp_uint8_eq(
    timestamptz,
    uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 = convert_timestamptz_uint8($2)) $$;
create operator pg_catalog.=(leftarg = timestamptz, rightarg = uint8, procedure = pg_catalog.timestamp_uint8_eq);

create or replace function pg_catalog.timestamp_uint8_ne(
    timestamptz,
    uint8
) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as $$ (SELECT $1 <> convert_timestamptz_uint8($2)) $$;
create operator pg_catalog.<>(leftarg = timestamptz, rightarg = uint8, procedure = pg_catalog.timestamp_uint8_ne);

CREATE OR REPLACE FUNCTION pg_catalog.hex(tinyblob) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bytea_to_hex';
CREATE OR REPLACE FUNCTION pg_catalog.hex(blob) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bytea_to_hex';
CREATE OR REPLACE FUNCTION pg_catalog.hex(mediumblob) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bytea_to_hex';
CREATE OR REPLACE FUNCTION pg_catalog.hex(longblob) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bytea_to_hex';

CREATE OR REPLACE FUNCTION pg_catalog.binary_out (binary) RETURNS cstring LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_binaryout';
CREATE OR REPLACE FUNCTION pg_catalog.varbinary_out (varbinary) RETURNS cstring LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_binaryout';

DROP FUNCTION IF EXISTS pg_catalog.double_or_binary(double precision, binary) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.double_or_binary(double precision, binary) RETURNS bigint LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT $1 | $2::numeric $$;
CREATE OPERATOR pg_catalog.|(leftarg = double precision, rightarg = binary, procedure = pg_catalog.double_or_binary);
DROP FUNCTION IF EXISTS pg_catalog.binary_or_double(binary, double precision) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.binary_or_double(binary, double precision) RETURNS bigint LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT $1::numeric | $2 $$;
CREATE OPERATOR pg_catalog.|(leftarg = binary, rightarg = double precision, procedure = pg_catalog.binary_or_double);
DROP FUNCTION IF EXISTS pg_catalog.uint8_or_binary(uint8, binary) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.uint8_or_binary(uint8, binary) RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT $1 | $2::numeric $$;
CREATE OPERATOR pg_catalog.|(leftarg = uint8, rightarg = binary, procedure = pg_catalog.uint8_or_binary);
DROP FUNCTION IF EXISTS pg_catalog.binary_or_uint8(binary, uint8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.binary_or_uint8(binary, uint8) RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT $1::numeric | $2 $$;
CREATE OPERATOR pg_catalog.|(leftarg = binary, rightarg = uint8, procedure = pg_catalog.binary_or_uint8);
DROP FUNCTION IF EXISTS pg_catalog.binary_or_binary(binary, binary) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.binary_or_binary(binary, binary) RETURNS bigint LANGUAGE SQL IMMUTABLE STRICT as $$ SELECT $1::numeric | $2::numeric $$;
CREATE OPERATOR pg_catalog.|(leftarg = binary, rightarg = binary, procedure = pg_catalog.binary_or_binary);

DROP FUNCTION IF EXISTS pg_catalog.div(binary, double precision);
CREATE OR REPLACE FUNCTION pg_catalog.div(binary, double precision)
returns numeric language plpgsql as
$$
declare
    quotient double precision := $1::numeric / $2;
begin
    return sign(quotient) * floor(abs(quotient));
end;
$$;
DROP FUNCTION IF EXISTS pg_catalog.div(double precision, binary);
CREATE OR REPLACE FUNCTION pg_catalog.div(double precision, binary)
returns numeric language plpgsql as
$$
declare
    quotient double precision := $1 / $2::numeric;
begin
    return sign(quotient) * floor(abs(quotient));
end;
$$;
DROP FUNCTION IF EXISTS pg_catalog.div(binary, binary);
CREATE OR REPLACE FUNCTION pg_catalog.div(binary, binary)
returns numeric language plpgsql as
$$
declare
    quotient double precision := $1::numeric / $2::numeric;
begin
    return sign(quotient) * floor(abs(quotient));
end;
$$;

DROP CAST IF EXISTS (year AS boolean);
DROP FUNCTION IF EXISTS pg_catalog.year_to_bool(year);
CREATE OR REPLACE FUNCTION pg_catalog.year_to_bool(year)
RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT as
'select cast(cast($1 as text) as boolean)';
CREATE CAST (year AS boolean) WITH FUNCTION year_to_bool(year) AS IMPLICIT;

-- not operator
DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_int1not(int1) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_int1not(int1) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_int1not';
CREATE OPERATOR dolphin_catalog.~(rightarg = int1, procedure = dolphin_catalog.dolphin_int1not);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_int2not(int2) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_int2not(int2) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_int2not';
CREATE OPERATOR dolphin_catalog.~(rightarg = int2, procedure = dolphin_catalog.dolphin_int2not);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_int4not(int4) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_int4not(int4) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_int4not';
CREATE OPERATOR dolphin_catalog.~(rightarg = int4, procedure = dolphin_catalog.dolphin_int4not);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_int8not(int8) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_int8not(int8) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_int8not';
CREATE OPERATOR dolphin_catalog.~(rightarg = int8, procedure = dolphin_catalog.dolphin_int8not);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_uint1not(uint1) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_uint1not(uint1) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_uint1not';
CREATE OPERATOR dolphin_catalog.~(rightarg = uint1, procedure = dolphin_catalog.dolphin_uint1not);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_uint2not(uint2) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_uint2not(uint2) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_uint2not';
CREATE OPERATOR dolphin_catalog.~(rightarg = uint2, procedure = dolphin_catalog.dolphin_uint2not);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_uint4not(uint4) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_uint4not(uint4) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_uint4not';
CREATE OPERATOR dolphin_catalog.~(rightarg = uint4, procedure = dolphin_catalog.dolphin_uint4not);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_uint8not(uint8) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_uint8not(uint8) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_uint8not';
CREATE OPERATOR dolphin_catalog.~(rightarg = uint8, procedure = dolphin_catalog.dolphin_uint8not);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_float4not(float4) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_float4not(float4) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_float4not';
CREATE OPERATOR dolphin_catalog.~(rightarg = float4, procedure = dolphin_catalog.dolphin_float4not);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_float8not(float8) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_float8not(float8) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_float8not';
CREATE OPERATOR dolphin_catalog.~(rightarg = float8, procedure = dolphin_catalog.dolphin_float8not);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_numericnot(numeric) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_numericnot(numeric) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_numericnot';
CREATE OPERATOR dolphin_catalog.~(rightarg = numeric, procedure = dolphin_catalog.dolphin_numericnot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_bitnot(bit) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_bitnot(bit) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_bitnot';
CREATE OPERATOR dolphin_catalog.~(rightarg = bit, procedure = dolphin_catalog.dolphin_bitnot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_boolnot(boolean) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_boolnot(boolean) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_boolnot';
CREATE OPERATOR dolphin_catalog.~(rightarg = boolean, procedure = dolphin_catalog.dolphin_boolnot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_datenot(date) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_datenot(date) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_datenot';
CREATE OPERATOR dolphin_catalog.~(rightarg = date, procedure = dolphin_catalog.dolphin_datenot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_timenot(time) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_timenot(time) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_timenot';
CREATE OPERATOR dolphin_catalog.~(rightarg = time, procedure = dolphin_catalog.dolphin_timenot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_timestampnot(timestamp without time zone) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_timestampnot(timestamp without time zone) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_timestampnot';
CREATE OPERATOR dolphin_catalog.~(rightarg = timestamp without time zone, procedure = dolphin_catalog.dolphin_timestampnot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_timestamptznot(timestamp with time zone) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_timestamptznot(timestamp with time zone) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_timestamptznot';
CREATE OPERATOR dolphin_catalog.~(rightarg = timestamp with time zone, procedure = dolphin_catalog.dolphin_timestamptznot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_yearnot(year) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_yearnot(year) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_yearnot';
CREATE OPERATOR dolphin_catalog.~(rightarg = year, procedure = dolphin_catalog.dolphin_yearnot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_charnot(char) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_charnot(char) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_charnot';
CREATE OPERATOR dolphin_catalog.~(rightarg = char, procedure = dolphin_catalog.dolphin_charnot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_varcharnot(varchar) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_varcharnot(varchar) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_varcharnot';
CREATE OPERATOR dolphin_catalog.~(rightarg = varchar, procedure = dolphin_catalog.dolphin_varcharnot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_textnot(text) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_textnot(text) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_textnot';
CREATE OPERATOR dolphin_catalog.~(rightarg = text, procedure = dolphin_catalog.dolphin_textnot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_varlenanot(anyelement) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_varlenanot(anyelement) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_varlenanot';
CREATE OPERATOR dolphin_catalog.~(rightarg = anyelement, procedure = dolphin_catalog.dolphin_varlenanot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_enumnot(anyenum) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_enumnot(anyenum) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_enumnot';
CREATE OPERATOR dolphin_catalog.~(rightarg = anyenum, procedure = dolphin_catalog.dolphin_enumnot);

DROP FUNCTION IF EXISTS dolphin_catalog.dolphin_setnot(anyset) CASCADE;
CREATE OR REPLACE FUNCTION dolphin_catalog.dolphin_setnot(anyset) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_setnot';
CREATE OPERATOR dolphin_catalog.~(rightarg = anyset, procedure = dolphin_catalog.dolphin_setnot);

CREATE OR REPLACE FUNCTION pg_catalog.binary_cmp(binary, binary) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';

CREATE OPERATOR FAMILY pg_catalog.binary_ops USING BTREE;
CREATE OPERATOR FAMILY pg_catalog.binary_ops USING HASH;

CREATE OPERATOR CLASS pg_catalog.binary_ops DEFAULT
   FOR TYPE binary USING BTREE FAMILY pg_catalog.binary_ops as
   OPERATOR 1 pg_catalog.<(binary, binary),
   OPERATOR 2 pg_catalog.<=(binary, binary),
   OPERATOR 3 pg_catalog.=(binary, binary),
   OPERATOR 4 pg_catalog.>=(binary, binary),
   OPERATOR 5 pg_catalog.>(binary, binary),
   FUNCTION 1 pg_catalog.binary_cmp(binary, binary),
   FUNCTION 2 pg_catalog.bytea_sortsupport(internal);

CREATE OPERATOR CLASS pg_catalog.binary_ops DEFAULT
   FOR TYPE binary USING HASH FAMILY binary_ops as
   OPERATOR 1 pg_catalog.=(binary, binary),
   FUNCTION 1 (binary, binary) pg_catalog.hashvarlena(internal);

CREATE OR REPLACE FUNCTION pg_catalog.varbinary_cmp(varbinary, varbinary) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR FAMILY pg_catalog.varbinary_ops USING BTREE;
CREATE OPERATOR FAMILY pg_catalog.varbinary_ops USING HASH;

CREATE OPERATOR CLASS pg_catalog.varbinary_ops DEFAULT
   FOR TYPE varbinary USING BTREE FAMILY pg_catalog.varbinary_ops as
   OPERATOR 1 pg_catalog.<(varbinary, varbinary),
   OPERATOR 2 pg_catalog.<=(varbinary, varbinary),
   OPERATOR 3 pg_catalog.=(varbinary, varbinary),
   OPERATOR 4 pg_catalog.>=(varbinary, varbinary),
   OPERATOR 5 pg_catalog.>(varbinary, varbinary),
   FUNCTION 1 pg_catalog.varbinary_cmp(varbinary, varbinary),
   FUNCTION 2 pg_catalog.bytea_sortsupport(internal);

CREATE OPERATOR CLASS pg_catalog.varbinary_ops DEFAULT
   FOR TYPE varbinary USING HASH FAMILY pg_catalog.varbinary_ops as
   OPERATOR 1 pg_catalog.=(varbinary, varbinary),
   FUNCTION 1 (varbinary, varbinary) pg_catalog.hashvarlena(internal);

CREATE OR REPLACE FUNCTION pg_catalog.blob_cmp(blob, blob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR FAMILY pg_catalog.blob_ops USING BTREE;
CREATE OPERATOR FAMILY pg_catalog.blob_ops USING HASH;

-- about blob op family
CREATE OPERATOR CLASS pg_catalog.blob_ops DEFAULT
   FOR TYPE blob USING BTREE FAMILY pg_catalog.blob_ops as
   OPERATOR 1 pg_catalog.<(blob, blob),
   OPERATOR 2 pg_catalog.<=(blob, blob),
   OPERATOR 3 pg_catalog.=(blob, blob),
   OPERATOR 4 pg_catalog.>=(blob, blob),
   OPERATOR 5 pg_catalog.>(blob, blob),
   FUNCTION 1 pg_catalog.blob_cmp(blob, blob),
   FUNCTION 2 pg_catalog.bytea_sortsupport(internal);

CREATE OPERATOR CLASS pg_catalog.blob_ops DEFAULT
   FOR TYPE blob USING HASH FAMILY blob_ops as
   OPERATOR 1 pg_catalog.=(blob, blob),
   FUNCTION 1 (blob, blob) pg_catalog.hashvarlena(internal);

-- about tinyblob op family
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_eq(arg1 tinyblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_ne(arg1 tinyblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_lt(arg1 tinyblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_le(arg1 tinyblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_gt(arg1 tinyblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_ge(arg1 tinyblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_cmp(tinyblob, tinyblob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = tinyblob, rightarg = tinyblob, procedure = tinyblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = tinyblob, rightarg = tinyblob, procedure = tinyblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = tinyblob, rightarg = tinyblob, procedure = tinyblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = tinyblob, rightarg = tinyblob, procedure = tinyblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = tinyblob, rightarg = tinyblob, procedure = tinyblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = tinyblob, rightarg = tinyblob, procedure = tinyblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_eq_text(arg1 tinyblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT tinyblob_eq($1, $2::tinyblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_ne_text(arg1 tinyblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT tinyblob_ne($1, $2::tinyblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_lt_text(arg1 tinyblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT tinyblob_lt($1, $2::tinyblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_le_text(arg1 tinyblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT tinyblob_le($1, $2::tinyblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_gt_text(arg1 tinyblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT tinyblob_gt($1, $2::tinyblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_ge_text(arg1 tinyblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT tinyblob_ge($1, $2::tinyblob) $$;
CREATE OPERATOR pg_catalog.=(leftarg = tinyblob, rightarg = text, procedure = tinyblob_eq_text, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = tinyblob, rightarg = text, procedure = tinyblob_ne_text, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = tinyblob, rightarg = text, procedure = tinyblob_lt_text, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = tinyblob, rightarg = text, procedure = tinyblob_le_text, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = tinyblob, rightarg = text, procedure = tinyblob_gt_text, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = tinyblob, rightarg = text, procedure = tinyblob_ge_text, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.text_eq_tinyblob(arg1 text, arg2 tinyblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT tinyblob_eq($1::tinyblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.text_ne_tinyblob(arg1 text, arg2 tinyblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT tinyblob_ne($1::tinyblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.text_lt_tinyblob(arg1 text, arg2 tinyblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT tinyblob_lt($1::tinyblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.text_le_tinyblob(arg1 text, arg2 tinyblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT tinyblob_le($1::tinyblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.test_gt_tinyblob(arg1 text, arg2 tinyblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT tinyblob_gt($1::tinyblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.test_ge_tinyblob(arg1 text, arg2 tinyblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT tinyblob_ge($1::tinyblob, $2) $$;
CREATE OPERATOR pg_catalog.=(leftarg = text, rightarg = tinyblob, procedure = text_eq_tinyblob, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = text, rightarg = tinyblob, procedure = text_ne_tinyblob, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = text, rightarg = tinyblob, procedure = text_lt_tinyblob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = text, rightarg = tinyblob, procedure = text_le_tinyblob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = text, rightarg = tinyblob, procedure = test_gt_tinyblob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = text, rightarg = tinyblob, procedure = test_ge_tinyblob, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR FAMILY pg_catalog.tinyblob_ops USING BTREE;
CREATE OPERATOR FAMILY pg_catalog.tinyblob_ops USING HASH;
CREATE OPERATOR CLASS pg_catalog.tinyblob_ops DEFAULT
   FOR TYPE tinyblob USING BTREE FAMILY pg_catalog.tinyblob_ops as
   OPERATOR 1 pg_catalog.<(tinyblob, tinyblob),
   OPERATOR 2 pg_catalog.<=(tinyblob, tinyblob),
   OPERATOR 3 pg_catalog.=(tinyblob, tinyblob),
   OPERATOR 4 pg_catalog.>=(tinyblob, tinyblob),
   OPERATOR 5 pg_catalog.>(tinyblob, tinyblob),
   FUNCTION 1 pg_catalog.tinyblob_cmp(tinyblob, tinyblob),
   FUNCTION 2 pg_catalog.bytea_sortsupport(internal);

CREATE OPERATOR CLASS pg_catalog.tinyblob_ops DEFAULT
   FOR TYPE tinyblob USING HASH FAMILY tinyblob_ops as
   OPERATOR 1 pg_catalog.=(tinyblob, tinyblob),
   FUNCTION 1 (tinyblob, tinyblob) pg_catalog.hashvarlena(internal);

-- about mediumblob operator family
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_eq(arg1 mediumblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_ne(arg1 mediumblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_lt(arg1 mediumblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_le(arg1 mediumblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_gt(arg1 mediumblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_ge(arg1 mediumblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_cmp(mediumblob, mediumblob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = mediumblob, rightarg = mediumblob, procedure = mediumblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = mediumblob, rightarg = mediumblob, procedure = mediumblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = mediumblob, rightarg = mediumblob, procedure = mediumblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = mediumblob, rightarg = mediumblob, procedure = mediumblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = mediumblob, rightarg = mediumblob, procedure = mediumblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = mediumblob, rightarg = mediumblob, procedure = mediumblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_eq_text(arg1 mediumblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT mediumblob_eq($1, $2::mediumblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_ne_text(arg1 mediumblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT mediumblob_ne($1, $2::mediumblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_lt_text(arg1 mediumblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT mediumblob_lt($1, $2::mediumblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_le_text(arg1 mediumblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT mediumblob_le($1, $2::mediumblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_gt_text(arg1 mediumblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT mediumblob_gt($1, $2::mediumblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_ge_text(arg1 mediumblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT mediumblob_ge($1, $2::mediumblob) $$;
CREATE OPERATOR pg_catalog.=(leftarg = mediumblob, rightarg = text, procedure = mediumblob_eq_text, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = mediumblob, rightarg = text, procedure = mediumblob_ne_text, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = mediumblob, rightarg = text, procedure = mediumblob_lt_text, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = mediumblob, rightarg = text, procedure = mediumblob_le_text, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = mediumblob, rightarg = text, procedure = mediumblob_gt_text, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = mediumblob, rightarg = text, procedure = mediumblob_ge_text, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.text_eq_mediumblob(arg1 text, arg2 mediumblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT mediumblob_eq($1::mediumblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.text_ne_mediumblob(arg1 text, arg2 mediumblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT mediumblob_ne($1::mediumblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.text_lt_mediumblob(arg1 text, arg2 mediumblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT mediumblob_lt($1::mediumblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.text_le_mediumblob(arg1 text, arg2 mediumblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT mediumblob_le($1::mediumblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.test_gt_mediumblob(arg1 text, arg2 mediumblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT mediumblob_gt($1::mediumblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.test_ge_mediumblob(arg1 text, arg2 mediumblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT mediumblob_ge($1::mediumblob, $2) $$;
CREATE OPERATOR pg_catalog.=(leftarg = text, rightarg = mediumblob, procedure = text_eq_mediumblob, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = text, rightarg = mediumblob, procedure = text_ne_mediumblob, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = text, rightarg = mediumblob, procedure = text_lt_mediumblob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = text, rightarg = mediumblob, procedure = text_le_mediumblob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = text, rightarg = mediumblob, procedure = test_gt_mediumblob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = text, rightarg = mediumblob, procedure = test_ge_mediumblob, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR FAMILY pg_catalog.mediumblob_ops USING BTREE;
CREATE OPERATOR FAMILY pg_catalog.mediumblob_ops USING HASH;
CREATE OPERATOR CLASS pg_catalog.mediumblob_ops DEFAULT
   FOR TYPE mediumblob USING BTREE FAMILY pg_catalog.mediumblob_ops as
   OPERATOR 1 pg_catalog.<(mediumblob, mediumblob),
   OPERATOR 2 pg_catalog.<=(mediumblob, mediumblob),
   OPERATOR 3 pg_catalog.=(mediumblob, mediumblob),
   OPERATOR 4 pg_catalog.>=(mediumblob, mediumblob),
   OPERATOR 5 pg_catalog.>(mediumblob, mediumblob),
   FUNCTION 1 pg_catalog.mediumblob_cmp(mediumblob, mediumblob),
   FUNCTION 2 pg_catalog.bytea_sortsupport(internal);

CREATE OPERATOR CLASS pg_catalog.mediumblob_ops DEFAULT
   FOR TYPE mediumblob USING HASH FAMILY mediumblob_ops as
   OPERATOR 1 pg_catalog.=(mediumblob, mediumblob),
   FUNCTION 1 (mediumblob, mediumblob) pg_catalog.hashvarlena(internal);

-- about longblob operator family
CREATE OR REPLACE FUNCTION pg_catalog.longblob_eq(arg1 longblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_ne(arg1 longblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_lt(arg1 longblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_le(arg1 longblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_gt(arg1 longblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_ge(arg1 longblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_cmp(longblob, longblob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = longblob, procedure = longblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = longblob, rightarg = longblob, procedure = longblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = longblob, rightarg = longblob, procedure = longblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = longblob, rightarg = longblob, procedure = longblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = longblob, rightarg = longblob, procedure = longblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = longblob, rightarg = longblob, procedure = longblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.longblob_eq_text(arg1 longblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT longblob_eq($1, $2::longblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.longblob_ne_text(arg1 longblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT longblob_ne($1, $2::longblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.longblob_lt_text(arg1 longblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT longblob_lt($1, $2::longblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.longblob_le_text(arg1 longblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT longblob_le($1, $2::longblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.longblob_gt_text(arg1 longblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT longblob_gt($1, $2::longblob) $$;
CREATE OR REPLACE FUNCTION pg_catalog.longblob_ge_text(arg1 longblob, arg2 text) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT longblob_ge($1, $2::longblob) $$;
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = text, procedure = longblob_eq_text, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = longblob, rightarg = text, procedure = longblob_ne_text, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = longblob, rightarg = text, procedure = longblob_lt_text, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = longblob, rightarg = text, procedure = longblob_le_text, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = longblob, rightarg = text, procedure = longblob_gt_text, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = longblob, rightarg = text, procedure = longblob_ge_text, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.text_eq_longblob(arg1 text, arg2 longblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT longblob_eq($1::longblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.text_ne_longblob(arg1 text, arg2 longblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT longblob_ne($1::longblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.text_lt_longblob(arg1 text, arg2 longblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT longblob_lt($1::longblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.text_le_longblob(arg1 text, arg2 longblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT longblob_le($1::longblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.test_gt_longblob(arg1 text, arg2 longblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT longblob_gt($1::longblob, $2) $$;
CREATE OR REPLACE FUNCTION pg_catalog.test_ge_longblob(arg1 text, arg2 longblob) RETURNS bool LANGUAGE SQL STRICT AS $$ SELECT longblob_ge($1::longblob, $2) $$;
CREATE OPERATOR pg_catalog.=(leftarg = text, rightarg = longblob, procedure = text_eq_longblob, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = text, rightarg = longblob, procedure = text_ne_longblob, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = text, rightarg = longblob, procedure = text_lt_longblob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = text, rightarg = longblob, procedure = text_le_longblob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = text, rightarg = longblob, procedure = test_gt_longblob, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = text, rightarg = longblob, procedure = test_ge_longblob, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OPERATOR FAMILY pg_catalog.longblob_ops USING BTREE;
CREATE OPERATOR FAMILY pg_catalog.longblob_ops USING HASH;
CREATE OPERATOR CLASS pg_catalog.longblob_ops DEFAULT
   FOR TYPE longblob USING BTREE FAMILY pg_catalog.longblob_ops as
   OPERATOR 1 pg_catalog.<(longblob, longblob),
   OPERATOR 2 pg_catalog.<=(longblob, longblob),
   OPERATOR 3 pg_catalog.=(longblob, longblob),
   OPERATOR 4 pg_catalog.>=(longblob, longblob),
   OPERATOR 5 pg_catalog.>(longblob, longblob),
   FUNCTION 1 pg_catalog.longblob_cmp(longblob, longblob),
   FUNCTION 2 pg_catalog.bytea_sortsupport(internal);

CREATE OPERATOR CLASS pg_catalog.longblob_ops DEFAULT
   FOR TYPE longblob USING HASH FAMILY longblob_ops as
   OPERATOR 1 pg_catalog.=(longblob, longblob),
   FUNCTION 1 (longblob, longblob) pg_catalog.hashvarlena(internal);

-- about tinyblob op othersBlob
-- tinyblob op blob
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_blob_eq(arg1 tinyblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_blob_ne(arg1 tinyblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_blob_lt(arg1 tinyblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_blob_le(arg1 tinyblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_blob_gt(arg1 tinyblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_blob_ge(arg1 tinyblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_blob_cmp(tinyblob, blob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = tinyblob, rightarg = blob, procedure = tinyblob_blob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = tinyblob, rightarg = blob, procedure = tinyblob_blob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = tinyblob, rightarg = blob, procedure = tinyblob_blob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = tinyblob, rightarg = blob, procedure = tinyblob_blob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = tinyblob, rightarg = blob, procedure = tinyblob_blob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = tinyblob, rightarg = blob, procedure = tinyblob_blob_ge, restrict = scalarltsel, join = scalarltjoinsel);
-- tinyblob op mediumblob
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_mediumblob_eq(arg1 tinyblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_mediumblob_ne(arg1 tinyblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_mediumblob_lt(arg1 tinyblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_mediumblob_le(arg1 tinyblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_mediumblob_gt(arg1 tinyblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_mediumblob_ge(arg1 tinyblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_mediumblob_cmp(tinyblob, mediumblob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = tinyblob, rightarg = mediumblob, procedure = tinyblob_mediumblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = tinyblob, rightarg = mediumblob, procedure = tinyblob_mediumblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = tinyblob, rightarg = mediumblob, procedure = tinyblob_mediumblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = tinyblob, rightarg = mediumblob, procedure = tinyblob_mediumblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = tinyblob, rightarg = mediumblob, procedure = tinyblob_mediumblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = tinyblob, rightarg = mediumblob, procedure = tinyblob_mediumblob_ge, restrict = scalarltsel, join = scalarltjoinsel);
-- tinyblob op longblob
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_longblob_eq(arg1 tinyblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_longblob_ne(arg1 tinyblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_longblob_lt(arg1 tinyblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_longblob_le(arg1 tinyblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_longblob_gt(arg1 tinyblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_longblob_ge(arg1 tinyblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_longblob_cmp(tinyblob, longblob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = tinyblob, rightarg = longblob, procedure = tinyblob_longblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = tinyblob, rightarg = longblob, procedure = tinyblob_longblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = tinyblob, rightarg = longblob, procedure = tinyblob_longblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = tinyblob, rightarg = longblob, procedure = tinyblob_longblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = tinyblob, rightarg = longblob, procedure = tinyblob_longblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = tinyblob, rightarg = longblob, procedure = tinyblob_longblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

-- about blob op othersBlob
-- blob op tinyblob
CREATE OR REPLACE FUNCTION pg_catalog.blob_tinyblob_eq(arg1 blob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.blob_tinyblob_ne(arg1 blob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.blob_tinyblob_lt(arg1 blob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.blob_tinyblob_le(arg1 blob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.blob_tinyblob_gt(arg1 blob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.blob_tinyblob_ge(arg1 blob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.blob_tinyblob_cmp(blob, tinyblob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = tinyblob, procedure = blob_tinyblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = tinyblob, procedure = blob_tinyblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = tinyblob, procedure = blob_tinyblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = tinyblob, procedure = blob_tinyblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = tinyblob, procedure = blob_tinyblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = tinyblob, procedure = blob_tinyblob_ge, restrict = scalarltsel, join = scalarltjoinsel);
--- blob op mediumblob
CREATE OR REPLACE FUNCTION pg_catalog.blob_mediumblob_eq(arg1 blob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.blob_mediumblob_ne(arg1 blob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.blob_mediumblob_lt(arg1 blob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.blob_mediumblob_le(arg1 blob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.blob_mediumblob_gt(arg1 blob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.blob_mediumblob_ge(arg1 blob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.blob_mediumblob_cmp(blob, mediumblob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = mediumblob, procedure = blob_mediumblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = mediumblob, procedure = blob_mediumblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = mediumblob, procedure = blob_mediumblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = mediumblob, procedure = blob_mediumblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = mediumblob, procedure = blob_mediumblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = mediumblob, procedure = blob_mediumblob_ge, restrict = scalarltsel, join = scalarltjoinsel);
-- blob op longblob
CREATE OR REPLACE FUNCTION pg_catalog.blob_longblob_eq(arg1 blob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.blob_longblob_ne(arg1 blob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.blob_longblob_lt(arg1 blob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.blob_longblob_le(arg1 blob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.blob_longblob_gt(arg1 blob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.blob_longblob_ge(arg1 blob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.blob_longblob_cmp(longblob, longblob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = longblob, procedure = blob_longblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = longblob, procedure = blob_longblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = longblob, procedure = blob_longblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = longblob, procedure = blob_longblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = longblob, procedure = blob_longblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = longblob, procedure = blob_longblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

-- about mediumblob op othersBlob
-- mediumblob op tinyblob
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_tinyblob_eq(arg1 mediumblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_tinyblob_ne(arg1 mediumblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_tinyblob_lt(arg1 mediumblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_tinyblob_le(arg1 mediumblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_tinyblob_gt(arg1 mediumblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_tinyblob_ge(arg1 mediumblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_tinyblob_cmp(mediumblob, tinyblob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = mediumblob, rightarg = tinyblob, procedure = mediumblob_tinyblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = mediumblob, rightarg = tinyblob, procedure = mediumblob_tinyblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = mediumblob, rightarg = tinyblob, procedure = mediumblob_tinyblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = mediumblob, rightarg = tinyblob, procedure = mediumblob_tinyblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = mediumblob, rightarg = tinyblob, procedure = mediumblob_tinyblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = mediumblob, rightarg = tinyblob, procedure = mediumblob_tinyblob_ge, restrict = scalarltsel, join = scalarltjoinsel);
-- mediumblob op blob
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_blob_eq(arg1 mediumblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_blob_ne(arg1 mediumblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_blob_lt(arg1 mediumblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_blob_le(arg1 mediumblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_blob_gt(arg1 mediumblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_blob_ge(arg1 mediumblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_blob_cmp(mediumblob, blob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = mediumblob, rightarg = blob, procedure = mediumblob_blob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = mediumblob, rightarg = blob, procedure = mediumblob_blob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = mediumblob, rightarg = blob, procedure = mediumblob_blob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = mediumblob, rightarg = blob, procedure = mediumblob_blob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = mediumblob, rightarg = blob, procedure = mediumblob_blob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = mediumblob, rightarg = blob, procedure = mediumblob_blob_ge, restrict = scalarltsel, join = scalarltjoinsel);
-- mediumblob op longblob
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_longblob_eq(arg1 mediumblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_longblob_ne(arg1 mediumblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_longblob_lt(arg1 mediumblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_longblob_le(arg1 mediumblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_longblob_gt(arg1 mediumblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_longblob_ge(arg1 mediumblob, arg2 longblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_longblob_cmp(longblob, longblob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = mediumblob, rightarg = longblob, procedure = mediumblob_longblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = mediumblob, rightarg = longblob, procedure = mediumblob_longblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = mediumblob, rightarg = longblob, procedure = mediumblob_longblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = mediumblob, rightarg = longblob, procedure = mediumblob_longblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = mediumblob, rightarg = longblob, procedure = mediumblob_longblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = mediumblob, rightarg = longblob, procedure = mediumblob_longblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

-- about mediumblob op othersBlob
-- longblob op tinyblob
CREATE OR REPLACE FUNCTION pg_catalog.longblob_tinyblob_eq(arg1 longblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_tinyblob_ne(arg1 longblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_tinyblob_lt(arg1 longblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_tinyblob_le(arg1 longblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_tinyblob_gt(arg1 longblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_tinyblob_ge(arg1 longblob, arg2 tinyblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_tinyblob_cmp(longblob, tinyblob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = tinyblob, procedure = longblob_tinyblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = longblob, rightarg = tinyblob, procedure = longblob_tinyblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = longblob, rightarg = tinyblob, procedure = longblob_tinyblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = longblob, rightarg = tinyblob, procedure = longblob_tinyblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = longblob, rightarg = tinyblob, procedure = longblob_tinyblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = longblob, rightarg = tinyblob, procedure = longblob_tinyblob_ge, restrict = scalarltsel, join = scalarltjoinsel);
-- longblob op blob
CREATE OR REPLACE FUNCTION pg_catalog.longblob_blob_eq(arg1 longblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_blob_ne(arg1 longblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_blob_lt(arg1 longblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_blob_le(arg1 longblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_blob_gt(arg1 longblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_blob_ge(arg1 longblob, arg2 blob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_blob_cmp(longblob, blob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = blob, procedure = longblob_blob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = longblob, rightarg = blob, procedure = longblob_blob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = longblob, rightarg = blob, procedure = longblob_blob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = longblob, rightarg = blob, procedure = longblob_blob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = longblob, rightarg = blob, procedure = longblob_blob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = longblob, rightarg = blob, procedure = longblob_blob_ge, restrict = scalarltsel, join = scalarltjoinsel);
-- longblobg op mediumblob
CREATE OR REPLACE FUNCTION pg_catalog.longblob_mediumblob_eq(arg1 longblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteaeq';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_mediumblob_ne(arg1 longblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteane';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_mediumblob_lt(arg1 longblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'bytealt';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_mediumblob_le(arg1 longblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteale';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_mediumblob_gt(arg1 longblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteagt';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_mediumblob_ge(arg1 longblob, arg2 mediumblob) RETURNS bool LANGUAGE INTERNAL STRICT AS 'byteage';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_mediumblob_cmp(longblob, longblob) RETURNS integer LANGUAGE INTERNAL IMMUTABLE STRICT as 'byteacmp';
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = mediumblob, procedure = longblob_mediumblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = longblob, rightarg = mediumblob, procedure = longblob_mediumblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = longblob, rightarg = mediumblob, procedure = longblob_mediumblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = longblob, rightarg = mediumblob, procedure = longblob_mediumblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = longblob, rightarg = mediumblob, procedure = longblob_mediumblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = longblob, rightarg = mediumblob, procedure = longblob_mediumblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

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.exp(year);
DROP FUNCTION IF EXISTS pg_catalog.exp(json);
CREATE OR REPLACE FUNCTION pg_catalog.degrees(boolean) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.degrees(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.degrees(year) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.degrees(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.degrees(json) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.degrees(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.acos(boolean) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.acos(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.acos(year) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.acos(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.acos(json) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.acos(cast($1 as double precision))';

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);

CREATE FUNCTION pg_catalog.convert(boolean,name) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.convert(cast($1 as TEXT), $2)';
CREATE FUNCTION pg_catalog.convert(longblob,name) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.convert(cast($1 as TEXT), $2)';
CREATE FUNCTION pg_catalog.convert(anyenum,name) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.convert(cast($1 as TEXT), $2)';
CREATE FUNCTION pg_catalog.convert(json,name) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.convert(cast($1 as TEXT), $2)';

DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(bit) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(tinyblob) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(nvarchar2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(year) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(json) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa (bit) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa (binary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa (tinyblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa (nvarchar2) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as varchar))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa (year) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa (json) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';

CREATE OR REPLACE FUNCTION pg_catalog.exp(year) RETURNS numeric LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.exp(cast($1 as numeric))';
CREATE OR REPLACE FUNCTION pg_catalog.exp(json) RETURNS numeric LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.exp(cast($1 as numeric))';

CREATE OR REPLACE FUNCTION pg_catalog.int8_cast_date(int1)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_cast_date';
CREATE OR REPLACE FUNCTION pg_catalog.int16_cast_date(int2)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_cast_date';
CREATE OR REPLACE FUNCTION pg_catalog.int32_cast_date(int4)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int32_cast_date';
CREATE OR REPLACE FUNCTION pg_catalog.int64_cast_date(int8)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_cast_date';

CREATE OR REPLACE FUNCTION pg_catalog.uint8_cast_date(uint1)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint8_cast_date';
CREATE OR REPLACE FUNCTION pg_catalog.uint16_cast_date(uint2)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint16_cast_date';
CREATE OR REPLACE FUNCTION pg_catalog.uint32_cast_date(uint4)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint32_cast_date';
CREATE OR REPLACE FUNCTION pg_catalog.uint64_cast_date(uint8)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint64_cast_date';

CREATE OR REPLACE FUNCTION pg_catalog.float4_cast_date(float4)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float4_cast_date';
CREATE OR REPLACE FUNCTION pg_catalog.float8_cast_date(float8)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float8_cast_date';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_cast_date(numeric)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_cast_date';
CREATE OR REPLACE FUNCTION pg_catalog.text_date_explicit(TEXT)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'text_date_explicit';

CREATE OR REPLACE FUNCTION pg_catalog.int8_cast_datetime(int1)
RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_cast_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.int16_cast_datetime(int2)
RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_cast_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.int32_cast_datetime(int4)
RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int32_cast_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.int64_cast_datetime(int8)
RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_cast_datetime';

CREATE OR REPLACE FUNCTION pg_catalog.uint8_cast_datetime(uint1)
RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint8_cast_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.uint16_cast_datetime(uint2)
RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint16_cast_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.uint32_cast_datetime(uint4)
RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint32_cast_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.uint64_cast_datetime(uint8)
RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint64_cast_datetime';

CREATE OR REPLACE FUNCTION pg_catalog.float4_cast_datetime(float4)
RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float4_cast_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.float8_cast_datetime(float8)
RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float8_cast_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_cast_datetime(numeric)
RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_cast_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_explicit(TEXT)
RETURNS timestamp without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamp_explicit';

CREATE OR REPLACE FUNCTION pg_catalog.int8_cast_timestamptz(int1)
RETURNS timestamp with time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int8_cast_timestamptz';
CREATE OR REPLACE FUNCTION pg_catalog.int16_cast_timestamptz(int2)
RETURNS timestamp with time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int16_cast_timestamptz';
CREATE OR REPLACE FUNCTION pg_catalog.int32_cast_timestamptz(int4)
RETURNS timestamp with time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int32_cast_timestamptz';
CREATE OR REPLACE FUNCTION pg_catalog.int64_cast_timestamptz(int8)
RETURNS timestamp with time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'int64_cast_timestamptz';

CREATE OR REPLACE FUNCTION pg_catalog.uint8_cast_timestamptz(uint1)
RETURNS timestamp with time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint8_cast_timestamptz';
CREATE OR REPLACE FUNCTION pg_catalog.uint16_cast_timestamptz(uint2)
RETURNS timestamp with time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint16_cast_timestamptz';
CREATE OR REPLACE FUNCTION pg_catalog.uint32_cast_timestamptz(uint4)
RETURNS timestamp with time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint32_cast_timestamptz';
CREATE OR REPLACE FUNCTION pg_catalog.uint64_cast_timestamptz(uint8)
RETURNS timestamp with time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'uint64_cast_timestamptz';

CREATE OR REPLACE FUNCTION pg_catalog.float4_cast_timestamptz(float4)
RETURNS timestamp with time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float4_cast_timestamptz';
CREATE OR REPLACE FUNCTION pg_catalog.float8_cast_timestamptz(float8)
RETURNS timestamp with time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'float8_cast_timestamptz';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_cast_timestamptz(numeric)
RETURNS timestamp with time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'numeric_cast_timestamptz';
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_explicit(TEXT)
RETURNS timestamp with time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptz_explicit';

CREATE CAST(TEXT AS timestamp with time zone) WITH FUNCTION pg_catalog.timestamptz_explicit(TEXT) AS ASSIGNMENT;

--reset pg_cast content, change the castfunc in code(find_coercion_pathway)
do $$
begin
update pg_catalog.pg_cast set castfunc = 401, castowner = 10 where castsource = 1042 and casttarget = 25;
update pg_catalog.pg_cast set castfunc = 401, castowner = 10 where castsource = 1042 and casttarget = 1043;
update pg_catalog.pg_cast set castfunc = 401, castowner = 10 where castsource = 1042 and casttarget = 3969;
end
$$;

drop function pg_catalog.year_recv(bytea);
CREATE OR REPLACE FUNCTION pg_catalog.year_recv (internal) RETURNS year LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'year_recv';
do $$
begin
update pg_catalog.pg_type set typreceive = 'year_recv'::regproc, typsend = 'year_send'::regproc where oid = 'year'::regtype;
end
$$;

DROP FUNCTION IF EXISTS pg_catalog.ln(year);
CREATE OR REPLACE FUNCTION pg_catalog.ln(year) 
RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as
'select pg_catalog.ln(cast($1 as double precision))';

DROP FUNCTION IF EXISTS pg_catalog.ln(json);
CREATE OR REPLACE FUNCTION pg_catalog.ln(json) 
RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as
'select pg_catalog.ln(cast($1 as double precision))';

DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_int1(anyelement) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_int1 (
anyelement
) RETURNS int1 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena_cast_int1';

DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_int2(anyelement) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_int2 (
anyelement
) RETURNS int2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena_cast_int2';

DROP FUNCTION IF EXISTS pg_catalog.varlena_cast_int4(anyelement) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.varlena_cast_int4 (
anyelement
) RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varlena_cast_int4';

CREATE OR REPLACE FUNCTION pg_catalog.str_to_date(boolean, TEXT) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.str_to_date(cast($1 as TEXT), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.str_to_date(longblob, TEXT) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.str_to_date(cast($1 as TEXT), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.str_to_date(anyenum, TEXT) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.str_to_date(cast($1 as TEXT), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.str_to_date(json, TEXT) RETURNS TEXT LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.str_to_date(cast($1 as TEXT), $2)';

DROP FUNCTION IF EXISTS pg_catalog.floor(year);
CREATE OR REPLACE FUNCTION pg_catalog.floor(year) 
RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as
'select pg_catalog.floor(cast($1 as double precision))';

DROP FUNCTION IF EXISTS pg_catalog.floor(json);
CREATE OR REPLACE FUNCTION pg_catalog.floor(json) 
RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as
'select pg_catalog.floor(cast($1 as double precision))';

CREATE OR REPLACE FUNCTION pg_catalog.log(anyelement,anyelement) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log(cast($1 as number), cast($2 as number))';

DROP FUNCTION IF EXISTS pg_catalog.log(year);
DROP FUNCTION IF EXISTS pg_catalog.log(json);
CREATE OR REPLACE FUNCTION pg_catalog.log(year) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log(json) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log(uint1) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log(uint2) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log(uint4) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log(uint8) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log(bit) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log(boolean) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log(text) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log(char) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log(varchar) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log(cast($1 as double precision))';

CREATE OR REPLACE FUNCTION pg_catalog.log2(uint1) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log2(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log2(uint2) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log2(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log2(uint4) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log2(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log2(uint8) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log2(cast($1 as double precision))';
DROP FUNCTION IF EXISTS pg_catalog.log2(numeric);
CREATE OR REPLACE FUNCTION pg_catalog.log2(numeric) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log2(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log2(bit) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log2(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log2(boolean) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log2(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log2(text) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log2(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log2(char) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log2(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log2(varchar) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log2(cast($1 as double precision))';

CREATE OR REPLACE FUNCTION pg_catalog.log10(uint1) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log10(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log10(uint2) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log10(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log10(uint4) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log10(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log10(uint8) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log10(cast($1 as double precision))';
DROP FUNCTION IF EXISTS pg_catalog.log10(numeric);
CREATE OR REPLACE FUNCTION pg_catalog.log10(numeric) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log10(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log10(bit) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log10(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log10(boolean) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log10(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log10(text) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log10(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log10(char) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log10(cast($1 as double precision))';
CREATE OR REPLACE FUNCTION pg_catalog.log10(varchar) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.log10(cast($1 as double precision))';

CREATE OR REPLACE FUNCTION pg_catalog.substr(arg1 longblob, start int, the_end int) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.substrb(arg1::text, start, the_end)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.substr(arg1 longblob, start int) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.substrb(arg1::text, start)::longblob';

CREATE CAST (tinyblob AS binary) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (tinyblob AS varbinary) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (blob AS binary) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (blob AS varbinary) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (mediumblob AS binary) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (mediumblob AS varbinary) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (longblob AS binary) WITHOUT FUNCTION AS IMPLICIT;
CREATE CAST (longblob AS varbinary) WITHOUT FUNCTION AS IMPLICIT;

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;
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa (blob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa (mediumblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa (longblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';

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 longblob LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'hex_decode_text';
CREATE OR REPLACE FUNCTION pg_catalog.unhex (boolean)  RETURNS longblob LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'hex_decode_bool';
CREATE OR REPLACE FUNCTION pg_catalog.unhex (bytea)  RETURNS longblob LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'hex_decode_bytea';
CREATE OR REPLACE FUNCTION pg_catalog.unhex (bit)  RETURNS longblob LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'hex_decode_bit';

-- repeat function support
CREATE OR REPLACE FUNCTION pg_catalog.repeat(anyenum, integer) RETURNS text LANGUAGE SQL STRICT IMMUTABLE AS 'select repeat($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.repeat(boolean, integer) RETURNS text LANGUAGE SQL STRICT IMMUTABLE AS 'select repeat($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.repeat(tinyblob, integer) RETURNS longblob LANGUAGE SQL STRICT IMMUTABLE AS 'select repeat($1::text, $2)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.repeat(blob, integer) RETURNS longblob LANGUAGE SQL STRICT IMMUTABLE AS 'select repeat($1::text, $2)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.repeat(mediumblob, integer) RETURNS longblob LANGUAGE SQL STRICT IMMUTABLE AS 'select repeat($1::text, $2)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.repeat(longblob, integer) RETURNS longblob LANGUAGE SQL STRICT IMMUTABLE AS 'select repeat($1::text, $2)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.repeat(json, integer) RETURNS text LANGUAGE SQL STRICT IMMUTABLE AS 'select repeat($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.repeat(year, integer) RETURNS text LANGUAGE SQL STRICT IMMUTABLE AS 'select repeat($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.repeat(binary, integer) RETURNS bytea LANGUAGE C STRICT IMMUTABLE AS '$libdir/dolphin', 'repeat_binary';
CREATE OR REPLACE FUNCTION pg_catalog.repeat(bit, integer) RETURNS bytea LANGUAGE C STRICT IMMUTABLE AS '$libdir/dolphin', 'repeat_bit';

DROP CAST IF EXISTS ("binary" AS boolean) CASCADE;
DROP CAST IF EXISTS ("varbinary" AS boolean) CASCADE;
DROP CAST IF EXISTS (blob AS boolean) CASCADE;
DROP CAST IF EXISTS (tinyblob AS boolean) CASCADE;
DROP CAST IF EXISTS (mediumblob AS boolean) CASCADE;
DROP CAST IF EXISTS (longblob AS boolean) CASCADE;
DROP CAST IF EXISTS (anyset AS boolean) CASCADE;
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;
CREATE OR REPLACE FUNCTION pg_catalog.any2boolean(anyelement) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as text) as boolean)';
CREATE OR REPLACE FUNCTION pg_catalog.enum_boolean(anyenum) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int) as boolean)';
CREATE OR REPLACE FUNCTION pg_catalog.set_boolean(anyset) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int) as boolean)';
CREATE OR REPLACE FUNCTION pg_catalog.binary2boolean(binary) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT as 'select char_bool($1::char)';
CREATE OR REPLACE FUNCTION pg_catalog.varbinary2boolean(varbinary) RETURNS boolean LANGUAGE SQL IMMUTABLE STRICT as 'select varchar_bool($1::varchar)';
CREATE CAST ("binary" AS boolean) WITH FUNCTION pg_catalog.binary2boolean(binary) AS ASSIGNMENT;
CREATE CAST ("varbinary" AS boolean) WITH FUNCTION pg_catalog.varbinary2boolean(varbinary) AS ASSIGNMENT;
CREATE CAST (blob AS boolean) WITH FUNCTION pg_catalog.any2boolean(anyelement) AS ASSIGNMENT;
CREATE CAST (tinyblob AS boolean) WITH FUNCTION pg_catalog.any2boolean(anyelement) AS ASSIGNMENT;
CREATE CAST (mediumblob AS boolean) WITH FUNCTION pg_catalog.any2boolean(anyelement) AS ASSIGNMENT;
CREATE CAST (longblob AS boolean) WITH FUNCTION pg_catalog.any2boolean(anyelement) AS ASSIGNMENT;
CREATE CAST (anyset AS boolean) WITH FUNCTION pg_catalog.set_boolean(anyset) AS ASSIGNMENT;

-- nvarchar2
DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_cast_ui1(nvarchar2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.nvarchar2_cast_ui1 (
nvarchar2
) RETURNS uint1 LANGUAGE SQL IMMUTABLE STRICT as
'select cast(cast($1 as float8) as uint1)';

DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_cast_ui2(nvarchar2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.nvarchar2_cast_ui2 (
nvarchar2
) RETURNS uint2 LANGUAGE SQL IMMUTABLE STRICT as
'select cast(cast($1 as float8) as uint2)';

DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_cast_ui4(nvarchar2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.nvarchar2_cast_ui4 (
nvarchar2
) RETURNS uint4 LANGUAGE SQL IMMUTABLE STRICT as
'select cast(cast($1 as float8) as uint4)';

DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_cast_ui8(nvarchar2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.nvarchar2_cast_ui8 (
nvarchar2
) RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as
'select cast(cast($1 as float8) as uint8)';

DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_enum(nvarchar2, int4, anyelement) cascade;
CREATE OR REPLACE FUNCTION pg_catalog.nvarchar2_enum(
nvarchar2, int4, anyelement
) RETURNS anyenum LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'nvarchar2_enum';

DROP FUNCTION IF EXISTS pg_catalog.nvarchar2_cast_int8(nvarchar2) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.nvarchar2_cast_int8 (
nvarchar2
) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'nvarchar2_cast_int8';
DROP FUNCTION IF EXISTS pg_catalog.boolean_time(boolean) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.boolean_date(boolean) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.boolean_datetime(boolean) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.boolean_timestamptz(boolean) CASCADE;
DROP CAST IF EXISTS (boolean as time without time zone) CASCADE;
DROP CAST IF EXISTS (boolean as date) CASCADE;
DROP CAST IF EXISTS (boolean as timestamp without time zone) CASCADE;
DROP CAST IF EXISTS (boolean as timestamptz) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.boolean_time(boolean) RETURNS time without time zone
LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int) as time without time zone)';
CREATE OR REPLACE FUNCTION pg_catalog.boolean_date(boolean) RETURNS date
LANGUAGE C STRICT IMMUTABLE AS '$libdir/dolphin', 'bool_b_format_date';
CREATE OR REPLACE FUNCTION pg_catalog.boolean_datetime(boolean) RETURNS timestamp without time zone
LANGUAGE C STRICT IMMUTABLE AS '$libdir/dolphin', 'bool_b_format_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.boolean_timestamptz(boolean) RETURNS timestamptz
LANGUAGE C STRICT IMMUTABLE AS '$libdir/dolphin', 'bool_b_format_timestamp';
CREATE CAST (boolean as time without time zone) WITH FUNCTION pg_catalog.boolean_time(boolean) AS ASSIGNMENT;
CREATE CAST (boolean as date) WITH FUNCTION pg_catalog.boolean_date(boolean) AS ASSIGNMENT;
CREATE CAST (boolean as timestamp without time zone) WITH FUNCTION pg_catalog.boolean_datetime(boolean) AS ASSIGNMENT;
CREATE CAST (boolean as timestamptz) WITH FUNCTION pg_catalog.boolean_timestamptz(boolean) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.bool_cast_time(boolean) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bool_cast_date(boolean) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bool_cast_datetime(boolean) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.bool_cast_timestamptz(boolean) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.bool_cast_time(boolean)
RETURNS time without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bool_cast_time';
CREATE OR REPLACE FUNCTION pg_catalog.bool_cast_date(boolean)
RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bool_cast_date';
CREATE OR REPLACE FUNCTION pg_catalog.bool_cast_datetime(boolean)
RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bool_cast_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.bool_cast_timestamptz(boolean)
RETURNS timestamp with time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'bool_cast_timestamptz';

CREATE OR REPLACE FUNCTION pg_catalog.ascii(blob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.ascii(cast($1 as TEXT))';
CREATE OR REPLACE FUNCTION pg_catalog.ascii(year) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.ascii(cast($1 as TEXT))';
CREATE OR REPLACE FUNCTION pg_catalog.ascii(json) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.ascii(cast($1 as TEXT))';
CREATE OR REPLACE FUNCTION pg_catalog.ascii(boolean) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.ascii(cast($1 as integer))';
CREATE OR REPLACE FUNCTION pg_catalog.ascii(anyenum) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.ascii(cast($1 as TEXT))';
CREATE OR REPLACE FUNCTION pg_catalog.ascii(bit) RETURNS integer LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bit_to_ascii';

CREATE OR REPLACE FUNCTION pg_catalog.bit_length(boolean) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.bit_length(cast($1 as TEXT))';
CREATE OR REPLACE FUNCTION pg_catalog.bit_length(year) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.bit_length(cast($1 as TEXT))';
CREATE OR REPLACE FUNCTION pg_catalog.bit_length(blob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.bit_length(cast($1 as TEXT))';
CREATE OR REPLACE FUNCTION pg_catalog.bit_length(anyenum) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.bit_length(cast($1 as TEXT))';
CREATE OR REPLACE FUNCTION pg_catalog.bit_length(json) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.bit_length(cast($1 as TEXT))';
CREATE OR REPLACE FUNCTION pg_catalog.bit_length(binary) RETURNS integer LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'mp_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;
CREATE OR REPLACE FUNCTION pg_catalog.uint4_year(uint4) RETURNS year LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST(uint4 AS year) WITH FUNCTION uint4_year(uint4) AS ASSIGNMENT;
CREATE OR REPLACE FUNCTION pg_catalog.boolean_year(boolean) RETURNS year LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST(boolean AS year) WITH FUNCTION boolean_year(boolean) AS ASSIGNMENT;
CREATE OR REPLACE FUNCTION pg_catalog.char_year(char) RETURNS year LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST(char AS year) WITH FUNCTION char_year(char) AS ASSIGNMENT;
CREATE OR REPLACE FUNCTION pg_catalog.varchar_year(varchar) RETURNS year LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST(varchar AS year) WITH FUNCTION varchar_year(varchar) AS ASSIGNMENT;
CREATE OR REPLACE FUNCTION pg_catalog.text_year (text) RETURNS year LANGUAGE SQL IMMUTABLE STRICT as 'select cast(cast($1 as int8) as year)';
CREATE CAST(text AS year) WITH FUNCTION text_year(text) AS ASSIGNMENT;

create or replace function pg_catalog.varbinarylike(varbinary, varbinary) returns bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'binarylike';
CREATE OPERATOR pg_catalog.~~(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinarylike);

create or replace function pg_catalog.varbinarytextlike(varbinary, text) returns bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'binarylike';
CREATE OPERATOR pg_catalog.~~(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinarytextlike);
CREATE OPERATOR pg_catalog.~~*(leftarg = varbinary, rightarg = text, procedure = pg_catalog.varbinarytextlike);

create or replace function pg_catalog.textvarbinarylike(text, varbinary) returns bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'binarylike';
CREATE OPERATOR pg_catalog.~~(leftarg = text, rightarg = varbinary, procedure = pg_catalog.textvarbinarylike);
CREATE OPERATOR pg_catalog.~~*(leftarg = text, rightarg = varbinary, procedure = pg_catalog.textvarbinarylike);

create or replace function pg_catalog.bloblike(blob, blob) returns bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'binarylike';
CREATE OPERATOR pg_catalog.~~(leftarg = blob, rightarg = blob, procedure = pg_catalog.bloblike);
CREATE OPERATOR pg_catalog.~~*(leftarg = blob, rightarg = blob, procedure = pg_catalog.bloblike);

create or replace function pg_catalog.binarylike(binary, binary) returns bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'binarylike';
create or replace function pg_catalog.binarytextlike(binary, text) returns bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'binarylike';
create or replace function pg_catalog.textbinarylike(text, binary) returns bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'binarylike';

create or replace function pg_catalog.boolean_binary_eq(boolean, binary) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int = $2::float)';
CREATE OPERATOR pg_catalog.=(leftarg = boolean, rightarg = binary, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.boolean_binary_eq, restrict = eqsel, join = eqjoinsel);
create or replace function pg_catalog.binary_boolean_eq(binary, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float = $2::int)';
CREATE OPERATOR pg_catalog.=(leftarg = binary, rightarg = boolean, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.binary_boolean_eq, restrict = eqsel, join = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_binary_ne(boolean, binary) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int != $2::float)';
CREATE OPERATOR pg_catalog.<>(leftarg = boolean, rightarg = binary, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.boolean_binary_ne,restrict = neqsel, join = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_boolean_ne(binary, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float != $2::int)';
CREATE OPERATOR pg_catalog.<>(leftarg = binary, rightarg = boolean, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.binary_boolean_ne,restrict = neqsel, join = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_binary_gt(boolean, binary) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int > $2::float)';
CREATE OPERATOR pg_catalog.>(leftarg = boolean, rightarg = binary, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.boolean_binary_gt,restrict = scalargtsel, join = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_boolean_gt(binary, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float > $2::int)';
CREATE OPERATOR pg_catalog.>(leftarg = binary, rightarg = boolean, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.binary_boolean_gt,restrict = scalargtsel, join = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_binary_lt(boolean, binary) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int < $2::float)';
CREATE OPERATOR pg_catalog.<(leftarg = boolean, rightarg = binary, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.boolean_binary_lt,restrict = scalarltsel, join = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_boolean_lt(binary, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float < $2::int)';
CREATE OPERATOR pg_catalog.<(leftarg = binary, rightarg = boolean, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.binary_boolean_lt,restrict = scalarltsel, join = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_binary_ge(boolean, binary) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int >= $2::float)';
CREATE OPERATOR pg_catalog.>=(leftarg = boolean, rightarg = binary, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.boolean_binary_ge,restrict = scalargtsel, join = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_boolean_ge(binary, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float >= $2::int)';
CREATE OPERATOR pg_catalog.>=(leftarg = binary, rightarg = boolean, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.binary_boolean_ge,restrict = scalargtsel, join = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_binary_le(boolean, binary) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int <= $2::float)';
CREATE OPERATOR pg_catalog.<=(leftarg = boolean, rightarg = binary, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.boolean_binary_le,restrict = scalarltsel, join = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_boolean_le(binary, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float <= $2::int)';
CREATE OPERATOR pg_catalog.<=(leftarg = binary, rightarg = boolean, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.binary_boolean_le,restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.boolean_tinyblob_eq(boolean, tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = boolean, RIGHTARG = tinyblob, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.boolean_tinyblob_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_boolean_eq(tinyblob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = tinyblob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.tinyblob_boolean_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_tinyblob_ne(boolean, tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = boolean, RIGHTARG = tinyblob, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.boolean_tinyblob_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_boolean_ne(tinyblob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = tinyblob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.tinyblob_boolean_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_tinyblob_gt(boolean, tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = boolean, RIGHTARG = tinyblob, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.boolean_tinyblob_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_boolean_gt(tinyblob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = tinyblob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.tinyblob_boolean_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_tinyblob_lt(boolean, tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = boolean, RIGHTARG = tinyblob, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.boolean_tinyblob_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_boolean_lt(tinyblob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = tinyblob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.tinyblob_boolean_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_tinyblob_ge(boolean, tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = boolean, RIGHTARG = tinyblob, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.boolean_tinyblob_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_boolean_ge(tinyblob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = tinyblob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.tinyblob_boolean_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_tinyblob_le(boolean, tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = boolean, RIGHTARG = tinyblob, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.boolean_tinyblob_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_boolean_le(tinyblob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = tinyblob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.tinyblob_boolean_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.boolean_mediumblob_eq(boolean, mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = boolean, RIGHTARG = mediumblob, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.boolean_mediumblob_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_boolean_eq(mediumblob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = mediumblob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.mediumblob_boolean_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_mediumblob_ne(boolean, mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = boolean, RIGHTARG = mediumblob, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.boolean_mediumblob_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_boolean_ne(mediumblob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = mediumblob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.mediumblob_boolean_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_mediumblob_gt(boolean, mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = boolean, RIGHTARG = mediumblob, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.boolean_mediumblob_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_boolean_gt(mediumblob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = mediumblob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.mediumblob_boolean_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_mediumblob_lt(boolean, mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = boolean, RIGHTARG = mediumblob, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.boolean_mediumblob_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_boolean_lt(mediumblob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = mediumblob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.mediumblob_boolean_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_mediumblob_ge(boolean, mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = boolean, RIGHTARG = mediumblob, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.boolean_mediumblob_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_boolean_ge(mediumblob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = mediumblob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.mediumblob_boolean_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_mediumblob_le(boolean, mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = boolean, RIGHTARG = mediumblob, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.boolean_mediumblob_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_boolean_le(mediumblob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = mediumblob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.mediumblob_boolean_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.boolean_blob_eq(boolean, blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = boolean, RIGHTARG = blob, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.boolean_blob_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.blob_boolean_eq(blob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = blob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.blob_boolean_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_blob_ne(boolean, blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = boolean, RIGHTARG = blob, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.boolean_blob_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.blob_boolean_ne(blob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = blob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.blob_boolean_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_blob_gt(boolean, blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = boolean, RIGHTARG = blob, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.boolean_blob_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.blob_boolean_gt(blob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = blob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.blob_boolean_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_blob_lt(boolean, blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = boolean, RIGHTARG = blob, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.boolean_blob_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.blob_boolean_lt(blob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = blob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.blob_boolean_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_blob_ge(boolean, blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = boolean, RIGHTARG = blob, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.boolean_blob_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.blob_boolean_ge(blob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = blob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.blob_boolean_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_blob_le(boolean, blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = boolean, RIGHTARG = blob, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.boolean_blob_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.blob_boolean_le(blob, boolean) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = blob, RIGHTARG = boolean, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.blob_boolean_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.boolean_longblob_eq(boolean, longblob) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(leftarg = boolean, rightarg = longblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.boolean_longblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.longblob_boolean_eq(longblob, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = boolean, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.longblob_boolean_eq, restrict = eqsel, join = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_longblob_ne(boolean, longblob) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(leftarg = boolean, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.boolean_longblob_ne,restrict = neqsel, join = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.longblob_boolean_ne(longblob, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(leftarg = longblob, rightarg = boolean, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.longblob_boolean_ne,restrict = neqsel, join = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_longblob_gt(boolean, longblob) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(leftarg = boolean, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.boolean_longblob_gt,restrict = scalargtsel, join = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.longblob_boolean_gt(longblob, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(leftarg = longblob, rightarg = boolean, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.longblob_boolean_gt,restrict = scalargtsel, join = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_longblob_lt(boolean, longblob) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(leftarg = boolean, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.boolean_longblob_lt,restrict = scalarltsel, join = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.longblob_boolean_lt(longblob, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(leftarg = longblob, rightarg = boolean, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.longblob_boolean_lt,restrict = scalarltsel, join = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_longblob_ge(boolean, longblob) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(leftarg = boolean, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.boolean_longblob_ge,restrict = scalargtsel, join = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.longblob_boolean_ge(longblob, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(leftarg = longblob, rightarg = boolean, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.longblob_boolean_ge,restrict = scalargtsel, join = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.boolean_longblob_le(boolean, longblob) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(leftarg = boolean, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.boolean_longblob_le,restrict = scalarltsel, join = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.longblob_boolean_le(longblob, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(leftarg = longblob, rightarg = boolean, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.longblob_boolean_le,restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.year_binary_eq(year, binary) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::int = $2::float)';
CREATE OPERATOR pg_catalog.=(LEFTARG = year, RIGHTARG = binary, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.year_binary_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_year_eq(binary, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::float = $2::int)';
CREATE OPERATOR pg_catalog.=(LEFTARG = binary, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.binary_year_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_binary_ne(year, binary) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::int != $2::float)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = year, RIGHTARG = binary, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.year_binary_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_year_ne(binary, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::float != $2::int)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = binary, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.binary_year_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_binary_gt(year, binary) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::int > $2::float)';
CREATE OPERATOR pg_catalog.>(LEFTARG = year, RIGHTARG = binary, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.year_binary_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_year_gt(binary, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::float > $2::int)';
CREATE OPERATOR pg_catalog.>(LEFTARG = binary, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.binary_year_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_binary_lt(year, binary) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::int < $2::float)';
CREATE OPERATOR pg_catalog.<(LEFTARG = year, RIGHTARG = binary, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.year_binary_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_year_lt(binary, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::float < $2::int)';
CREATE OPERATOR pg_catalog.<(LEFTARG = binary, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.binary_year_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_binary_ge(year, binary) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::int >= $2::float)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = year, RIGHTARG = binary, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.year_binary_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_year_ge(binary, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::float >= $2::int)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = binary, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.binary_year_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_binary_le(year, binary) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::int <= $2::float)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = year, RIGHTARG = binary, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.year_binary_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_year_le(binary, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::float <= $2::int)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = binary, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.binary_year_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.year_tinyblob_eq(year, tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = year, RIGHTARG = tinyblob, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.year_tinyblob_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_year_eq(tinyblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = tinyblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.tinyblob_year_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_tinyblob_ne(year, tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = year, RIGHTARG = tinyblob, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.year_tinyblob_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_year_ne(tinyblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = tinyblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.tinyblob_year_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_tinyblob_gt(year, tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = year, RIGHTARG = tinyblob, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.year_tinyblob_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_year_gt(tinyblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = tinyblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.tinyblob_year_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_tinyblob_lt(year, tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = year, RIGHTARG = tinyblob, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.year_tinyblob_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_year_lt(tinyblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = tinyblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.tinyblob_year_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_tinyblob_ge(year, tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = year, RIGHTARG = tinyblob, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.year_tinyblob_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_year_ge(tinyblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = tinyblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.tinyblob_year_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_tinyblob_le(year, tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = year, RIGHTARG = tinyblob, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.year_tinyblob_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_year_le(tinyblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = tinyblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.tinyblob_year_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.year_mediumblob_eq(year, mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = year, RIGHTARG = mediumblob, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.year_mediumblob_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_year_eq(mediumblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = mediumblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.mediumblob_year_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_mediumblob_ne(year, mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = year, RIGHTARG = mediumblob, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.year_mediumblob_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_year_ne(mediumblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = mediumblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.mediumblob_year_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_mediumblob_gt(year, mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = year, RIGHTARG = mediumblob, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.year_mediumblob_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_year_gt(mediumblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = mediumblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.mediumblob_year_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_mediumblob_lt(year, mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = year, RIGHTARG = mediumblob, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.year_mediumblob_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_year_lt(mediumblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = mediumblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.mediumblob_year_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_mediumblob_ge(year, mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = year, RIGHTARG = mediumblob, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.year_mediumblob_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_year_ge(mediumblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = mediumblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.mediumblob_year_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_mediumblob_le(year, mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = year, RIGHTARG = mediumblob, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.year_mediumblob_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_year_le(mediumblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = mediumblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.mediumblob_year_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.year_blob_eq(year, blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = year, RIGHTARG = blob, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.year_blob_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.blob_year_eq(blob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = blob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.blob_year_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_blob_ne(year, blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = year, RIGHTARG = blob, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.year_blob_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.blob_year_ne(blob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = blob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.blob_year_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_blob_gt(year, blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = year, RIGHTARG = blob, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.year_blob_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.blob_year_gt(blob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = blob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.blob_year_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_blob_lt(year, blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = year, RIGHTARG = blob, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.year_blob_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.blob_year_lt(blob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = blob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.blob_year_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_blob_ge(year, blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = year, RIGHTARG = blob, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.year_blob_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.blob_year_ge(blob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = blob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.blob_year_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_blob_le(year, blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = year, RIGHTARG = blob, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.year_blob_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.blob_year_le(blob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = blob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.blob_year_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.year_longblob_eq(year, longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = year, RIGHTARG = longblob, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.year_longblob_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.longblob_year_eq(longblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text = $2::text)';
CREATE OPERATOR pg_catalog.=(LEFTARG = longblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.=), PROCEDURE = pg_catalog.longblob_year_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_longblob_ne(year, longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = year, RIGHTARG = longblob, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.year_longblob_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.longblob_year_ne(longblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text != $2::text)';
CREATE OPERATOR pg_catalog.<>(LEFTARG = longblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<>), PROCEDURE = pg_catalog.longblob_year_ne, RESTRICT = neqsel, JOIN = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_longblob_gt(year, longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = year, RIGHTARG = longblob, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.year_longblob_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.longblob_year_gt(longblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text > $2::text)';
CREATE OPERATOR pg_catalog.>(LEFTARG = longblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<), PROCEDURE = pg_catalog.longblob_year_gt, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_longblob_lt(year, longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = year, RIGHTARG = longblob, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.year_longblob_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.longblob_year_lt(longblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text < $2::text)';
CREATE OPERATOR pg_catalog.<(LEFTARG = longblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.>), PROCEDURE = pg_catalog.longblob_year_lt, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_longblob_ge(year, longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = year, RIGHTARG = longblob, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.year_longblob_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.longblob_year_ge(longblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text >= $2::text)';
CREATE OPERATOR pg_catalog.>=(LEFTARG = longblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.<=), PROCEDURE = pg_catalog.longblob_year_ge, RESTRICT = scalargtsel, JOIN = scalargtjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.year_longblob_le(year, longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = year, RIGHTARG = longblob, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.year_longblob_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.longblob_year_le(longblob, year) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1::text <= $2::text)';
CREATE OPERATOR pg_catalog.<=(LEFTARG = longblob, RIGHTARG = year, COMMUTATOR = OPERATOR(pg_catalog.>=), PROCEDURE = pg_catalog.longblob_year_le, RESTRICT = scalarltsel, JOIN = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.int1_binary_eq(int1, binary) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1 = $2::float)';
CREATE OPERATOR pg_catalog.=(leftarg = int1, rightarg = binary, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.int1_binary_eq, restrict = eqsel, join = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_int1_eq(binary, int1) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float = $2)';
CREATE OPERATOR pg_catalog.=(leftarg = binary, rightarg = int1, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.binary_int1_eq, restrict = eqsel, join = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.int1_binary_ne(int1, binary) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float != $2)';
CREATE OPERATOR pg_catalog.<>(leftarg = int1, rightarg = binary, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.int1_binary_ne,restrict = neqsel, join = neqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_int1_ne(binary, int1) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1 != $2::float)';
CREATE OPERATOR pg_catalog.<>(leftarg = binary, rightarg = int1, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.binary_int1_ne,restrict = neqsel, join = neqjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.text_binary_eq(text, binary) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::binary = $2)';
CREATE OPERATOR pg_catalog.=(leftarg = text, rightarg = binary, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.text_binary_eq, restrict = eqsel, join = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.binary_text_eq(binary, text) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1 = $2::binary)';
CREATE OPERATOR pg_catalog.=(leftarg = binary, rightarg = text, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.binary_text_eq, restrict = eqsel, join = eqjoinsel);

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 C IMMUTABLE STRICT as '$libdir/dolphin', 'timestamptz_year';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_year(timestamp(0) without time zone) RETURNS year LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'datetime_year';
CREATE OR REPLACE FUNCTION pg_catalog.date_year(date) RETURNS year LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'date_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);
CREATE OR REPLACE FUNCTION pg_catalog.float8_nvarchar2(FLOAT8) RETURNS NVARCHAR2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float8_nvarchar2';
CREATE CAST (FLOAT8 AS NVARCHAR2) WITH FUNCTION pg_catalog.float8_nvarchar2(FLOAT8) AS IMPLICIT;

DROP CAST IF EXISTS (FLOAT4 AS NVARCHAR2);
CREATE OR REPLACE FUNCTION pg_catalog.float4_nvarchar2(FLOAT4) RETURNS NVARCHAR2 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'float4_nvarchar2';
CREATE CAST (FLOAT4 AS NVARCHAR2) WITH FUNCTION pg_catalog.float4_nvarchar2(FLOAT4) 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 int8 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_contains';
CREATE OR REPLACE FUNCTION pg_catalog.json_contains("any", "any") RETURNS int8 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_contains';
CREATE OR REPLACE FUNCTION pg_catalog.json_valid("any") RETURNS int8 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 int8 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_length';
CREATE OR REPLACE FUNCTION pg_catalog.json_length("any",text) RETURNS int8 LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'json_length';
CREATE OR REPLACE FUNCTION pg_catalog.json_depth("any") RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_depth';
CREATE OR REPLACE FUNCTION pg_catalog.json_storage_size("any") RETURNS int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'json_storage_size';

DROP FUNCTION IF EXISTS pg_catalog.b_extract (text, year);
CREATE OR REPLACE FUNCTION pg_catalog.b_extract (text, year) RETURNS int8 LANGUAGE SQL STABLE STRICT as $$ SELECT pg_catalog.b_extract($1, $2::text) $$;
DROP FUNCTION IF EXISTS pg_catalog.yearweek (year);
CREATE OR REPLACE FUNCTION pg_catalog.yearweek (year) RETURNS int8 LANGUAGE SQL STABLE STRICT as $$ SELECT pg_catalog.yearweek($1::text) $$;
DROP FUNCTION IF EXISTS pg_catalog.makedate (year, int8);
CREATE OR REPLACE FUNCTION pg_catalog.makedate (year, int8) RETURNS date AS $$ SELECT pg_catalog.makedate(cast($1 as int8), cast($2 as int8)) $$ LANGUAGE SQL;
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);
CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,year,year) RETURNS int8 AS $$ SELECT pg_catalog.b_timestampdiff($1, $3::text, $2::text) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,text,year) RETURNS int8 AS $$ SELECT -pg_catalog.b_timestampdiff($1, $3::text, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.b_timestampdiff(text,year,text) RETURNS int8 AS $$ SELECT -pg_catalog.b_timestampdiff($1, $3, $2::text) $$ LANGUAGE SQL;
DROP FUNCTION IF EXISTS pg_catalog.date_add (year, interval);
CREATE OR REPLACE FUNCTION pg_catalog.date_add (year, interval) RETURNS text AS $$ SELECT pg_catalog.adddate($1::text, $2)  $$ LANGUAGE SQL;
DROP FUNCTION IF EXISTS pg_catalog.date_sub (year, interval);
CREATE OR REPLACE FUNCTION pg_catalog.date_sub (year, interval) RETURNS text AS $$ SELECT pg_catalog.adddate($1::text, -$2)  $$ LANGUAGE SQL;

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;

CREATE OR REPLACE FUNCTION pg_catalog.is_ipv4(bit) RETURNS int4 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.is_ipv4(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.is_ipv4(boolean) RETURNS int4 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.is_ipv4(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.is_ipv4(year) RETURNS int4 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.is_ipv4(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.is_ipv4(blob) RETURNS int4 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.is_ipv4(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.is_ipv4(anyenum) RETURNS int4 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.is_ipv4(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.is_ipv4(json) RETURNS int4 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.is_ipv4(cast($1 as text))';

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(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;

CREATE OR REPLACE FUNCTION pg_catalog.binaryand(binary, binary) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'binaryand';
CREATE OR REPLACE FUNCTION pg_catalog.varbinary_and_binary(varbinary, binary) RETURNS varbinary LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'varbinary_and_binary';
CREATE OR REPLACE FUNCTION pg_catalog.varbinaryand(varbinary, varbinary) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varbinaryand';
CREATE OR REPLACE FUNCTION pg_catalog.bloband(blob, blob) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bloband';
CREATE OR REPLACE FUNCTION pg_catalog.varbinary_and_tinyblob(varbinary, tinyblob) RETURNS varbinary LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'varbinary_and_tinyblob';
CREATE OR REPLACE FUNCTION pg_catalog.varbinary_and_blob(varbinary, blob) RETURNS varbinary LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'varbinary_and_blob';
CREATE OR REPLACE FUNCTION pg_catalog.varbinary_and_mediumblob(varbinary, mediumblob) RETURNS varbinary LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'varbinary_and_mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.varbinary_and_longblob(varbinary, longblob) RETURNS varbinary LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'varbinary_and_longblob';
CREATE OR REPLACE FUNCTION pg_catalog.text_and_uint8(uint8, text) RETURNS uint8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_and_uint8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8and(uint8, char) RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint8and($1, cast($2 as uint8))';
CREATE OR REPLACE FUNCTION pg_catalog.uint8and(uint8, varchar) RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint8and($1, cast($2 as uint8))';
CREATE OR REPLACE FUNCTION pg_catalog.uint8and(uint8, json) RETURNS uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint8and($1, cast($2 as uint8))';
CREATE OPERATOR pg_catalog.&(leftarg = binary, rightarg = binary, procedure = pg_catalog.binaryand);
CREATE OPERATOR pg_catalog.&(leftarg = blob, rightarg = blob, procedure = pg_catalog.bloband);
CREATE AGGREGATE pg_catalog.bit_and(char) (SFUNC = pg_catalog.uint8and, cFUNC = pg_catalog.uint8and, STYPE = uint8, initcond = '18446744073709551615');
CREATE AGGREGATE pg_catalog.bit_and(varchar) (SFUNC = pg_catalog.uint8and, cFUNC = pg_catalog.uint8and, STYPE = uint8, initcond = '18446744073709551615');
CREATE AGGREGATE pg_catalog.bit_and(binary) (SFUNC = pg_catalog.varbinary_and_binary, STYPE = varbinary);
CREATE AGGREGATE pg_catalog.bit_and(varbinary) (SFUNC = pg_catalog.varbinaryand, STYPE = varbinary);
CREATE AGGREGATE pg_catalog.bit_and(tinyblob) (SFUNC = pg_catalog.varbinary_and_tinyblob, STYPE = varbinary);
CREATE AGGREGATE pg_catalog.bit_and(blob) (SFUNC = pg_catalog.varbinary_and_blob, STYPE = varbinary);
CREATE AGGREGATE pg_catalog.bit_and(mediumblob) (SFUNC = pg_catalog.varbinary_and_mediumblob, STYPE = varbinary);
CREATE AGGREGATE pg_catalog.bit_and(longblob) (SFUNC = pg_catalog.varbinary_and_longblob, STYPE = varbinary);
CREATE AGGREGATE pg_catalog.bit_and(text) (SFUNC = pg_catalog.text_and_uint8, STYPE = uint8, initcond = '18446744073709551615');
CREATE AGGREGATE pg_catalog.bit_and(json) (SFUNC = pg_catalog.uint8and, cFUNC = pg_catalog.uint8and, STYPE = uint8, initcond = '18446744073709551615');

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;

CREATE OR REPLACE FUNCTION pg_catalog.inet6_ntoa(bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet6_ntoa(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.inet6_ntoa(boolean) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet6_ntoa(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.inet6_ntoa(year) RETURNS varchar LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'inetntop';
CREATE OR REPLACE FUNCTION pg_catalog.inet6_ntoa(blob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet6_ntoa(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.inet6_ntoa(anyenum) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet6_ntoa(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.inet6_ntoa(json) RETURNS varchar LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'inetntop';

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;

CREATE OR REPLACE FUNCTION pg_catalog.md5(bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.md5(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.md5(boolean) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.md5(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.md5(year) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.md5(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.md5(blob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.md5(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.md5(anyenum) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.md5(cast($1 as text))';
CREATE OR REPLACE FUNCTION pg_catalog.md5(json) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.md5(cast($1 as text))';
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;


DO $for_upgrade_only$
DECLARE
  ans boolean;
  v_isinplaceupgrade boolean;
BEGIN
    select case when count(*)=1 then true else false end as ans from (select setting from pg_settings where name = 'upgrade_mode' and setting != '0') into ans;
    show isinplaceupgrade into v_isinplaceupgrade;
    -- we can do drop operator only during upgrade
    if ans = true and v_isinplaceupgrade = true then
        drop operator IF EXISTS pg_catalog.=(uint2, int8);
        CREATE OPERATOR pg_catalog.=(
        leftarg = uint2, rightarg = int8, procedure = uint2_int8_eq,
        restrict = eqsel, join = eqjoinsel, commutator = operator(pg_catalog.=),
        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, commutator=operator(pg_catalog.=),
        HASHES, MERGES
        );
    end if;
END
$for_upgrade_only$;

CREATE FUNCTION pg_catalog.int8_uint4_eq (
int8,uint4
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_uint4_eq';

CREATE OPERATOR pg_catalog.=(
leftarg = int8, rightarg = uint4, procedure = int8_uint4_eq, commutator = operator(pg_catalog.=),
restrict = eqsel, join = eqjoinsel, HASHES, MERGES
);

CREATE or replace FUNCTION pg_catalog.int8_uint2_eq (
int8,uint2
) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_uint2_eq';

CREATE OPERATOR pg_catalog.=(
leftarg = int8, rightarg = uint2, procedure = int8_uint2_eq, commutator = operator(pg_catalog.=),
restrict = eqsel, join = eqjoinsel, HASHES, MERGES
);

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);

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       =(int8, uint2),
        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       =(int8, uint4),
        OPERATOR        1       =(int4, uint4),
        FUNCTION        1       hashuint4(uint4);

CREATE OPERATOR CLASS pg_catalog.enumtext_ops
     FOR TYPE anyenum USING hash AS
        OPERATOR        1       = ,
        OPERATOR        1       =(anyenum, text),
        OPERATOR        1       =(text, anyenum),
        FUNCTION        1       hashenum(anyenum),
        FUNCTION        1       hashtext(text);

DROP FUNCTION IF EXISTS pg_catalog.xor(integer, integer);
CREATE OR REPLACE FUNCTION pg_catalog.xor(int8, int8) RETURNS integer LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'dolphin_int8xor';
CREATE OR REPLACE FUNCTION pg_catalog.xor(int8, bit) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(bit, int8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(bit, bit) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(int8, text) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::bool::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(text, int8) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::bool::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(text, text) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::bool::int8, $2::bool::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(text, bit) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::bool::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(bit, text) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::bool::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varbinary, int8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(int8, varbinary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varbinary, varbinary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varbinary, bit) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(bit, varbinary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varbinary, text) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::bool::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(text, varbinary) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::bool::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(binary, int8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(int8, binary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(binary, binary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(binary, bit) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(bit, binary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varbinary, binary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(binary, varbinary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(binary, text) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::bool::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(text, binary) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::bool::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varchar, int8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(int8, varchar) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varchar, varchar) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varchar, bit) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(bit, varchar) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varbinary, varchar) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varchar, varbinary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varchar, text) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::bool::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(text, varchar) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::bool::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(binary, varchar) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varchar, binary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(char, int8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(int8, char) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(char, char) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(char, bit) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(bit, char) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varbinary, char) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(char, varbinary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(char, text) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::bool::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(text, char) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::bool::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(binary, char) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(char, binary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varchar, char) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(char, varchar) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.xor($1::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(unknown,unknown) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::text::int8, $2::text::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(unknown, int8) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::text::int8, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(int8, unknown) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1, $2::text::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(integer, unknown) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::text::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(unknown, integer) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::text::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(unknown, float8) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::text::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(float8, unknown) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::text::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(unknown, boolean) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::text::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(boolean, unknown) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::text::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(unknown, bit) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::text::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(bit, unknown) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::text::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(unknown, text) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::text::int8, $2::bool::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(text, unknown) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::bool::int8, $2::text::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(unknown, binary) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::text::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(binary, unknown) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::text::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varbinary, unknown) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::text::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(unknown, varbinary) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::text::int8, $2::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(varchar, unknown) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::int8, $2::text::int8)';
CREATE OR REPLACE FUNCTION pg_catalog.xor(unknown, varchar) RETURNS integer LANGUAGE SQL IMMUTABLE as 'select pg_catalog.xor($1::text::int8, $2::int8)';

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(bit) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.to_days(cast(cast($1 as int8) as timestamp(0) without time zone))';
CREATE OR REPLACE FUNCTION pg_catalog.to_days(boolean) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.to_days(cast(cast($1 as int8) as timestamp(0) without time zone))';
CREATE OR REPLACE FUNCTION pg_catalog.to_days(time) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.to_days(cast($1 as timestamp(0) without time zone))';
CREATE OR REPLACE FUNCTION pg_catalog.to_days(year) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.to_days(cast(cast($1 as int8) as timestamp(0) without time zone))';
CREATE OR REPLACE FUNCTION pg_catalog.to_days(binary) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.to_days(cast($1 as timestamp(0) without time zone))';
CREATE OR REPLACE FUNCTION pg_catalog.to_days(blob) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.to_days(cast($1 as timestamp(0) without time zone))';
CREATE OR REPLACE FUNCTION pg_catalog.to_days(text) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.to_days(text_timestamp($1))';
CREATE OR REPLACE FUNCTION pg_catalog.to_days(anyenum) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.to_days(cast($1 as timestamp(0) without time zone))';
CREATE OR REPLACE FUNCTION pg_catalog.to_days(anyset) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.to_days(cast($1 as timestamp(0) without time zone))';
CREATE OR REPLACE FUNCTION pg_catalog.to_days(json) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'select pg_catalog.to_days(cast($1 as timestamp(0) without time zone))';

CREATE OR REPLACE FUNCTION pg_catalog.round(int1) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(uint1) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(int2) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(uint2) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(int8) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(uint8) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(boolean) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(year) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number))::int8';

CREATE OR REPLACE FUNCTION pg_catalog.round(int1, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(uint1, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(int2, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(uint2, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(int4, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(uint4, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(int8, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(uint8, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(boolean, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(year, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(binary, int4) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.round(json, int4) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), $2)';

CREATE OR REPLACE FUNCTION pg_catalog.round(int1, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(uint1, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(int2, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(uint2, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(int4, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(uint4, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(int8, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(uint8, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(boolean, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(year, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.round(binary, uint4) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), cast($2 as int4))';
CREATE OR REPLACE FUNCTION pg_catalog.round(json, uint4) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as number), cast($2 as int4))';

CREATE OR REPLACE FUNCTION pg_catalog.truncate(int1, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(uint1, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(int2, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(uint2, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(int4, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(uint4, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(int8, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(uint8, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(boolean, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(year, int4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), $2)::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(binary, int4) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(json, int4) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), $2)';

CREATE OR REPLACE FUNCTION pg_catalog.truncate(int1, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(uint1, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(int2, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(uint2, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(int4, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(uint4, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(int8, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(uint8, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(boolean, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(year, uint4) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), cast($2 as int4))::int8';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(binary, uint4) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), cast($2 as int4))';
CREATE OR REPLACE FUNCTION pg_catalog.truncate(json, uint4) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.truncate(cast($1 as number), cast($2 as int4))';

CREATE FUNCTION pg_catalog.bit_concat(bit, bit) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bit_bool_concat(bit, boolean) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bool_bit_concat(boolean, bit) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bool_concat(boolean, boolean) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select concat($1, $2)';
CREATE FUNCTION pg_catalog.text_bool_concat(text, boolean) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select concat($1, $2)';
CREATE FUNCTION pg_catalog.bool_text_concat(boolean, text) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select concat($1, $2)';
CREATE FUNCTION pg_catalog.text_bit_concat(text, bit) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bit_text_concat(bit, text) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';

CREATE FUNCTION pg_catalog.bin_concat(binary,binary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bin_int_concat(binary,uint8) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bin_int8_concat(binary,int8) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bin_float4_concat(binary,float4) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bin_float8_concat(binary,float8) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bin_num_concat(binary,numeric) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bin_bit_concat(binary,bit) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bin_text_concat(binary,text) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bin_bool_concat(binary,boolean) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.int_bin_concat(uint8,binary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.int8_bin_concat(int8,binary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.float4_bin_concat(float4,binary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.float8_bin_concat(float8,binary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.num_bin_concat(numeric,binary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bit_bin_concat(bit,binary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.text_bin_concat(text,binary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bool_bin_concat(boolean,binary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';

CREATE FUNCTION pg_catalog.varbin_concat(varbinary,varbinary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.varbin_int_concat(varbinary,uint8) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.varbin_int8_concat(varbinary,int8) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.varbin_float4_concat(varbinary,float4) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.varbin_float8_concat(varbinary,float8) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.varbin_num_concat(varbinary,numeric) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.varbin_bit_concat(varbinary,bit) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.varbin_text_concat(varbinary,text) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.varbin_bool_concat(varbinary,boolean) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.varbin_bin_concat(varbinary,binary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.int_varbin_concat(uint8,varbinary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.int8_varbin_concat(int8,varbinary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.float4_varbin_concat(float4,varbinary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.float8_varbin_concat(float8,varbinary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.num_varbin_concat(numeric,varbinary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bit_varbin_concat(bit,varbinary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.text_varbin_concat(text,varbinary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bool_varbin_concat(boolean,varbinary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';
CREATE FUNCTION pg_catalog.bin_varbin_concat(binary,varbinary) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'concat_blob';

CREATE OPERATOR pg_catalog.||(leftarg=bit, rightarg=bit, procedure=pg_catalog.bit_concat);
CREATE OPERATOR pg_catalog.||(leftarg=bit, rightarg=boolean, procedure=pg_catalog.bit_bool_concat);
CREATE OPERATOR pg_catalog.||(leftarg=boolean, rightarg=bit, procedure=pg_catalog.bool_bit_concat);
CREATE OPERATOR pg_catalog.||(leftarg=boolean, rightarg=boolean, procedure=pg_catalog.bool_concat);
CREATE OPERATOR pg_catalog.||(leftarg=text, rightarg=boolean, procedure=pg_catalog.text_bool_concat);
CREATE OPERATOR pg_catalog.||(leftarg=boolean, rightarg=text, procedure=pg_catalog.bool_text_concat);
CREATE OPERATOR pg_catalog.||(leftarg=bit, rightarg=text, procedure=pg_catalog.bit_text_concat);
CREATE OPERATOR pg_catalog.||(leftarg=text, rightarg=bit, procedure=pg_catalog.text_bit_concat);
CREATE OPERATOR pg_catalog.||(leftarg=bit, rightarg=binary, procedure=pg_catalog.bit_bin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=binary, rightarg=bit, procedure=pg_catalog.bin_bit_concat);
CREATE OPERATOR pg_catalog.||(leftarg=uint8, rightarg=binary, procedure=pg_catalog.int_bin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=binary, rightarg=uint8, procedure=pg_catalog.bin_int_concat);
CREATE OPERATOR pg_catalog.||(leftarg=int8, rightarg=binary, procedure=pg_catalog.int8_bin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=binary, rightarg=int8, procedure=pg_catalog.bin_int8_concat);
CREATE OPERATOR pg_catalog.||(leftarg=numeric, rightarg=binary, procedure=pg_catalog.num_bin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=binary, rightarg=numeric, procedure=pg_catalog.bin_num_concat);
CREATE OPERATOR pg_catalog.||(leftarg=float4, rightarg=binary, procedure=pg_catalog.float4_bin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=binary, rightarg=float4, procedure=pg_catalog.bin_float4_concat);
CREATE OPERATOR pg_catalog.||(leftarg=float8, rightarg=binary, procedure=pg_catalog.float8_bin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=binary, rightarg=float8, procedure=pg_catalog.bin_float8_concat);
CREATE OPERATOR pg_catalog.||(leftarg=text, rightarg=binary, procedure=pg_catalog.text_bin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=binary, rightarg=text, procedure=pg_catalog.bin_text_concat);
CREATE OPERATOR pg_catalog.||(leftarg=boolean, rightarg=binary, procedure=pg_catalog.bool_bin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=binary, rightarg=boolean, procedure=pg_catalog.bin_bool_concat);
CREATE OPERATOR pg_catalog.||(leftarg=binary, rightarg=binary, procedure=pg_catalog.bin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=bit, rightarg=varbinary, procedure=pg_catalog.bit_varbin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=varbinary, rightarg=bit, procedure=pg_catalog.varbin_bit_concat);
CREATE OPERATOR pg_catalog.||(leftarg=uint8, rightarg=varbinary, procedure=pg_catalog.int_varbin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=varbinary, rightarg=uint8, procedure=pg_catalog.varbin_int_concat);
CREATE OPERATOR pg_catalog.||(leftarg=int8, rightarg=varbinary, procedure=pg_catalog.int8_varbin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=varbinary, rightarg=int8, procedure=pg_catalog.varbin_int8_concat);
CREATE OPERATOR pg_catalog.||(leftarg=numeric, rightarg=varbinary, procedure=pg_catalog.num_varbin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=varbinary, rightarg=numeric, procedure=pg_catalog.varbin_num_concat);
CREATE OPERATOR pg_catalog.||(leftarg=float4, rightarg=varbinary, procedure=pg_catalog.float4_varbin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=varbinary, rightarg=float4, procedure=pg_catalog.varbin_float4_concat);
CREATE OPERATOR pg_catalog.||(leftarg=float8, rightarg=varbinary, procedure=pg_catalog.float8_varbin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=varbinary, rightarg=float8, procedure=pg_catalog.varbin_float8_concat);
CREATE OPERATOR pg_catalog.||(leftarg=text, rightarg=varbinary, procedure=pg_catalog.text_varbin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=varbinary, rightarg=text, procedure=pg_catalog.varbin_text_concat);
CREATE OPERATOR pg_catalog.||(leftarg=boolean, rightarg=varbinary, procedure=pg_catalog.bool_varbin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=varbinary, rightarg=boolean, procedure=pg_catalog.varbin_bool_concat);
CREATE OPERATOR pg_catalog.||(leftarg=binary, rightarg=varbinary, procedure=pg_catalog.bin_varbin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=varbinary, rightarg=binary, procedure=pg_catalog.varbin_bin_concat);
CREATE OPERATOR pg_catalog.||(leftarg=varbinary, rightarg=varbinary, procedure=pg_catalog.varbin_concat);

CREATE OR REPLACE FUNCTION pg_catalog.lower(boolean) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower(cast($1 as TEXT))::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.lower(tinyblob) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'lower_blob';
CREATE OR REPLACE FUNCTION pg_catalog.lower(blob) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'lower_blob';
CREATE OR REPLACE FUNCTION pg_catalog.lower(mediumblob) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'lower_blob';
CREATE OR REPLACE FUNCTION pg_catalog.lower(longblob) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'lower_blob';
CREATE OR REPLACE FUNCTION pg_catalog.lower(bit) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'lower_bit';
CREATE OR REPLACE FUNCTION pg_catalog.lower(binary) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'lower_blob';
CREATE OR REPLACE FUNCTION pg_catalog.lower(varbinary) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'lower_blob';
CREATE OR REPLACE FUNCTION pg_catalog.lower(integer) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower(cast($1 as TEXT))::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.lower(float) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower(cast($1 as TEXT))::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.lower(char) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower(cast($1 as TEXT))::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.lower(varchar) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower(cast($1 as TEXT))::varchar';

CREATE OR REPLACE FUNCTION pg_catalog.lcase(boolean) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(tinyblob) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(blob) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(mediumblob) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(longblob) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(bit) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(binary) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(varbinary) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(integer) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(float) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(char) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(varchar) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';

CREATE OR REPLACE FUNCTION pg_catalog.int_uint2_eq(int, uint2) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT ($1 = $2::int4)';
CREATE OPERATOR pg_catalog.=(LEFTARG = int, RIGHTARG = uint2, COMMUTATOR = operator(pg_catalog.=), PROCEDURE = pg_catalog.int_uint2_eq, RESTRICT = eqsel, JOIN = eqjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.json_eq(tinyblob, json) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','json_eq';
CREATE OPERATOR pg_catalog.=(leftarg = tinyblob, rightarg = json, PROCEDURE = pg_catalog.json_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.json_eq(blob, json) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','json_eq';
CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = json, PROCEDURE = pg_catalog.json_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.json_eq(mediumblob, json) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','json_eq';
CREATE OPERATOR pg_catalog.=(leftarg = mediumblob, rightarg = json, PROCEDURE = pg_catalog.json_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.json_eq(longblob, json) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','json_eq';
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = json, PROCEDURE = pg_catalog.json_eq, RESTRICT = eqsel, JOIN = eqjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.json_eq(anyenum, json) RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','json_eq';
CREATE OPERATOR pg_catalog.=(leftarg = anyenum, rightarg = json, PROCEDURE = pg_catalog.json_eq, RESTRICT = eqsel, JOIN = eqjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.hex(anyenum) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'SELECT hex($1::text)';

CREATE OR REPLACE FUNCTION pg_catalog.left(bit, integer) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bit_left';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, integer) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'blob_left';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, integer) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left(cast($1 as text), $2)::varchar';
--blob op numeric
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_numeric_eq(arg1 tinyblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_numeric_ne(arg1 tinyblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_numeric_lt(arg1 tinyblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_numeric_le(arg1 tinyblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_numeric_gt(arg1 tinyblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_numeric_ge(arg1 tinyblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_numeric_cmp(tinyblob, numeric) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = tinyblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.tinyblob_numeric_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = tinyblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.tinyblob_numeric_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = tinyblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.tinyblob_numeric_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = tinyblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.tinyblob_numeric_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = tinyblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.tinyblob_numeric_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = tinyblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.tinyblob_numeric_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.numeric_tinyblob_eq(arg1 numeric, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_tinyblob_ne(arg1 numeric, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_tinyblob_lt(arg1 numeric, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_tinyblob_le(arg1 numeric, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_tinyblob_gt(arg1 numeric, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_tinyblob_ge(arg1 numeric, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_tinyblob_cmp(numeric, tinyblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = numeric, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.numeric_tinyblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = numeric, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.numeric_tinyblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = numeric, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.numeric_tinyblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = numeric, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.numeric_tinyblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = numeric, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.numeric_tinyblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = numeric, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.numeric_tinyblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.blob_numeric_eq(arg1 blob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_numeric_ne(arg1 blob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_numeric_lt(arg1 blob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_numeric_le(arg1 blob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_numeric_gt(arg1 blob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_numeric_ge(arg1 blob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_numeric_cmp(blob, numeric) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.blob_numeric_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.blob_numeric_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.blob_numeric_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.blob_numeric_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.blob_numeric_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.blob_numeric_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.numeric_blob_eq(arg1 numeric, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_blob_ne(arg1 numeric, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_blob_lt(arg1 numeric, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_blob_le(arg1 numeric, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_blob_gt(arg1 numeric, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_blob_ge(arg1 numeric, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_blob_cmp(numeric, blob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = numeric, rightarg = blob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.numeric_blob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = numeric, rightarg = blob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.numeric_blob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = numeric, rightarg = blob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.numeric_blob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = numeric, rightarg = blob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.numeric_blob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = numeric, rightarg = blob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.numeric_blob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = numeric, rightarg = blob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.numeric_blob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_numeric_eq(arg1 mediumblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_numeric_ne(arg1 mediumblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_numeric_lt(arg1 mediumblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_numeric_le(arg1 mediumblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_numeric_gt(arg1 mediumblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_numeric_ge(arg1 mediumblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_numeric_cmp(mediumblob, numeric) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = mediumblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.mediumblob_numeric_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = mediumblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.mediumblob_numeric_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = mediumblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.mediumblob_numeric_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = mediumblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.mediumblob_numeric_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = mediumblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.mediumblob_numeric_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = mediumblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.mediumblob_numeric_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.numeric_mediumblob_eq(arg1 numeric, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_mediumblob_ne(arg1 numeric, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_mediumblob_lt(arg1 numeric, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_mediumblob_le(arg1 numeric, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_mediumblob_gt(arg1 numeric, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_mediumblob_ge(arg1 numeric, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_mediumblob_cmp(numeric, mediumblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = numeric, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.numeric_mediumblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = numeric, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.numeric_mediumblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = numeric, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.numeric_mediumblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = numeric, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.numeric_mediumblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = numeric, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.numeric_mediumblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = numeric, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.numeric_mediumblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.longblob_numeric_eq(arg1 longblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_numeric_ne(arg1 longblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_numeric_lt(arg1 longblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_numeric_le(arg1 longblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_numeric_gt(arg1 longblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_numeric_ge(arg1 longblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_numeric_cmp(longblob, numeric) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.longblob_numeric_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = longblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.longblob_numeric_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = longblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.longblob_numeric_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = longblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.longblob_numeric_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = longblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.longblob_numeric_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = longblob, rightarg = numeric, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.longblob_numeric_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.numeric_longblob_eq(arg1 numeric, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_longblob_ne(arg1 numeric, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_longblob_lt(arg1 numeric, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_longblob_le(arg1 numeric, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_longblob_gt(arg1 numeric, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_longblob_ge(arg1 numeric, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_longblob_cmp(numeric, longblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = numeric, rightarg = longblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.numeric_longblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = numeric, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.numeric_longblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = numeric, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.numeric_longblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = numeric, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.numeric_longblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = numeric, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.numeric_longblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = numeric, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.numeric_longblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_int8_eq(arg1 tinyblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_int8_ne(arg1 tinyblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_int8_lt(arg1 tinyblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_int8_le(arg1 tinyblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_int8_gt(arg1 tinyblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_int8_ge(arg1 tinyblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_int8_cmp(tinyblob, int8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = tinyblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.tinyblob_int8_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = tinyblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.tinyblob_int8_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = tinyblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.tinyblob_int8_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = tinyblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.tinyblob_int8_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = tinyblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.tinyblob_int8_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = tinyblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.tinyblob_int8_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.int8_tinyblob_eq(arg1 int8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_tinyblob_ne(arg1 int8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_tinyblob_lt(arg1 int8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_tinyblob_le(arg1 int8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_tinyblob_gt(arg1 int8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_tinyblob_ge(arg1 int8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_tinyblob_cmp(int8, tinyblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = int8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.int8_tinyblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = int8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.int8_tinyblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = int8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.int8_tinyblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = int8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.int8_tinyblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = int8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.int8_tinyblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = int8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.int8_tinyblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.blob_int8_eq(arg1 blob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_int8_ne(arg1 blob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_int8_lt(arg1 blob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_int8_le(arg1 blob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_int8_gt(arg1 blob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_int8_ge(arg1 blob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_int8_cmp(blob, int8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = int8, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.blob_int8_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = int8, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.blob_int8_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = int8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.blob_int8_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = int8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.blob_int8_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = int8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.blob_int8_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = int8, COMMUTATOR = operator(pg_catalog.>=),procedure = pg_catalog.blob_int8_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.int8_blob_eq(arg1 int8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_blob_ne(arg1 int8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_blob_lt(arg1 int8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_blob_le(arg1 int8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_blob_gt(arg1 int8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_blob_ge(arg1 int8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_blob_cmp(int8, blob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = int8, rightarg = blob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.int8_blob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = int8, rightarg = blob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.int8_blob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = int8, rightarg = blob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.int8_blob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = int8, rightarg = blob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.int8_blob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = int8, rightarg = blob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.int8_blob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = int8, rightarg = blob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.int8_blob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_int8_eq(arg1 mediumblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_int8_ne(arg1 mediumblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_int8_lt(arg1 mediumblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_int8_le(arg1 mediumblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_int8_gt(arg1 mediumblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_int8_ge(arg1 mediumblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_int8_cmp(mediumblob, int8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = mediumblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.mediumblob_int8_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = mediumblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.mediumblob_int8_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = mediumblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.mediumblob_int8_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = mediumblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.mediumblob_int8_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = mediumblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.mediumblob_int8_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = mediumblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.mediumblob_int8_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.int8_mediumblob_eq(arg1 int8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_mediumblob_ne(arg1 int8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_mediumblob_lt(arg1 int8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_mediumblob_le(arg1 int8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_mediumblob_gt(arg1 int8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_mediumblob_ge(arg1 int8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_mediumblob_cmp(int8, mediumblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = int8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.int8_mediumblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = int8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.int8_mediumblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = int8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.int8_mediumblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = int8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.int8_mediumblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = int8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.int8_mediumblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = int8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.int8_mediumblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.longblob_int8_eq(arg1 longblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_int8_ne(arg1 longblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_int8_lt(arg1 longblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_int8_le(arg1 longblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_int8_gt(arg1 longblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_int8_ge(arg1 longblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_int8_cmp(longblob, int8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.longblob_int8_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = longblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.longblob_int8_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = longblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.longblob_int8_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = longblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.longblob_int8_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = longblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.longblob_int8_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = longblob, rightarg = int8, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.longblob_int8_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.int8_longblob_eq(arg1 int8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_longblob_ne(arg1 int8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_longblob_lt(arg1 int8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_longblob_le(arg1 int8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_longblob_gt(arg1 int8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_longblob_ge(arg1 int8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.int8_longblob_cmp(int8, longblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = int8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.int8_longblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = int8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.int8_longblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = int8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.int8_longblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = int8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.int8_longblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = int8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.int8_longblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = int8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.int8_longblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_uint8_eq(arg1 tinyblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_uint8_ne(arg1 tinyblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_uint8_lt(arg1 tinyblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_uint8_le(arg1 tinyblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_uint8_gt(arg1 tinyblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_uint8_ge(arg1 tinyblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_uint8_cmp(tinyblob, uint8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = tinyblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.tinyblob_uint8_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = tinyblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.tinyblob_uint8_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = tinyblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.tinyblob_uint8_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = tinyblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.tinyblob_uint8_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = tinyblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.tinyblob_uint8_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = tinyblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.tinyblob_uint8_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.uint8_tinyblob_eq(arg1 uint8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_tinyblob_ne(arg1 uint8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_tinyblob_lt(arg1 uint8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_tinyblob_le(arg1 uint8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_tinyblob_gt(arg1 uint8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_tinyblob_ge(arg1 uint8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_tinyblob_cmp(uint8, tinyblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = uint8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.uint8_tinyblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = uint8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.uint8_tinyblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = uint8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.uint8_tinyblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = uint8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.uint8_tinyblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = uint8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.uint8_tinyblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = uint8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.uint8_tinyblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.blob_uint8_eq(arg1 blob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_uint8_ne(arg1 blob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_uint8_lt(arg1 blob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_uint8_le(arg1 blob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_uint8_gt(arg1 blob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_uint8_ge(arg1 blob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_uint8_cmp(blob, uint8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.blob_uint8_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.blob_uint8_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.blob_uint8_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.blob_uint8_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.blob_uint8_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.blob_uint8_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.uint8_blob_eq(arg1 uint8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_blob_ne(arg1 uint8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_blob_lt(arg1 uint8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_blob_le(arg1 uint8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_blob_gt(arg1 uint8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_blob_ge(arg1 uint8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_blob_cmp(uint8, blob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = uint8, rightarg = blob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.uint8_blob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = uint8, rightarg = blob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.uint8_blob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = uint8, rightarg = blob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.uint8_blob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = uint8, rightarg = blob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.uint8_blob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = uint8, rightarg = blob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.uint8_blob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = uint8, rightarg = blob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.uint8_blob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_uint8_eq(arg1 mediumblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_uint8_ne(arg1 mediumblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_uint8_lt(arg1 mediumblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_uint8_le(arg1 mediumblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_uint8_gt(arg1 mediumblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_uint8_ge(arg1 mediumblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_uint8_cmp(mediumblob, uint8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = mediumblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.mediumblob_uint8_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = mediumblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.mediumblob_uint8_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = mediumblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.mediumblob_uint8_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = mediumblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.mediumblob_uint8_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = mediumblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.mediumblob_uint8_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = mediumblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.mediumblob_uint8_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.uint8_mediumblob_eq(arg1 uint8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_mediumblob_ne(arg1 uint8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_mediumblob_lt(arg1 uint8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_mediumblob_le(arg1 uint8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_mediumblob_gt(arg1 uint8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_mediumblob_ge(arg1 uint8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_mediumblob_cmp(uint8, mediumblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = uint8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.uint8_mediumblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = uint8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.uint8_mediumblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = uint8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.uint8_mediumblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = uint8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.uint8_mediumblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = uint8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.uint8_mediumblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = uint8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.uint8_mediumblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.longblob_uint8_eq(arg1 longblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_uint8_ne(arg1 longblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_uint8_lt(arg1 longblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_uint8_le(arg1 longblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_uint8_gt(arg1 longblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_uint8_ge(arg1 longblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_uint8_cmp(longblob, uint8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.longblob_uint8_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = longblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.longblob_uint8_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = longblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.longblob_uint8_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = longblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.longblob_uint8_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = longblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.longblob_uint8_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = longblob, rightarg = uint8, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.longblob_uint8_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.uint8_longblob_eq(arg1 uint8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_longblob_ne(arg1 uint8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_longblob_lt(arg1 uint8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_longblob_le(arg1 uint8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_longblob_gt(arg1 uint8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_longblob_ge(arg1 uint8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_longblob_cmp(uint8, longblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = uint8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.uint8_longblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = uint8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<>),  procedure = pg_catalog.uint8_longblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = uint8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<),  procedure = pg_catalog.uint8_longblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = uint8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<=),  procedure = pg_catalog.uint8_longblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = uint8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>),  procedure = pg_catalog.uint8_longblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = uint8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>=),  procedure = pg_catalog.uint8_longblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_float8_eq(arg1 tinyblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_float8_ne(arg1 tinyblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_float8_lt(arg1 tinyblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_float8_le(arg1 tinyblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_float8_gt(arg1 tinyblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_float8_ge(arg1 tinyblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_float8_cmp(tinyblob, float8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = tinyblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.tinyblob_float8_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = tinyblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.tinyblob_float8_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = tinyblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.tinyblob_float8_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = tinyblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.tinyblob_float8_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = tinyblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.tinyblob_float8_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = tinyblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.tinyblob_float8_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.float8_tinyblob_eq(arg1 float8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_tinyblob_ne(arg1 float8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_tinyblob_lt(arg1 float8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_tinyblob_le(arg1 float8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_tinyblob_gt(arg1 float8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_tinyblob_ge(arg1 float8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_tinyblob_cmp(float8, tinyblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = float8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.float8_tinyblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = float8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.float8_tinyblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = float8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.float8_tinyblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = float8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.float8_tinyblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = float8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.float8_tinyblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = float8, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.float8_tinyblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.blob_float8_eq(arg1 blob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_float8_ne(arg1 blob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_float8_lt(arg1 blob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_float8_le(arg1 blob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_float8_gt(arg1 blob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_float8_ge(arg1 blob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_float8_cmp(blob, float8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = float8, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.blob_float8_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = float8, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.blob_float8_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = float8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.blob_float8_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = float8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.blob_float8_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = float8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.blob_float8_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = float8, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.blob_float8_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.float8_blob_eq(arg1 float8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_blob_ne(arg1 float8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_blob_lt(arg1 float8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_blob_le(arg1 float8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_blob_gt(arg1 float8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_blob_ge(arg1 float8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_blob_cmp(float8, blob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = float8, rightarg = blob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.float8_blob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = float8, rightarg = blob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.float8_blob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = float8, rightarg = blob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.float8_blob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = float8, rightarg = blob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.float8_blob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = float8, rightarg = blob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.float8_blob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = float8, rightarg = blob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.float8_blob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_float8_eq(arg1 mediumblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_float8_ne(arg1 mediumblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_float8_lt(arg1 mediumblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_float8_le(arg1 mediumblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_float8_gt(arg1 mediumblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_float8_ge(arg1 mediumblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_float8_cmp(mediumblob, float8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = mediumblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.mediumblob_float8_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = mediumblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.mediumblob_float8_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = mediumblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.mediumblob_float8_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = mediumblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.mediumblob_float8_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = mediumblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.mediumblob_float8_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = mediumblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.mediumblob_float8_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.float8_mediumblob_eq(arg1 float8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_mediumblob_ne(arg1 float8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_mediumblob_lt(arg1 float8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_mediumblob_le(arg1 float8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_mediumblob_gt(arg1 float8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_mediumblob_ge(arg1 float8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_mediumblob_cmp(float8, mediumblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = float8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.float8_mediumblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = float8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.float8_mediumblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = float8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.float8_mediumblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = float8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.float8_mediumblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = float8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.float8_mediumblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = float8, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.float8_mediumblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.longblob_float8_eq(arg1 longblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::float8=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_float8_ne(arg1 longblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_float8_lt(arg1 longblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_float8_le(arg1 longblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_float8_gt(arg1 longblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_float8_ge(arg1 longblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::float8>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_float8_cmp(longblob, float8) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::float8, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.longblob_float8_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = longblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.longblob_float8_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = longblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.longblob_float8_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = longblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.longblob_float8_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = longblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.longblob_float8_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = longblob, rightarg = float8, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.longblob_float8_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.float8_longblob_eq(arg1 float8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_longblob_ne(arg1 float8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_longblob_lt(arg1 float8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_longblob_le(arg1 float8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_longblob_gt(arg1 float8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_longblob_ge(arg1 float8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::float8';
CREATE OR REPLACE FUNCTION pg_catalog.float8_longblob_cmp(float8, longblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::float8)';
CREATE OPERATOR pg_catalog.=(leftarg = float8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.float8_longblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = float8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.float8_longblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = float8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.float8_longblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = float8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.float8_longblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = float8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.float8_longblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = float8, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.float8_longblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_datetime_eq(arg1 tinyblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::text=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_datetime_ne(arg1 tinyblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_datetime_lt(arg1 tinyblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_datetime_le(arg1 tinyblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_datetime_gt(arg1 tinyblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_datetime_ge(arg1 tinyblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_datetime_cmp(tinyblob, timestamp without time zone) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::text, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = tinyblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.tinyblob_datetime_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = tinyblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.tinyblob_datetime_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = tinyblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.tinyblob_datetime_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = tinyblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.tinyblob_datetime_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = tinyblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.tinyblob_datetime_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = tinyblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.tinyblob_datetime_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.datetime_tinyblob_eq(arg1 timestamp without time zone, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_tinyblob_ne(arg1 timestamp without time zone, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_tinyblob_lt(arg1 timestamp without time zone, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_tinyblob_le(arg1 timestamp without time zone, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_tinyblob_gt(arg1 timestamp without time zone, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_tinyblob_ge(arg1 timestamp without time zone, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_tinyblob_cmp(timestamp without time zone, tinyblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::text)';
CREATE OPERATOR pg_catalog.=(leftarg = timestamp without time zone, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.datetime_tinyblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = timestamp without time zone, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.datetime_tinyblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = timestamp without time zone, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.datetime_tinyblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = timestamp without time zone, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.datetime_tinyblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = timestamp without time zone, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.datetime_tinyblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = timestamp without time zone, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.datetime_tinyblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.blob_datetime_eq(arg1 blob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::text=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_datetime_ne(arg1 blob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_datetime_lt(arg1 blob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_datetime_le(arg1 blob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_datetime_gt(arg1 blob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_datetime_ge(arg1 blob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_datetime_cmp(blob, timestamp without time zone) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::text, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.blob_datetime_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.blob_datetime_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.blob_datetime_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.blob_datetime_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.blob_datetime_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.blob_datetime_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.datetime_blob_eq(arg1 timestamp without time zone, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_blob_ne(arg1 timestamp without time zone, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_blob_lt(arg1 timestamp without time zone, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_blob_le(arg1 timestamp without time zone, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_blob_gt(arg1 timestamp without time zone, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_blob_ge(arg1 timestamp without time zone, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_blob_cmp(timestamp without time zone, blob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::text)';
CREATE OPERATOR pg_catalog.=(leftarg = timestamp without time zone, rightarg = blob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.datetime_blob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = timestamp without time zone, rightarg = blob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.datetime_blob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = timestamp without time zone, rightarg = blob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.datetime_blob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = timestamp without time zone, rightarg = blob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.datetime_blob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = timestamp without time zone, rightarg = blob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.datetime_blob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = timestamp without time zone, rightarg = blob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.datetime_blob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_datetime_eq(arg1 mediumblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::text=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_datetime_ne(arg1 mediumblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_datetime_lt(arg1 mediumblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_datetime_le(arg1 mediumblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_datetime_gt(arg1 mediumblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_datetime_ge(arg1 mediumblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_datetime_cmp(mediumblob, timestamp without time zone) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::text, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = mediumblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.mediumblob_datetime_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = mediumblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.mediumblob_datetime_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = mediumblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.mediumblob_datetime_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = mediumblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.mediumblob_datetime_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = mediumblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.mediumblob_datetime_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = mediumblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.mediumblob_datetime_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.datetime_mediumblob_eq(arg1 timestamp without time zone, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_mediumblob_ne(arg1 timestamp without time zone, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_mediumblob_lt(arg1 timestamp without time zone, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_mediumblob_le(arg1 timestamp without time zone, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_mediumblob_gt(arg1 timestamp without time zone, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_mediumblob_ge(arg1 timestamp without time zone, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_mediumblob_cmp(timestamp without time zone, mediumblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::text)';
CREATE OPERATOR pg_catalog.=(leftarg = timestamp without time zone, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.datetime_mediumblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = timestamp without time zone, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.datetime_mediumblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = timestamp without time zone, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.datetime_mediumblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = timestamp without time zone, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.datetime_mediumblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = timestamp without time zone, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.datetime_mediumblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = timestamp without time zone, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.datetime_mediumblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.longblob_datetime_eq(arg1 longblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::text=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_datetime_ne(arg1 longblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_datetime_lt(arg1 longblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_datetime_le(arg1 longblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_datetime_gt(arg1 longblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_datetime_ge(arg1 longblob, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_datetime_cmp(longblob, timestamp without time zone) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::text, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.longblob_datetime_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = longblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.longblob_datetime_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = longblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.longblob_datetime_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = longblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.longblob_datetime_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = longblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.longblob_datetime_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = longblob, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.longblob_datetime_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.datetime_longblob_eq(arg1 timestamp without time zone, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_longblob_ne(arg1 timestamp without time zone, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_longblob_lt(arg1 timestamp without time zone, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_longblob_le(arg1 timestamp without time zone, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_longblob_gt(arg1 timestamp without time zone, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_longblob_ge(arg1 timestamp without time zone, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_longblob_cmp(timestamp without time zone, longblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::text)';
CREATE OPERATOR pg_catalog.=(leftarg = timestamp without time zone, rightarg = longblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.datetime_longblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = timestamp without time zone, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.datetime_longblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = timestamp without time zone, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.datetime_longblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = timestamp without time zone, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.datetime_longblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = timestamp without time zone, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.datetime_longblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = timestamp without time zone, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.datetime_longblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_timestamp_eq(arg1 tinyblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::text=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_timestamp_ne(arg1 tinyblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_timestamp_lt(arg1 tinyblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_timestamp_le(arg1 tinyblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_timestamp_gt(arg1 tinyblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_timestamp_ge(arg1 tinyblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_timestamp_cmp(tinyblob, timestamptz) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::text, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = tinyblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.tinyblob_timestamp_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = tinyblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.tinyblob_timestamp_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = tinyblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.tinyblob_timestamp_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = tinyblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.tinyblob_timestamp_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = tinyblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.tinyblob_timestamp_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = tinyblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.tinyblob_timestamp_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.timestamp_tinyblob_eq(arg1 timestamptz, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_tinyblob_ne(arg1 timestamptz, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_tinyblob_lt(arg1 timestamptz, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_tinyblob_le(arg1 timestamptz, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_tinyblob_gt(arg1 timestamptz, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_tinyblob_ge(arg1 timestamptz, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_tinyblob_cmp(timestamptz, tinyblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::text)';
CREATE OPERATOR pg_catalog.=(leftarg = timestamptz, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.timestamp_tinyblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = timestamptz, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.timestamp_tinyblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = timestamptz, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.timestamp_tinyblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = timestamptz, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.timestamp_tinyblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = timestamptz, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.timestamp_tinyblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = timestamptz, rightarg = tinyblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.timestamp_tinyblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.blob_timestamp_eq(arg1 blob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::text=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_timestamp_ne(arg1 blob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_timestamp_lt(arg1 blob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_timestamp_le(arg1 blob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_timestamp_gt(arg1 blob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_timestamp_ge(arg1 blob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.blob_timestamp_cmp(blob, timestamptz) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::text, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = blob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.blob_timestamp_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = blob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.blob_timestamp_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = blob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.blob_timestamp_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = blob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.blob_timestamp_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = blob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.blob_timestamp_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = blob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.blob_timestamp_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.timestamp_blob_eq(arg1 timestamptz, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_blob_ne(arg1 timestamptz, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_blob_lt(arg1 timestamptz, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_blob_le(arg1 timestamptz, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_blob_gt(arg1 timestamptz, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_blob_ge(arg1 timestamptz, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_blob_cmp(timestamptz, blob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::text)';
CREATE OPERATOR pg_catalog.=(leftarg = timestamptz, rightarg = blob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.timestamp_blob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = timestamptz, rightarg = blob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.timestamp_blob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = timestamptz, rightarg = blob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.timestamp_blob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = timestamptz, rightarg = blob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.timestamp_blob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = timestamptz, rightarg = blob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.timestamp_blob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = timestamptz, rightarg = blob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.timestamp_blob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_timestamp_eq(arg1 mediumblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::text=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_timestamp_ne(arg1 mediumblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_timestamp_lt(arg1 mediumblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_timestamp_le(arg1 mediumblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_timestamp_gt(arg1 mediumblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_timestamp_ge(arg1 mediumblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_timestamp_cmp(mediumblob, timestamptz) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::text, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = mediumblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.mediumblob_timestamp_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = mediumblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.mediumblob_timestamp_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = mediumblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.mediumblob_timestamp_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = mediumblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.mediumblob_timestamp_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = mediumblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.mediumblob_timestamp_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = mediumblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.mediumblob_timestamp_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.timestamp_mediumblob_eq(arg1 timestamptz, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_mediumblob_ne(arg1 timestamptz, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_mediumblob_lt(arg1 timestamptz, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_mediumblob_le(arg1 timestamptz, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_mediumblob_gt(arg1 timestamptz, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_mediumblob_ge(arg1 timestamptz, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_mediumblob_cmp(timestamptz, mediumblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::text)';
CREATE OPERATOR pg_catalog.=(leftarg = timestamptz, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.timestamp_mediumblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = timestamptz, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.timestamp_mediumblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = timestamptz, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.timestamp_mediumblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = timestamptz, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.timestamp_mediumblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = timestamptz, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.timestamp_mediumblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = timestamptz, rightarg = mediumblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.timestamp_mediumblob_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.longblob_timestamp_eq(arg1 longblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::text=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_timestamp_ne(arg1 longblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_timestamp_lt(arg1 longblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_timestamp_le(arg1 longblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_timestamp_gt(arg1 longblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_timestamp_ge(arg1 longblob, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::text>=$2';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_timestamp_cmp(longblob, timestamptz) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1::text, $2)';
CREATE OPERATOR pg_catalog.=(leftarg = longblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.longblob_timestamp_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = longblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.longblob_timestamp_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = longblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.longblob_timestamp_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = longblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.longblob_timestamp_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = longblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.longblob_timestamp_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = longblob, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.longblob_timestamp_ge, restrict = scalarltsel, join = scalarltjoinsel);

CREATE OR REPLACE FUNCTION pg_catalog.timestamp_longblob_eq(arg1 timestamptz, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_longblob_ne(arg1 timestamptz, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_longblob_lt(arg1 timestamptz, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_longblob_le(arg1 timestamptz, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_longblob_gt(arg1 timestamptz, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_longblob_ge(arg1 timestamptz, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::text';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_longblob_cmp(timestamptz, longblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.btfloat8cmp($1, $2::text)';
CREATE OPERATOR pg_catalog.=(leftarg = timestamptz, rightarg = longblob, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.timestamp_longblob_eq, restrict = eqsel, join = eqjoinsel);
CREATE OPERATOR pg_catalog.<>(leftarg = timestamptz, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.timestamp_longblob_ne, restrict = neqsel, join = neqjoinsel);
CREATE OPERATOR pg_catalog.<(leftarg = timestamptz, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.timestamp_longblob_lt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.<=(leftarg = timestamptz, rightarg = longblob, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.timestamp_longblob_le, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>(leftarg = timestamptz, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.timestamp_longblob_gt, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OPERATOR pg_catalog.>=(leftarg = timestamptz, rightarg = longblob, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.timestamp_longblob_ge, restrict = scalarltsel, join = scalarltjoinsel);
CREATE OR REPLACE FUNCTION pg_catalog.any_accum(numeric[], anyelement) RETURNS numeric[] LANGUAGE C STRICT AS  '$libdir/dolphin',  'any_accum';
CREATE AGGREGATE pg_catalog.stddev_pop(json) (SFUNC = any_accum, cFUNC = numeric_collect, STYPE = numeric[], finalfunc = numeric_stddev_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');
CREATE AGGREGATE pg_catalog.var_pop(json) (SFUNC = any_accum, cFUNC = numeric_collect, STYPE = numeric[], finalfunc = numeric_var_pop, initcond = '{0,0,0}', initcollect = '{0,0,0}');

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);

CREATE OR REPLACE FUNCTION pg_catalog.upper(int8) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(numeric) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(date) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(time) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(timestamp(0) without time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(timestamp(0) with time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(binary) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT AS '$libdir/dolphin',  'binary_varbinary';
CREATE OR REPLACE FUNCTION pg_catalog.upper(bit) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text::binary)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(boolean) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(year) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(char) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(varchar) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(varbinary) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT AS 'select $1';
CREATE OR REPLACE FUNCTION pg_catalog.upper(tinyblob) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::binary)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(blob) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT AS 'select $1';
CREATE OR REPLACE FUNCTION pg_catalog.upper(mediumblob) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT AS 'select $1';
CREATE OR REPLACE FUNCTION pg_catalog.upper(longblob) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT AS 'select $1';
CREATE OR REPLACE FUNCTION pg_catalog.upper(anyenum) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(anyset) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.upper(json) RETURNS text LANGUAGE SQL IMMUTABLE STRICT AS 'select pg_catalog.upper($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.length(boolean) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.length($1::integer)';
CREATE OR REPLACE FUNCTION pg_catalog.length(tinyblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.length($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.length(blob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.length($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.length(mediumblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.length($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.length(longblob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.length($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.length(anyenum) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.length($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.length(json) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.length($1::text)';

CREATE OR REPLACE FUNCTION pg_catalog.octet_length(boolean) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.octet_length($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.octet_length(year) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.octet_length($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.octet_length(blob) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.octet_length($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.octet_length(anyenum) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.octet_length($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.octet_length(json) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.octet_length($1::text)';

CREATE OR REPLACE FUNCTION pg_catalog.position(boolean, text) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.position($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.position(binary, text) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.position($1::bytea, $2::bytea)';
CREATE OR REPLACE FUNCTION pg_catalog.position(varbinary, text) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.position($1::bytea, $2::bytea)';

CREATE OR REPLACE FUNCTION pg_catalog.instr(binary, text) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.position($1, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.instr(varbinary, text) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.position($1, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.instr(boolean, text, integer) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.instr($1::text, $2, $3)';
CREATE OR REPLACE FUNCTION pg_catalog.instr(bit, bit, integer) RETURNS integer LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'instr_bit';
CREATE OR REPLACE FUNCTION pg_catalog.instr(bytea, bytea, integer) RETURNS integer LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'instr_binary';
CREATE OR REPLACE FUNCTION pg_catalog.instr(binary, text, integer) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.instr($1::bytea, $2::bytea, $3)';
CREATE OR REPLACE FUNCTION pg_catalog.instr(varbinary, text, integer) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.instr($1::bytea, $2::bytea, $3)';

CREATE OR REPLACE FUNCTION pg_catalog.locate(boolean, text) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.position($1, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.locate(bit, bit) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.position($1, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.locate(binary, text) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.position($1, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.locate(varbinary, text) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.position($1, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.locate(boolean, text, integer) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.instr($1, $2, $3)';
CREATE OR REPLACE FUNCTION pg_catalog.locate(bit, bit, integer) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.instr($1, $2, $3)';
CREATE OR REPLACE FUNCTION pg_catalog.locate(bytea, bytea, integer) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.instr($1, $2, $3)';
CREATE OR REPLACE FUNCTION pg_catalog.locate(binary, text, integer) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.instr($1, $2, $3)';
CREATE OR REPLACE FUNCTION pg_catalog.locate(varbinary, text, integer) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.instr($1, $2, $3)';

CREATE OR REPLACE FUNCTION pg_catalog.mid(boolean, int) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1::text, $2)::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.mid(boolean, int, int) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1::text, $2, $3)::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.mid(binary, int) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1::bytea, $2)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.mid(binary, int, int) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1::bytea, $2, $3)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.mid(varbinary, int) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1::bytea, $2)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.mid(varbinary, int, int) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1::bytea, $2, $3)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.mid(bit, int) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bit_substr_no_len';
CREATE OR REPLACE FUNCTION pg_catalog.mid(bit, int, int) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bit_substr';

CREATE OR REPLACE FUNCTION pg_catalog.mid(text, bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int)::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.mid(boolean, bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int)::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.mid(binary, bit) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.mid(varbinary, bit) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.mid(bit, bit) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int)::varbinary(65535)';

CREATE OR REPLACE FUNCTION pg_catalog.mid(text, bit, int) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int, $3)::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.mid(boolean, bit, int) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1::text, $2::int, $3)::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.mid(binary, bit, int) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1::bytea, $2::int, $3)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.mid(varbinary, bit, int) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int, $3)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.mid(bit, bit, int) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int, $3)::varbinary(65535)';

CREATE OR REPLACE FUNCTION pg_catalog.mid(text, int, bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2, $3::int)::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.mid(boolean, int, bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2, $3::int)::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.mid(binary, int, bit) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2, $3::int)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.mid(varbinary, int, bit) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2, $3::int)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.mid(bit, int, bit) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2, $3::int)::varbinary(65535)';

CREATE OR REPLACE FUNCTION pg_catalog.mid(text, bit, bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int, $3::int)::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.mid(boolean, bit, bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int, $3::int)::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.mid(binary, bit, bit) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int, $3::int)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.mid(varbinary, bit, bit) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int, $3::int)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.mid(bit, bit, bit) RETURNS varbinary LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mid($1, $2::int, $3::int)::varbinary(65535)';

CREATE OR REPLACE FUNCTION pg_catalog.log10(float8) RETURNS double precision LANGUAGE INTERNAL IMMUTABLE STRICT as 'dlog10';

CREATE OR REPLACE FUNCTION pg_catalog.lower(int8) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower(cast($1 as TEXT))::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.lower(uint8) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower(cast($1 as TEXT))::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.lower(float4) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower(cast($1 as TEXT))::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.lower(numeric) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower(cast($1 as TEXT))::varchar';

CREATE OR REPLACE FUNCTION pg_catalog.lcase(int8) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(uint8) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(float4) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';
CREATE OR REPLACE FUNCTION pg_catalog.lcase(numeric) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lower($1)';

DROP FUNCTION IF EXISTS pg_catalog.cot(bit);
CREATE OR REPLACE FUNCTION pg_catalog.cot(bit) RETURNS double precision LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cot_bit';
DROP FUNCTION IF EXISTS pg_catalog.cot(boolean);
CREATE OR REPLACE FUNCTION pg_catalog.cot(boolean) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.cot(cast($1 as float))';

DROP FUNCTION IF EXISTS pg_catalog.acos(bit);
CREATE OR REPLACE FUNCTION pg_catalog.acos(bit) RETURNS double precision LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'acos_bit';

DROP FUNCTION IF EXISTS pg_catalog.cos(bit);
CREATE OR REPLACE FUNCTION pg_catalog.cos(bit) RETURNS double precision LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'cos_bit';
DROP FUNCTION IF EXISTS pg_catalog.cos(boolean);
CREATE OR REPLACE FUNCTION pg_catalog.cos(boolean) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.cos(cast($1 as float))';

DROP FUNCTION IF EXISTS pg_catalog.asin(bit);
CREATE OR REPLACE FUNCTION pg_catalog.asin(bit) RETURNS double precision LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'asin_bit';
DROP FUNCTION IF EXISTS pg_catalog.asin(boolean);
CREATE OR REPLACE FUNCTION pg_catalog.asin(boolean) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.asin(cast($1 as float))';

DROP FUNCTION IF EXISTS pg_catalog.atan(bit);
CREATE OR REPLACE FUNCTION pg_catalog.atan(bit) RETURNS double precision LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'atan_bit';

DROP FUNCTION IF EXISTS pg_catalog.year(integer);
CREATE OR REPLACE FUNCTION pg_catalog.year(integer) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT year($1::timestamp(0) without time zone)';
CREATE OR REPLACE FUNCTION pg_catalog.year(anyset) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT year($1::timestamp(0) without time zone)';

CREATE OR REPLACE FUNCTION pg_catalog.hour(bit) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as  '$libdir/dolphin','hour_bit';
CREATE OR REPLACE FUNCTION pg_catalog.hour(blob) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT hour($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.hour(boolean) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT hour($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.hour(json) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT hour($1::timestamp(0) without time zone)';
CREATE OR REPLACE FUNCTION pg_catalog.hour(integer) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT hour($1::text)';

CREATE OR REPLACE FUNCTION pg_catalog.minute(bit) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as  '$libdir/dolphin','minute_bit';
CREATE OR REPLACE FUNCTION pg_catalog.minute(blob) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT minute($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.minute(boolean) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT minute($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.minute(json) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT minute($1::timestamp(0) without time zone)';
CREATE OR REPLACE FUNCTION pg_catalog.minute(integer) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT minute($1::text)';

CREATE OR REPLACE FUNCTION pg_catalog.second(bit) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as  '$libdir/dolphin','second_bit';
CREATE OR REPLACE FUNCTION pg_catalog.second(blob) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT second($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.second(boolean) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT second($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.second(json) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT second($1::timestamp(0) without time zone)';
CREATE OR REPLACE FUNCTION pg_catalog.second(integer) RETURNS int8 LANGUAGE SQL IMMUTABLE STRICT as 'SELECT second($1::text)';

CREATE OR REPLACE FUNCTION pg_catalog.microsecond (year) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT microsecond($1::time)';
CREATE OR REPLACE FUNCTION pg_catalog.microsecond (bit) RETURNS int8 LANGUAGE C IMMUTABLE STRICT as  '$libdir/dolphin','microsecond_bit';
CREATE OR REPLACE FUNCTION pg_catalog.microsecond (blob) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT microsecond($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.microsecond (boolean) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT microsecond($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.microsecond (json) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT microsecond($1::timestamp(0) without time zone)';
CREATE OR REPLACE FUNCTION pg_catalog.microsecond (integer) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT microsecond($1::text)';
CREATE OR REPLACE FUNCTION pg_catalog.microsecond (float) RETURNS int8 LANGUAGE SQL STABLE STRICT as 'SELECT microsecond($1::text)';

DROP FUNCTION IF EXISTS pg_catalog.left(text, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(text, numeric);
CREATE OR REPLACE FUNCTION pg_catalog.left(text, numeric) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_left_numeric';
CREATE OR REPLACE FUNCTION pg_catalog.left(text, bit) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, cast($2 as numeric))';
DROP FUNCTION IF EXISTS pg_catalog.right(text, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(text, numeric);
CREATE OR REPLACE FUNCTION pg_catalog.right(text, numeric) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_right_numeric';
CREATE OR REPLACE FUNCTION pg_catalog.right(text, bit) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, cast($2 as numeric))';

DROP FUNCTION IF EXISTS pg_catalog.right(bit, numeric);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, year);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, text);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(bit, json);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, numeric);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, year);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, text);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(boolean, json);
DROP FUNCTION IF EXISTS pg_catalog.right(year, numeric);
DROP FUNCTION IF EXISTS pg_catalog.right(year, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(year, year);
DROP FUNCTION IF EXISTS pg_catalog.right(year, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(year, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(year, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(year, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(year, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(year, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(year, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(year, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(year, text);
DROP FUNCTION IF EXISTS pg_catalog.right(year, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(year, json);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, numeric);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, year);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, text);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(tinyblob, json);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, numeric);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, year);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, text);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(mediumblob, json);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, numeric);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, year);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, text);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(longblob, json);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, year);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, text);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, json);
DROP FUNCTION IF EXISTS pg_catalog.right(blob, numeric);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, numeric);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, year);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, text);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(anyenum, json);
DROP FUNCTION IF EXISTS pg_catalog.right(json, numeric);
DROP FUNCTION IF EXISTS pg_catalog.right(json, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(json, year);
DROP FUNCTION IF EXISTS pg_catalog.right(json, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(json, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(json, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(json, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(json, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(json, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(json, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(json, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(json, text);
DROP FUNCTION IF EXISTS pg_catalog.right(json, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(json, json);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, numeric);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, year);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, text);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(binary, json);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, numeric);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, year);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, text);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(varbinary, json);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, bit);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, year);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, text);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, json);
DROP FUNCTION IF EXISTS pg_catalog.right(bytea, numeric);
DROP FUNCTION IF EXISTS pg_catalog.right(text, year);
DROP FUNCTION IF EXISTS pg_catalog.right(text, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(text, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.right(text, binary);
DROP FUNCTION IF EXISTS pg_catalog.right(text, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.right(text, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.right(text, blob);
DROP FUNCTION IF EXISTS pg_catalog.right(text, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.right(text, longblob);
DROP FUNCTION IF EXISTS pg_catalog.right(text, text);
DROP FUNCTION IF EXISTS pg_catalog.right(text, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.right(text, json);
CREATE OR REPLACE FUNCTION pg_catalog.right(text, year) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(text, timestamp with time zone) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(text, timestamp without time zone) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(text, binary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(text, varbinary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(text, tinyblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(text, blob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(text, mediumblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(text, longblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(text, text) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(text, anyenum) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(text, json) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, numeric) RETURNS bytea LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bytea_right_numeric';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, bit) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, year) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, timestamp with time zone) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, timestamp without time zone) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, binary) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, varbinary) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, tinyblob) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, blob) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, mediumblob) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, longblob) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, text) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, anyenum) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bytea, json) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, numeric) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, bit) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, year) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, timestamp with time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, timestamp without time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, binary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, varbinary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, tinyblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, blob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, mediumblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, longblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, text) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, anyenum) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(binary, json) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, numeric) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, bit) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, year) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, timestamp with time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, timestamp without time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, binary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, varbinary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, tinyblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, blob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, mediumblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, longblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, text) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, anyenum) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(varbinary, json) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, numeric) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, year) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, timestamp with time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, timestamp without time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, binary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, varbinary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, tinyblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, blob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, mediumblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, longblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, text) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, anyenum) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(boolean, json) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, numeric) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, year) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, timestamp with time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, timestamp without time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, binary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, varbinary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, tinyblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, blob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, mediumblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, longblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, text) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, anyenum) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(year, json) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, numeric) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'blob_right_numeric';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, bit) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, year) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, timestamp with time zone) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, timestamp without time zone) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, binary) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, varbinary) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, tinyblob) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, blob) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, mediumblob) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, longblob) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, text) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, anyenum) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(blob, json) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, numeric) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, bit) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, year) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, timestamp with time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, timestamp without time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, binary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, varbinary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, tinyblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, blob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, mediumblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, longblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, text) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, anyenum) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(tinyblob, json) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, numeric) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, bit) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, year) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, timestamp with time zone) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, timestamp without time zone) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, binary) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, varbinary) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, tinyblob) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, blob) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, mediumblob) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, longblob) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, text) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, anyenum) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(mediumblob, json) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, numeric) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, bit) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, year) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, timestamp with time zone) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, timestamp without time zone) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, binary) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, varbinary) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, tinyblob) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, blob) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, mediumblob) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, longblob) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, text) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, anyenum) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(longblob, json) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, numeric) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, bit) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, year) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, timestamp with time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, timestamp without time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, binary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, varbinary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, tinyblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, blob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, mediumblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, longblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, text) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, anyenum) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(bit, json) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::blob, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, numeric) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, year) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, timestamp with time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, timestamp without time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, binary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, varbinary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, tinyblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, blob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, mediumblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, longblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, text) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, anyenum) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(anyenum, json) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, numeric) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, bit) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, year) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, timestamp with time zone) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, timestamp without time zone) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, binary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, varbinary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, tinyblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, blob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, mediumblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, longblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, text) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, anyenum) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.right(json, json) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.right($1::text, $2::number)';

DROP FUNCTION IF EXISTS pg_catalog.left(bit, numeric);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, year);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, text);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(bit, json);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, numeric);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, year);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, text);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(boolean, json);
DROP FUNCTION IF EXISTS pg_catalog.left(year, numeric);
DROP FUNCTION IF EXISTS pg_catalog.left(year, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(year, year);
DROP FUNCTION IF EXISTS pg_catalog.left(year, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(year, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(year, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(year, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(year, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(year, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(year, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(year, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(year, text);
DROP FUNCTION IF EXISTS pg_catalog.left(year, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(year, json);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, numeric);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, year);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, text);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(tinyblob, json);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, numeric);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, year);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, text);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(mediumblob, json);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, numeric);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, year);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, text);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(longblob, json);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, year);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, text);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, json);
DROP FUNCTION IF EXISTS pg_catalog.left(blob, numeric);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, numeric);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, year);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, text);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(anyenum, json);
DROP FUNCTION IF EXISTS pg_catalog.left(json, numeric);
DROP FUNCTION IF EXISTS pg_catalog.left(json, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(json, year);
DROP FUNCTION IF EXISTS pg_catalog.left(json, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(json, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(json, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(json, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(json, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(json, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(json, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(json, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(json, text);
DROP FUNCTION IF EXISTS pg_catalog.left(json, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(json, json);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, numeric);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, year);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, text);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(binary, json);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, numeric);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, year);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, text);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(varbinary, json);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, bit);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, year);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, text);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, json);
DROP FUNCTION IF EXISTS pg_catalog.left(bytea, numeric);
DROP FUNCTION IF EXISTS pg_catalog.left(text, year);
DROP FUNCTION IF EXISTS pg_catalog.left(text, timestamp with time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(text, timestamp without time zone);
DROP FUNCTION IF EXISTS pg_catalog.left(text, binary);
DROP FUNCTION IF EXISTS pg_catalog.left(text, varbinary);
DROP FUNCTION IF EXISTS pg_catalog.left(text, tinyblob);
DROP FUNCTION IF EXISTS pg_catalog.left(text, blob);
DROP FUNCTION IF EXISTS pg_catalog.left(text, mediumblob);
DROP FUNCTION IF EXISTS pg_catalog.left(text, longblob);
DROP FUNCTION IF EXISTS pg_catalog.left(text, text);
DROP FUNCTION IF EXISTS pg_catalog.left(text, anyenum);
DROP FUNCTION IF EXISTS pg_catalog.left(text, json);
CREATE OR REPLACE FUNCTION pg_catalog.left(text, year) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(text, timestamp with time zone) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(text, timestamp without time zone) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(text, binary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(text, varbinary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(text, tinyblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(text, blob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(text, mediumblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(text, longblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(text, text) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(text, anyenum) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(text, json) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, numeric) RETURNS bytea LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'bytea_left_numeric';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, bit) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, year) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, timestamp with time zone) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, timestamp without time zone) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, binary) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, varbinary) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, tinyblob) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, blob) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, mediumblob) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, longblob) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, text) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, anyenum) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bytea, json) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, numeric) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, bit) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, year) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, timestamp with time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, timestamp without time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, binary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, varbinary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, tinyblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, blob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, mediumblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, longblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, text) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, anyenum) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(binary, json) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, numeric) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, bit) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, year) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, timestamp with time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, timestamp without time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, binary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, varbinary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, tinyblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, blob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, mediumblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, longblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, text) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, anyenum) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(varbinary, json) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::bytea, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, numeric) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, year) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, timestamp with time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, timestamp without time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, binary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, varbinary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, tinyblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, blob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, mediumblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, longblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, text) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, anyenum) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(boolean, json) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, numeric) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, year) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, timestamp with time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, timestamp without time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, binary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, varbinary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, tinyblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, blob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, mediumblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, longblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, text) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, anyenum) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(year, json) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, numeric) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'blob_left_numeric';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, bit) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, year) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, timestamp with time zone) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, timestamp without time zone) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, binary) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, varbinary) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, tinyblob) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, blob) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, mediumblob) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, longblob) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, text) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, anyenum) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(blob, json) RETURNS blob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, numeric) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, bit) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, year) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, timestamp with time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, timestamp without time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, binary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, varbinary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, tinyblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, blob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, mediumblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, longblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, text) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, anyenum) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(tinyblob, json) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, numeric) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, bit) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, year) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, timestamp with time zone) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, timestamp without time zone) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, binary) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, varbinary) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, tinyblob) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, blob) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, mediumblob) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, longblob) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, text) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, anyenum) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(mediumblob, json) RETURNS mediumblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::mediumblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, numeric) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, bit) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, year) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, timestamp with time zone) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, timestamp without time zone) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, binary) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, varbinary) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, tinyblob) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, blob) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, mediumblob) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, longblob) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, text) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, anyenum) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(longblob, json) RETURNS longblob LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::longblob';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, numeric) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::varbinary(65535), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, bit) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, year) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, timestamp with time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, timestamp without time zone) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, binary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, varbinary) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, tinyblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, blob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, mediumblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, longblob) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, text) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, anyenum) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(bit, json) RETURNS varbinary(65535) LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::blob, $2::number)::varbinary(65535)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, numeric) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, year) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, timestamp with time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, timestamp without time zone) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, binary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, varbinary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, tinyblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, blob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, mediumblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, longblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, text) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, anyenum) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(anyenum, json) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, numeric) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, bit) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, year) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, timestamp with time zone) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, timestamp without time zone) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, binary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, varbinary) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, tinyblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, blob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, mediumblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, longblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, text) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, anyenum) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';
CREATE OR REPLACE FUNCTION pg_catalog.left(json, json) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.left($1::text, $2::number)';

-- bit bool compare
CREATE OR REPLACE FUNCTION pg_catalog.bool_bit_gt(boolean, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int > $2::int)';
CREATE OPERATOR pg_catalog.>(leftarg = boolean, rightarg = bit, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.bool_bit_gt);
CREATE OR REPLACE FUNCTION pg_catalog.bool_bit_ge(boolean, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int >= $2::int)';
CREATE OPERATOR pg_catalog.>=(leftarg = boolean, rightarg = bit, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.bool_bit_ge);
CREATE OR REPLACE FUNCTION pg_catalog.bool_bit_lt(boolean, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int < $2::int)';
CREATE OPERATOR pg_catalog.<(leftarg = boolean, rightarg = bit, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.bool_bit_lt);
CREATE OR REPLACE FUNCTION pg_catalog.bool_bit_le(boolean, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int <= $2::int)';
CREATE OPERATOR pg_catalog.<=(leftarg = boolean, rightarg = bit, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.bool_bit_le);
CREATE OR REPLACE FUNCTION pg_catalog.bit_bool_gt(bit, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int > $2::int)';
CREATE OPERATOR pg_catalog.>(leftarg = bit, rightarg = boolean, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.bit_bool_gt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_bool_ge(bit, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int >= $2::int)';
CREATE OPERATOR pg_catalog.>=(leftarg = bit, rightarg = boolean, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.bit_bool_ge);
CREATE OR REPLACE FUNCTION pg_catalog.bit_bool_lt(bit, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int < $2::int)';
CREATE OPERATOR pg_catalog.<(leftarg = bit, rightarg = boolean, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.bit_bool_lt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_bool_le(bit, boolean) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::int <= $2::int)';
CREATE OPERATOR pg_catalog.<=(leftarg = bit, rightarg = boolean, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.bit_bool_le);
-- bit date compare
CREATE OR REPLACE FUNCTION pg_catalog.date_bit_gt(date, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 > $2::float4)';
CREATE OPERATOR pg_catalog.>(leftarg = date, rightarg = bit, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.date_bit_gt);
CREATE OR REPLACE FUNCTION pg_catalog.date_bit_ge(date, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 >= $2::float4)';
CREATE OPERATOR pg_catalog.>=(leftarg = date, rightarg = bit, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.date_bit_ge);
CREATE OR REPLACE FUNCTION pg_catalog.date_bit_lt(date, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 < $2::float4)';
CREATE OPERATOR pg_catalog.<(leftarg = date, rightarg = bit, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.date_bit_lt);
CREATE OR REPLACE FUNCTION pg_catalog.date_bit_le(date, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 <= $2::float4)';
CREATE OPERATOR pg_catalog.<=(leftarg = date, rightarg = bit, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.date_bit_le);
CREATE OR REPLACE FUNCTION pg_catalog.bit_date_gt(bit, date) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 > $2::float4)';
CREATE OPERATOR pg_catalog.>(leftarg = bit, rightarg = date, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.bit_date_gt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_date_ge(bit, date) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 >= $2::float4)';
CREATE OPERATOR pg_catalog.>=(leftarg = bit, rightarg = date, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.bit_date_ge);
CREATE OR REPLACE FUNCTION pg_catalog.bit_date_lt(bit, date) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 < $2::float4)';
CREATE OPERATOR pg_catalog.<(leftarg = bit, rightarg = date, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.bit_date_lt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_date_le(bit, date) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 <= $2::float4)';
CREATE OPERATOR pg_catalog.<=(leftarg = bit, rightarg = date, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.bit_date_le);
-- bit timestamp without time zone compare
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_bit_gt(timestamp without time zone, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 > $2::float4)';
CREATE OPERATOR pg_catalog.>(leftarg = timestamp without time zone, rightarg = bit, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.timestamp_bit_gt);
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_bit_ge(timestamp without time zone, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 >= $2::float4)';
CREATE OPERATOR pg_catalog.>=(leftarg = timestamp without time zone, rightarg = bit, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.timestamp_bit_ge);
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_bit_lt(timestamp without time zone, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 < $2::float4)';
CREATE OPERATOR pg_catalog.<(leftarg = timestamp without time zone, rightarg = bit, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.timestamp_bit_lt);
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_bit_le(timestamp without time zone, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 <= $2::float4)';
CREATE OPERATOR pg_catalog.<=(leftarg = timestamp without time zone, rightarg = bit, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.timestamp_bit_le);
CREATE OR REPLACE FUNCTION pg_catalog.bit_timestamp_gt(bit, timestamp without time zone) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 > $2::float4)';
CREATE OPERATOR pg_catalog.>(leftarg = bit, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.bit_timestamp_gt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_timestamp_ge(bit, timestamp without time zone) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 >= $2::float4)';
CREATE OPERATOR pg_catalog.>=(leftarg = bit, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.bit_timestamp_ge);
CREATE OR REPLACE FUNCTION pg_catalog.bit_timestamp_lt(bit, timestamp without time zone) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 < $2::float4)';
CREATE OPERATOR pg_catalog.<(leftarg = bit, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.bit_timestamp_lt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_timestamp_le(bit, timestamp without time zone) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 <= $2::float4)';
CREATE OPERATOR pg_catalog.<=(leftarg = bit, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.bit_timestamp_le);
-- bit timestamp with time zone
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_bit_gt(timestamp with time zone, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 > $2::float4)';
CREATE OPERATOR pg_catalog.>(leftarg = timestamp with time zone, rightarg = bit, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.timestamptz_bit_gt);
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_bit_ge(timestamp with time zone, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 >= $2::float4)';
CREATE OPERATOR pg_catalog.>=(leftarg = timestamp with time zone, rightarg = bit, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.timestamptz_bit_ge);
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_bit_lt(timestamp with time zone, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 < $2::float4)';
CREATE OPERATOR pg_catalog.<(leftarg = timestamp with time zone, rightarg = bit, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.timestamptz_bit_lt);
CREATE OR REPLACE FUNCTION pg_catalog.timestamptz_bit_le(timestamp with time zone, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 <= $2::float4)';
CREATE OPERATOR pg_catalog.<=(leftarg = timestamp with time zone, rightarg = bit, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.timestamptz_bit_le);
CREATE OR REPLACE FUNCTION pg_catalog.bit_timestamptz_gt(bit, timestamp with time zone) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 > $2::float4)';
CREATE OPERATOR pg_catalog.>(leftarg = bit, rightarg = timestamp with time zone, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.bit_timestamptz_gt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_timestamptz_ge(bit, timestamp with time zone) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 >= $2::float4)';
CREATE OPERATOR pg_catalog.>=(leftarg = bit, rightarg = timestamp with time zone, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.bit_timestamptz_ge);
CREATE OR REPLACE FUNCTION pg_catalog.bit_timestamptz_lt(bit, timestamp with time zone) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 < $2::float4)';
CREATE OPERATOR pg_catalog.<(leftarg = bit, rightarg = timestamp with time zone, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.bit_timestamptz_lt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_timestamptz_le(bit, timestamp with time zone) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 <= $2::float4)';
CREATE OPERATOR pg_catalog.<=(leftarg = bit, rightarg = timestamp with time zone, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.bit_timestamptz_le);
-- bit year compare
CREATE OR REPLACE FUNCTION pg_catalog.year_bit_gt(year, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 > $2::float4)';
CREATE OPERATOR pg_catalog.>(leftarg = year, rightarg = bit, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.year_bit_gt);
CREATE OR REPLACE FUNCTION pg_catalog.year_bit_ge(year, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 >= $2::float4)';
CREATE OPERATOR pg_catalog.>=(leftarg = year, rightarg = bit, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.year_bit_ge);
CREATE OR REPLACE FUNCTION pg_catalog.year_bit_lt(year, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 < $2::float4)';
CREATE OPERATOR pg_catalog.<(leftarg = year, rightarg = bit, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.year_bit_lt);
CREATE OR REPLACE FUNCTION pg_catalog.year_bit_le(year, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 <= $2::float4)';
CREATE OPERATOR pg_catalog.<=(leftarg = year, rightarg = bit, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.year_bit_le);
CREATE OR REPLACE FUNCTION pg_catalog.bit_year_gt(bit, year) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 > $2::float4)';
CREATE OPERATOR pg_catalog.>(leftarg = bit, rightarg = year, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.bit_year_gt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_year_ge(bit, year) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 >= $2::float4)';
CREATE OPERATOR pg_catalog.>=(leftarg = bit, rightarg = year, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.bit_year_ge);
CREATE OR REPLACE FUNCTION pg_catalog.bit_year_lt(bit, year) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 < $2::float4)';
CREATE OPERATOR pg_catalog.<(leftarg = bit, rightarg = year, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.bit_year_lt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_year_le(bit, year) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 <= $2::float4)';
CREATE OPERATOR pg_catalog.<=(leftarg = bit, rightarg = year, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.bit_year_le);
-- bit time compare
CREATE OR REPLACE FUNCTION pg_catalog.time_bit_gt(time, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 > $2::float4)';
CREATE OPERATOR pg_catalog.>(leftarg = time, rightarg = bit, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.time_bit_gt);
CREATE OR REPLACE FUNCTION pg_catalog.time_bit_ge(time, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 >= $2::float4)';
CREATE OPERATOR pg_catalog.>=(leftarg = time, rightarg = bit, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.time_bit_ge);
CREATE OR REPLACE FUNCTION pg_catalog.time_bit_lt(time, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 < $2::float4)';
CREATE OPERATOR pg_catalog.<(leftarg = time, rightarg = bit, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.time_bit_lt);
CREATE OR REPLACE FUNCTION pg_catalog.time_bit_le(time, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 <= $2::float4)';
CREATE OPERATOR pg_catalog.<=(leftarg = time, rightarg = bit, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.time_bit_le);
CREATE OR REPLACE FUNCTION pg_catalog.bit_time_gt(bit, time) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 > $2::float4)';
CREATE OPERATOR pg_catalog.>(leftarg = bit, rightarg = time, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.bit_time_gt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_time_ge(bit, time) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 >= $2::float4)';
CREATE OPERATOR pg_catalog.>=(leftarg = bit, rightarg = time, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.bit_time_ge);
CREATE OR REPLACE FUNCTION pg_catalog.bit_time_lt(bit, time) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 < $2::float4)';
CREATE OPERATOR pg_catalog.<(leftarg = bit, rightarg = time, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.bit_time_lt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_time_le(bit, time) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 <= $2::float4)';
CREATE OPERATOR pg_catalog.<=(leftarg = bit, rightarg = time, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.bit_time_le);
-- bit uint8 compare
CREATE OR REPLACE FUNCTION pg_catalog.uint8_bit_gt(uint8, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 > $2::float4)';
CREATE OPERATOR pg_catalog.>(leftarg = uint8, rightarg = bit, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.uint8_bit_gt);
CREATE OR REPLACE FUNCTION pg_catalog.uint8_bit_ge(uint8, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 >= $2::float4)';
CREATE OPERATOR pg_catalog.>=(leftarg = uint8, rightarg = bit, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.uint8_bit_ge);
CREATE OR REPLACE FUNCTION pg_catalog.uint8_bit_lt(uint8, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 < $2::float4)';
CREATE OPERATOR pg_catalog.<(leftarg = uint8, rightarg = bit, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.uint8_bit_lt);
CREATE OR REPLACE FUNCTION pg_catalog.uint8_bit_le(uint8, bit) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 <= $2::float4)';
CREATE OPERATOR pg_catalog.<=(leftarg = uint8, rightarg = bit, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.uint8_bit_le);
CREATE OR REPLACE FUNCTION pg_catalog.bit_uint8_gt(bit, uint8) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 > $2::float4)';
CREATE OPERATOR pg_catalog.>(leftarg = bit, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.bit_uint8_gt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_uint8_ge(bit, uint8) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 >= $2::float4)';
CREATE OPERATOR pg_catalog.>=(leftarg = bit, rightarg = uint8, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.bit_uint8_ge);
CREATE OR REPLACE FUNCTION pg_catalog.bit_uint8_lt(bit, uint8) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 < $2::float4)';
CREATE OPERATOR pg_catalog.<(leftarg = bit, rightarg = uint8, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.bit_uint8_lt);
CREATE OR REPLACE FUNCTION pg_catalog.bit_uint8_le(bit, uint8) returns bool LANGUAGE SQL IMMUTABLE STRICT as 'select ($1::float4 <= $2::float4)';
CREATE OPERATOR pg_catalog.<=(leftarg = bit, rightarg = uint8, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.bit_uint8_le);

DO $for_upgrade_only$
DECLARE
  ans boolean;
  v_isinplaceupgrade boolean;
BEGIN
    select case when count(*)=1 then true else false end as ans from (select setting from pg_settings where name = 'upgrade_mode' and setting != '0') into ans;
    show isinplaceupgrade into v_isinplaceupgrade;
    -- we can do drop operator only during upgrade. Just for 6.0.0-RC1
    if ans = true and v_isinplaceupgrade = true then
        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 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);
    end if;
END
$for_upgrade_only$;

CREATE OR REPLACE FUNCTION pg_catalog.mod(binary,int8) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(binary,bit) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(binary,year) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(binary,binary) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(binary,varbinary) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(int8,binary) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(bit,binary) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(year,binary) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(varbinary,varbinary) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(varbinary,binary) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(varbinary,int8) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(varbinary,bit) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(varbinary,year) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(int8,varbinary) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(bit,varbinary) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';
CREATE OR REPLACE FUNCTION pg_catalog.mod(year,varbinary) RETURNS number LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.mod(cast($1 as number), cast($2 as number))';

DO $for_og_502$
BEGIN
    -- workering_version_num of openGauss5.0.1 is 92854, openGauss5.1.0 is 92913.
    if working_version_num() < 92855 or working_version_num() >= 92913 then
        CREATE OR REPLACE FUNCTION pg_catalog.datetime_text_eq(arg1 timestamp without time zone, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::timestamp without time zone';
        CREATE OR REPLACE FUNCTION pg_catalog.datetime_text_ne(arg1 timestamp without time zone, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::timestamp without time zone';
        CREATE OR REPLACE FUNCTION pg_catalog.datetime_text_lt(arg1 timestamp without time zone, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::timestamp without time zone';
        CREATE OR REPLACE FUNCTION pg_catalog.datetime_text_le(arg1 timestamp without time zone, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::timestamp without time zone';
        CREATE OR REPLACE FUNCTION pg_catalog.datetime_text_gt(arg1 timestamp without time zone, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::timestamp without time zone';
        CREATE OR REPLACE FUNCTION pg_catalog.datetime_text_ge(arg1 timestamp without time zone, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::timestamp without time zone';
        CREATE OPERATOR pg_catalog.=(leftarg = timestamp without time zone, rightarg = text, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.datetime_text_eq);
        CREATE OPERATOR pg_catalog.<>(leftarg = timestamp without time zone, rightarg = text, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.datetime_text_ne);
        CREATE OPERATOR pg_catalog.<(leftarg = timestamp without time zone, rightarg = text, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.datetime_text_lt);
        CREATE OPERATOR pg_catalog.<=(leftarg = timestamp without time zone, rightarg = text, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.datetime_text_le);
        CREATE OPERATOR pg_catalog.>(leftarg = timestamp without time zone, rightarg = text, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.datetime_text_gt);
        CREATE OPERATOR pg_catalog.>=(leftarg = timestamp without time zone, rightarg = text, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.datetime_text_ge);

        CREATE OR REPLACE FUNCTION pg_catalog.text_datetime_eq(arg1 text, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::timestamp without time zone=$2';
        CREATE OR REPLACE FUNCTION pg_catalog.text_datetime_ne(arg1 text, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::timestamp without time zone<>$2';
        CREATE OR REPLACE FUNCTION pg_catalog.text_datetime_lt(arg1 text, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::timestamp without time zone<$2';
        CREATE OR REPLACE FUNCTION pg_catalog.text_datetime_le(arg1 text, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::timestamp without time zone<=$2';
        CREATE OR REPLACE FUNCTION pg_catalog.text_datetime_gt(arg1 text, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::timestamp without time zone>$2';
        CREATE OR REPLACE FUNCTION pg_catalog.text_datetime_ge(arg1 text, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::timestamp without time zone>=$2';
        CREATE OPERATOR pg_catalog.=(leftarg = text, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.text_datetime_eq);
        CREATE OPERATOR pg_catalog.<>(leftarg = text, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.text_datetime_ne);
        CREATE OPERATOR pg_catalog.<(leftarg = text, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.text_datetime_lt);
        CREATE OPERATOR pg_catalog.<=(leftarg = text, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.text_datetime_le);
        CREATE OPERATOR pg_catalog.>(leftarg = text, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.text_datetime_gt);
        CREATE OPERATOR pg_catalog.>=(leftarg = text, rightarg = timestamp without time zone, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.text_datetime_ge);

        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_eq(arg1 timestamptz, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=$2::timestamptz';
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_ne(arg1 timestamptz, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>$2::timestamptz';
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_lt(arg1 timestamptz, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<$2::timestamptz';
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_le(arg1 timestamptz, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=$2::timestamptz';
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_gt(arg1 timestamptz, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>$2::timestamptz';
        CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_ge(arg1 timestamptz, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=$2::timestamptz';
        CREATE OPERATOR pg_catalog.=(leftarg = timestamptz, rightarg = text, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.timestamp_text_eq);
        CREATE OPERATOR pg_catalog.<>(leftarg = timestamptz, rightarg = text, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.timestamp_text_ne);
        CREATE OPERATOR pg_catalog.<(leftarg = timestamptz, rightarg = text, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.timestamp_text_lt);
        CREATE OPERATOR pg_catalog.<=(leftarg = timestamptz, rightarg = text, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.timestamp_text_le);
        CREATE OPERATOR pg_catalog.>(leftarg = timestamptz, rightarg = text, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.timestamp_text_gt);
        CREATE OPERATOR pg_catalog.>=(leftarg = timestamptz, rightarg = text, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.timestamp_text_ge);

        CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_eq(arg1 text, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT as 'select $1::timestamptz=$2';
        CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_ne(arg1 text, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::timestamptz<>$2';
        CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_lt(arg1 text, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::timestamptz<$2';
        CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_le(arg1 text, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::timestamptz<=$2';
        CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_gt(arg1 text, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::timestamptz>$2';
        CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_ge(arg1 text, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1::timestamptz>=$2';
        CREATE OPERATOR pg_catalog.=(leftarg = text, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.=), procedure = pg_catalog.text_timestamp_eq);
        CREATE OPERATOR pg_catalog.<>(leftarg = text, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<>), procedure = pg_catalog.text_timestamp_ne);
        CREATE OPERATOR pg_catalog.<(leftarg = text, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.>), procedure = pg_catalog.text_timestamp_lt);
        CREATE OPERATOR pg_catalog.<=(leftarg = text, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.>=), procedure = pg_catalog.text_timestamp_le);
        CREATE OPERATOR pg_catalog.>(leftarg = text, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<), procedure = pg_catalog.text_timestamp_gt);
        CREATE OPERATOR pg_catalog.>=(leftarg = text, rightarg = timestamptz, COMMUTATOR = operator(pg_catalog.<=), procedure = pg_catalog.text_timestamp_ge);
    end if;
END
$for_og_502$;

CREATE OR REPLACE FUNCTION pg_catalog.convert_text_datetime(text) RETURNS timestamp without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'convert_text_datetime';
CREATE OR REPLACE FUNCTION pg_catalog.convert_text_timestamptz(text) RETURNS timestamptz LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'convert_text_timestamptz';

CREATE OR REPLACE FUNCTION pg_catalog.datetime_text_eq(arg1 timestamp without time zone, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=convert_text_datetime($2)';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_text_ne(arg1 timestamp without time zone, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>convert_text_datetime($2)';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_text_lt(arg1 timestamp without time zone, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<convert_text_datetime($2)';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_text_le(arg1 timestamp without time zone, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=convert_text_datetime($2)';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_text_gt(arg1 timestamp without time zone, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>convert_text_datetime($2)';
CREATE OR REPLACE FUNCTION pg_catalog.datetime_text_ge(arg1 timestamp without time zone, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=convert_text_datetime($2)';

CREATE OR REPLACE FUNCTION pg_catalog.text_datetime_eq(arg1 text, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select convert_text_datetime($1)=$2';
CREATE OR REPLACE FUNCTION pg_catalog.text_datetime_ne(arg1 text, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select convert_text_datetime($1)<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.text_datetime_lt(arg1 text, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select convert_text_datetime($1)<$2';
CREATE OR REPLACE FUNCTION pg_catalog.text_datetime_le(arg1 text, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select convert_text_datetime($1)<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.text_datetime_gt(arg1 text, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select convert_text_datetime($1)>$2';
CREATE OR REPLACE FUNCTION pg_catalog.text_datetime_ge(arg1 text, arg2 timestamp without time zone) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select convert_text_datetime($1)>=$2';

CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_eq(arg1 timestamptz, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1=convert_text_timestamptz($2)';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_ne(arg1 timestamptz, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<>convert_text_timestamptz($2)';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_lt(arg1 timestamptz, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<convert_text_timestamptz($2)';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_le(arg1 timestamptz, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1<=convert_text_timestamptz($2)';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_gt(arg1 timestamptz, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>convert_text_timestamptz($2)';
CREATE OR REPLACE FUNCTION pg_catalog.timestamp_text_ge(arg1 timestamptz, arg2 text) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select $1>=convert_text_timestamptz($2)';

CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_eq(arg1 text, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select convert_text_timestamptz($1)=$2';
CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_ne(arg1 text, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select convert_text_timestamptz($1)<>$2';
CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_lt(arg1 text, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select convert_text_timestamptz($1)<$2';
CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_le(arg1 text, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select convert_text_timestamptz($1)<=$2';
CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_gt(arg1 text, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select convert_text_timestamptz($1)>$2';
CREATE OR REPLACE FUNCTION pg_catalog.text_timestamp_ge(arg1 text, arg2 timestamptz) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'select convert_text_timestamptz($1)>=$2';

CREATE FUNCTION pg_catalog.enumtext_like(anyenum, text) returns bool LANGUAGE SQL IMMUTABLE as 'select $1::text like $2';
CREATE FUNCTION pg_catalog.textenum_like(text, anyenum) returns bool LANGUAGE SQL IMMUTABLE as 'select $1 like $2::text';
CREATE FUNCTION pg_catalog.enumtext_nlike(anyenum, text) returns bool LANGUAGE SQL IMMUTABLE as 'select $1::text not like $2';
CREATE FUNCTION pg_catalog.textenum_nlike(text, anyenum) returns bool LANGUAGE SQL IMMUTABLE as 'select $1 not like $2::text';
CREATE OPERATOR pg_catalog.~~(leftarg = anyenum, rightarg = text, procedure = pg_catalog.enumtext_like);
CREATE OPERATOR pg_catalog.~~(leftarg = text, rightarg = anyenum, procedure = pg_catalog.textenum_like);
CREATE OPERATOR pg_catalog.!~~(leftarg = anyenum, rightarg = text, procedure = pg_catalog.enumtext_nlike);
CREATE OPERATOR pg_catalog.!~~(leftarg = text, rightarg = anyenum, procedure = pg_catalog.textenum_nlike);

CREATE FUNCTION pg_catalog.blob_to_float8(blob) RETURNS double precision LANGUAGE C IMMUTABLE STRICT AS '$libdir/dolphin', 'blob_to_float8';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_float8_eq(arg1 tinyblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.float8_tinyblob_eq(arg1 float8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_float8_eq(arg1 mediumblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.float8_mediumblob_eq(arg1 float8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';
CREATE OR REPLACE FUNCTION pg_catalog.blob_float8_eq(arg1 blob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.float8_blob_eq(arg1 float8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_float8_eq(arg1 longblob, arg2 float8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.float8_longblob_eq(arg1 float8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';

CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_numeric_eq(arg1 tinyblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_tinyblob_eq(arg1 numeric, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_numeric_eq(arg1 mediumblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_mediumblob_eq(arg1 numeric, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';
CREATE OR REPLACE FUNCTION pg_catalog.blob_numeric_eq(arg1 blob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_blob_eq(arg1 numeric, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_numeric_eq(arg1 longblob, arg2 numeric) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_longblob_eq(arg1 numeric, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';

CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_uint8_eq(arg1 tinyblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_tinyblob_eq(arg1 uint8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_uint8_eq(arg1 mediumblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_mediumblob_eq(arg1 uint8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';
CREATE OR REPLACE FUNCTION pg_catalog.blob_uint8_eq(arg1 blob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_blob_eq(arg1 uint8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_uint8_eq(arg1 longblob, arg2 uint8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.uint8_longblob_eq(arg1 uint8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';

CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_int8_eq(arg1 tinyblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.int8_tinyblob_eq(arg1 int8, arg2 tinyblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_int8_eq(arg1 mediumblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.int8_mediumblob_eq(arg1 int8, arg2 mediumblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';
CREATE OR REPLACE FUNCTION pg_catalog.blob_int8_eq(arg1 blob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.int8_blob_eq(arg1 int8, arg2 blob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_int8_eq(arg1 longblob, arg2 int8) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT pg_catalog.blob_to_float8($1) = $2';
CREATE OR REPLACE FUNCTION pg_catalog.int8_longblob_eq(arg1 int8, arg2 longblob) RETURNS bool LANGUAGE SQL IMMUTABLE STRICT AS 'SELECT $1 = pg_catalog.blob_to_float8($2)';

CREATE FUNCTION pg_catalog.text_to_tinyblob(text) RETURNS tinyblob LANGUAGE C IMMUTABLE STRICT AS '$libdir/dolphin', 'text_to_blob';
CREATE FUNCTION pg_catalog.text_to_blob(text) RETURNS blob LANGUAGE C IMMUTABLE STRICT AS '$libdir/dolphin', 'text_to_blob';
CREATE FUNCTION pg_catalog.text_to_mediumblob(text) RETURNS mediumblob LANGUAGE C IMMUTABLE STRICT AS '$libdir/dolphin', 'text_to_blob';
CREATE FUNCTION pg_catalog.text_to_longblob(text) RETURNS longblob LANGUAGE C IMMUTABLE STRICT AS '$libdir/dolphin', 'text_to_blob';
CREATE CAST (text AS tinyblob) WITH FUNCTION pg_catalog.text_to_tinyblob(text);
CREATE CAST (text AS blob) WITH FUNCTION pg_catalog.text_to_blob(text);
CREATE CAST (text AS mediumblob) WITH FUNCTION pg_catalog.text_to_mediumblob(text);
CREATE CAST (text AS longblob) WITH FUNCTION pg_catalog.text_to_longblob(text);

DO $for_upgrade_only$
DECLARE
  ans boolean;
  typ_check boolean;
  v_isinplaceupgrade boolean;
BEGIN
    select case when count(*)=1 then true else false end as ans from (select setting from pg_settings where name = 'upgrade_mode' and setting != '0') into ans;
    select case when a.oid<>b.typarray then true else false end as typ_check from pg_type a, pg_type b where (a.typname='_uint1' and b.typname='uint1') into typ_check;
    show isinplaceupgrade into v_isinplaceupgrade;
    -- we can do drop type only during upgrade
    if ans = true and v_isinplaceupgrade = true and typ_check = true then
        DROP TYPE IF EXISTS pg_catalog._uint1 cascade;
        DROP TYPE IF EXISTS pg_catalog._uint2 cascade;
        DROP TYPE IF EXISTS pg_catalog._uint4 cascade;
        DROP TYPE IF EXISTS pg_catalog._uint8 cascade;
        update pg_catalog.pg_type set typname = '_uint1' where typname = '_uint1_1';
        update pg_catalog.pg_type set typname = '_uint2' where typname = '_uint2_1';
        update pg_catalog.pg_type set typname = '_uint4' where typname = '_uint4_1';
        update pg_catalog.pg_type set typname = '_uint8' where typname = '_uint8_1';
    end if;
END
$for_upgrade_only$;

CREATE OPERATOR CLASS pg_catalog.uint1_ops
    DEFAULT FOR TYPE uint1 USING ubtree family pg_catalog.integer_ops AS
        OPERATOR        1       pg_catalog.< ,
        OPERATOR        1       pg_catalog.<(uint1, uint2),
        OPERATOR        1       pg_catalog.<(uint1, uint4),
        OPERATOR        1       pg_catalog.<(uint1, uint8),
        OPERATOR        1       pg_catalog.<(uint1, int1),
        OPERATOR        1       pg_catalog.<(uint1, int2),
        OPERATOR        1       pg_catalog.<(uint1, int4),
        OPERATOR        1       pg_catalog.<(uint1, int8),
        OPERATOR        2       pg_catalog.<= ,
        OPERATOR        2       pg_catalog.<=(uint1, uint2),
        OPERATOR        2       pg_catalog.<=(uint1, uint4),
        OPERATOR        2       pg_catalog.<=(uint1, uint8),
        OPERATOR        2       pg_catalog.<=(uint1, int1),
        OPERATOR        2       pg_catalog.<=(uint1, int2),
        OPERATOR        2       pg_catalog.<=(uint1, int4),
        OPERATOR        2       pg_catalog.<=(uint1, int8),
        OPERATOR        3       pg_catalog.= ,
        OPERATOR        3       pg_catalog.=(uint1, uint2),
        OPERATOR        3       pg_catalog.=(uint1, uint4),
        OPERATOR        3       pg_catalog.=(uint1, uint8),
        OPERATOR        3       pg_catalog.=(uint1, int1),
        OPERATOR        3       pg_catalog.=(uint1, int2),
        OPERATOR        3       pg_catalog.=(uint1, int4),
        OPERATOR        3       pg_catalog.=(uint1, int8),
        OPERATOR        4       pg_catalog.>= ,
        OPERATOR        4       pg_catalog.>=(uint1, uint2),
        OPERATOR        4       pg_catalog.>=(uint1, uint4),
        OPERATOR        4       pg_catalog.>=(uint1, uint8),
        OPERATOR        4       pg_catalog.>=(uint1, int1),
        OPERATOR        4       pg_catalog.>=(uint1, int2),
        OPERATOR        4       pg_catalog.>=(uint1, int4),
        OPERATOR        4       pg_catalog.>=(uint1, int8),
        OPERATOR        5       pg_catalog.> ,
        OPERATOR        5       pg_catalog.>(uint1, uint2),
        OPERATOR        5       pg_catalog.>(uint1, uint4),
        OPERATOR        5       pg_catalog.>(uint1, uint8),
        OPERATOR        5       pg_catalog.>(uint1, int1),
        OPERATOR        5       pg_catalog.>(uint1, int2),
        OPERATOR        5       pg_catalog.>(uint1, int4),
        OPERATOR        5       pg_catalog.>(uint1, int8),
        FUNCTION        1       pg_catalog.uint1cmp(uint1, uint1),
        FUNCTION        1       pg_catalog.uint12cmp(uint1, uint2),
        FUNCTION        1       pg_catalog.uint14cmp(uint1, uint4),
        FUNCTION        1       pg_catalog.uint18cmp(uint1, uint8),
        FUNCTION        1       pg_catalog.uint1_int1cmp(uint1, int1),
        FUNCTION        1       pg_catalog.uint1_int2cmp(uint1, int2),
        FUNCTION        1       pg_catalog.uint1_int4cmp(uint1, int4),
        FUNCTION        1       pg_catalog.uint1_int8cmp(uint1, int8),
        FUNCTION        2       pg_catalog.uint1_sortsupport(internal);

CREATE OPERATOR CLASS pg_catalog.uint2_ops
    DEFAULT FOR TYPE uint2 USING ubtree family pg_catalog.integer_ops AS
        OPERATOR        1       pg_catalog.< ,
        OPERATOR        1       pg_catalog.<(uint2, uint4),
        OPERATOR        1       pg_catalog.<(uint2, uint8),
        OPERATOR        1       pg_catalog.<(uint2, int2),
        OPERATOR        1       pg_catalog.<(uint2, int4),
        OPERATOR        1       pg_catalog.<(uint2, int8),
        OPERATOR        2       pg_catalog.<= ,
        OPERATOR        2       pg_catalog.<=(uint2, uint4),
        OPERATOR        2       pg_catalog.<=(uint2, uint8),
        OPERATOR        2       pg_catalog.<=(uint2, int2),
        OPERATOR        2       pg_catalog.<=(uint2, int4),
        OPERATOR        2       pg_catalog.<=(uint2, int8),
        OPERATOR        3       pg_catalog.= ,
        OPERATOR        3       pg_catalog.=(uint2, uint4),
        OPERATOR        3       pg_catalog.=(uint2, uint8),
        OPERATOR        3       pg_catalog.=(uint2, int2),
        OPERATOR        3       pg_catalog.=(uint2, int4),
        OPERATOR        3       pg_catalog.=(uint2, int8),
        OPERATOR        4       pg_catalog.>= ,
        OPERATOR        4       pg_catalog.>=(uint2, uint4),
        OPERATOR        4       pg_catalog.>=(uint2, uint8),
        OPERATOR        4       pg_catalog.>=(uint2, int2),
        OPERATOR        4       pg_catalog.>=(uint2, int4),
        OPERATOR        4       pg_catalog.>=(uint2, int8),
        OPERATOR        5       pg_catalog.> ,
        OPERATOR        5       pg_catalog.>(uint2, uint4),
        OPERATOR        5       pg_catalog.>(uint2, uint8),
        OPERATOR        5       pg_catalog.>(uint2, int2),
        OPERATOR        5       pg_catalog.>(uint2, int4),
        OPERATOR        5       pg_catalog.>(uint2, int8),
        FUNCTION        1       pg_catalog.uint2cmp(uint2, uint2),
        FUNCTION        1       pg_catalog.uint24cmp(uint2, uint4),
        FUNCTION        1       pg_catalog.uint28cmp(uint2, uint8),
        FUNCTION        1       pg_catalog.uint2_int2cmp(uint2, int2),
        FUNCTION        1       pg_catalog.uint2_int4cmp(uint2, int4),
        FUNCTION        1       pg_catalog.uint2_int8cmp(uint2, int8),
        FUNCTION        2       pg_catalog.uint2_sortsupport(internal);

CREATE OPERATOR CLASS pg_catalog.uint4_ops
    DEFAULT FOR TYPE uint4 USING ubtree family pg_catalog.integer_ops AS
        OPERATOR        1       pg_catalog.< ,
        OPERATOR        1       pg_catalog.<(uint4, uint8),
        OPERATOR        1       pg_catalog.<(uint4, int4),
        OPERATOR        1       pg_catalog.<(uint4, int8),
        OPERATOR        2       pg_catalog.<= ,
        OPERATOR        2       pg_catalog.<=(uint4, uint8),
        OPERATOR        2       pg_catalog.<=(uint4, int4),
        OPERATOR        2       pg_catalog.<=(uint4, int8),
        OPERATOR        3       pg_catalog.= ,
        OPERATOR        3       pg_catalog.=(uint4, uint8),
        OPERATOR        3       pg_catalog.=(uint4, int4),
        OPERATOR        3       pg_catalog.=(uint4, int8),
        OPERATOR        4       pg_catalog.>= ,
        OPERATOR        4       pg_catalog.>=(uint4, uint8),
        OPERATOR        4       pg_catalog.>=(uint4, int4),
        OPERATOR        4       pg_catalog.>=(uint4, int8),
        OPERATOR        5       pg_catalog.> ,
        OPERATOR        5       pg_catalog.>(uint4, uint8),
        OPERATOR        5       pg_catalog.>(uint4, int4),
        OPERATOR        5       pg_catalog.>(uint4, int8),
        FUNCTION        1       pg_catalog.uint4cmp(uint4, uint4),
        FUNCTION        1       pg_catalog.uint48cmp(uint4, uint8),
        FUNCTION        1       pg_catalog.uint4_int4cmp(uint4, int4),
        FUNCTION        1       pg_catalog.uint4_int8cmp(uint4, int8),
        FUNCTION        2       pg_catalog.uint4_sortsupport(internal);

CREATE OPERATOR CLASS pg_catalog.uint8_ops
    DEFAULT FOR TYPE uint8 USING ubtree family pg_catalog.integer_ops AS
        OPERATOR        1       pg_catalog.< ,
        OPERATOR        1       pg_catalog.<(uint8, int8),
        OPERATOR        2       pg_catalog.<= ,
        OPERATOR        2       pg_catalog.<=(uint8, int8),
        OPERATOR        3       pg_catalog.= ,
        OPERATOR        3       pg_catalog.=(uint8, int8),
        OPERATOR        4       pg_catalog.>= ,
        OPERATOR        4       pg_catalog.>=(uint8, int8),
        OPERATOR        5       pg_catalog.> ,
        OPERATOR        5       pg_catalog.>(uint8, int8),
        FUNCTION        1       pg_catalog.uint8cmp(uint8, uint8),
        FUNCTION        1       pg_catalog.uint8_int8cmp(uint8, int8),
        FUNCTION        2       pg_catalog.uint8_sortsupport(internal);

CREATE OPERATOR CLASS pg_catalog.year_ops
    DEFAULT FOR TYPE year USING ubtree AS
        OPERATOR        1       < ,
        OPERATOR        2       <= ,
        OPERATOR        3       = ,
        OPERATOR        4       >= ,
        OPERATOR        5       > ,
        FUNCTION        1       year_cmp(year, year),
        FUNCTION        2       year_sortsupport(internal);

DROP FUNCTION IF EXISTS pg_catalog.chara(variadic arr "any") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.chara(variadic arr "any") returns varbinary LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'm_char';

CREATE OR REPLACE FUNCTION pg_catalog.lpad(boolean, integer, text) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.lpad($1::text, $2, $3)::varchar';
CREATE OR REPLACE FUNCTION pg_catalog.lpad(bit, integer, text) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'lpad_bit';
CREATE OR REPLACE FUNCTION pg_catalog.lpad(binary, integer, text) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'lpad_bin';
CREATE OR REPLACE FUNCTION pg_catalog.lpad(varbinary, integer, text) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'lpad_bin';

DROP FUNCTION IF EXISTS pg_catalog.quarter (timestamptz);
DROP FUNCTION IF EXISTS pg_catalog.quarter (timetz);
DROP FUNCTION IF EXISTS pg_catalog.quarter (abstime);
DROP FUNCTION IF EXISTS pg_catalog.quarter (date);
DROP FUNCTION IF EXISTS pg_catalog.quarter (time);
DROP FUNCTION IF EXISTS pg_catalog.quarter (timestamp(0) with time zone);
CREATE OR REPLACE FUNCTION pg_catalog.quarter (timestamptz) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)::integer';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (timetz) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)::integer';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (abstime) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)::integer';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (date) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)::integer';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (time) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)::integer';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (timestamp(0) with time zone) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''quarter'', $1)::integer';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (year) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''quarter'', cast($1 as timestamp(0) with time zone))::integer';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (binary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''quarter'', cast($1 as timestamp(0) without time zone))::integer';
CREATE OR REPLACE FUNCTION pg_catalog.quarter (text) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''quarter'', cast($1 as timestamp(0) without time zone))::integer';

DROP CAST IF EXISTS (binary AS timestamp without time zone);
DROP CAST IF EXISTS (binary AS timestamp with time zone);
CREATE OR REPLACE FUNCTION pg_catalog.binary_timestamp(binary) RETURNS timestamp without time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'binary_timestamp';
CREATE OR REPLACE FUNCTION pg_catalog.binary_timestamptz(binary) RETURNS timestamp with time zone LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'binary_timestamptz';
CREATE CAST (binary AS timestamp without time zone) WITH FUNCTION pg_catalog.binary_timestamp(binary) AS ASSIGNMENT;
CREATE CAST (binary AS timestamp with time zone) WITH FUNCTION pg_catalog.binary_timestamptz(binary) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.weekday (timestamptz);
DROP FUNCTION IF EXISTS pg_catalog.weekday (timetz);
DROP FUNCTION IF EXISTS pg_catalog.weekday (abstime);
DROP FUNCTION IF EXISTS pg_catalog.weekday (date);
DROP FUNCTION IF EXISTS pg_catalog.weekday (time);
DROP FUNCTION IF EXISTS pg_catalog.weekday (timestamp(0) with time zone);
CREATE OR REPLACE FUNCTION pg_catalog.weekday (timestamptz) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1)::integer - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (timetz) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1)::integer - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (abstime) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1)::integer - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (date) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1)::integer - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (time) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1)::integer - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (timestamp(0) with time zone) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''isodow'', $1)::integer - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (year) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''isodow'', cast($1 as timestamp(0) with time zone))::integer - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (binary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''isodow'', cast($1 as timestamp(0) with time zone))::integer - 1';
CREATE OR REPLACE FUNCTION pg_catalog.weekday (text) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''isodow'', cast($1 as timestamp(0) with time zone))::integer - 1';

DROP FUNCTION IF EXISTS pg_catalog.weekofyear (timestamptz);
DROP FUNCTION IF EXISTS pg_catalog.weekofyear (timetz);
DROP FUNCTION IF EXISTS pg_catalog.weekofyear (abstime);
DROP FUNCTION IF EXISTS pg_catalog.weekofyear (date);
DROP FUNCTION IF EXISTS pg_catalog.weekofyear (time);
DROP FUNCTION IF EXISTS pg_catalog.weekofyear (timestamp(0) with time zone);
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (timestamptz) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)::integer';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (timetz) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)::integer';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (abstime) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)::integer';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (date) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)::integer';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (time) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', cast($1 as timestamp(0) without time zone))::integer';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (timestamp(0) with time zone) RETURNS integer LANGUAGE SQL STABLE STRICT as 'select pg_catalog.date_part(''week'', $1)::integer';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (year) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''week'', cast($1 as timestamp(0) without time zone))::integer';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (binary) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''week'', cast($1 as timestamp(0) without time zone))::integer';
CREATE OR REPLACE FUNCTION pg_catalog.weekofyear (text) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_part(''week'', cast($1 as timestamp(0) without time zone))::integer';

CREATE OR REPLACE FUNCTION pg_catalog.hex(uint1) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint1_to_hex';
CREATE OR REPLACE FUNCTION pg_catalog.hex(uint2) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint2_to_hex';
CREATE OR REPLACE FUNCTION pg_catalog.hex(uint4) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint4_to_hex';
CREATE OR REPLACE FUNCTION pg_catalog.hex(uint8) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'uint8_to_hex';

-- binary
DROP AGGREGATE IF EXISTS pg_catalog.bit_and(binary);
DROP FUNCTION IF EXISTS pg_catalog.binary_and(binary, binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.binary_varbinary(binary) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.binary_and(binary, binary) RETURNS binary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'binaryand';
CREATE OR REPLACE FUNCTION pg_catalog.binary_varbinary(binary) RETURNS varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'binary_varbinary';
CREATE AGGREGATE pg_catalog.bit_and(binary) (SFUNC = pg_catalog.binary_and, STYPE = binary, FINALFUNC = binary_varbinary);
-- uint8
drop aggregate if exists pg_catalog.bit_and(uint8);
create aggregate pg_catalog.bit_and(uint8) (SFUNC=uint8and, cFUNC = uint8and, STYPE= uint8, initcond = '18446744073709551615');
-- json max/min
CREATE OR REPLACE FUNCTION pg_catalog.json_larger(json, json) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','json_larger';
CREATE OR REPLACE FUNCTION pg_catalog.json_smaller(json, json) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','json_smaller';
create aggregate pg_catalog.max(json) (SFUNC=pg_catalog.json_larger, STYPE=json);
create aggregate pg_catalog.min(json) (SFUNC=pg_catalog.json_smaller, STYPE=json);
-- tinyblob
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_larger(tinyblob, tinyblob) RETURNS tinyblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','varlena_larger';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_smaller(tinyblob, tinyblob) RETURNS tinyblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','varlena_smaller';
create aggregate pg_catalog.max(tinyblob) (SFUNC=pg_catalog.tinyblob_larger, STYPE=tinyblob);
create aggregate pg_catalog.min(tinyblob) (SFUNC=pg_catalog.tinyblob_smaller, STYPE=tinyblob);
-- blob
CREATE OR REPLACE FUNCTION pg_catalog.blob_larger(blob, blob) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','varlena_larger';
CREATE OR REPLACE FUNCTION pg_catalog.blob_smaller(blob, blob) RETURNS blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','varlena_smaller';
create aggregate pg_catalog.max(blob) (SFUNC=pg_catalog.blob_larger, STYPE=blob);
create aggregate pg_catalog.min(blob) (SFUNC=pg_catalog.blob_smaller, STYPE=blob);
-- mediumblob
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_larger(mediumblob, mediumblob) RETURNS mediumblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','varlena_larger';
CREATE OR REPLACE FUNCTION pg_catalog.mediumblob_smaller(mediumblob, mediumblob) RETURNS mediumblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','varlena_smaller';
create aggregate pg_catalog.max(mediumblob) (SFUNC=pg_catalog.mediumblob_larger, STYPE=mediumblob);
create aggregate pg_catalog.min(mediumblob) (SFUNC=pg_catalog.mediumblob_smaller, STYPE=mediumblob);
-- longblob
CREATE OR REPLACE FUNCTION pg_catalog.longblob_larger(longblob, longblob) RETURNS longblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','varlena_larger';
CREATE OR REPLACE FUNCTION pg_catalog.longblob_smaller(longblob, longblob) RETURNS longblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','varlena_smaller';
create aggregate pg_catalog.max(longblob) (SFUNC=pg_catalog.longblob_larger, STYPE=longblob);
create aggregate pg_catalog.min(longblob) (SFUNC=pg_catalog.longblob_smaller, STYPE=longblob);
-- bit
CREATE OR REPLACE FUNCTION pg_catalog.bit_larger(bit, bit) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','varbit_larger';
CREATE OR REPLACE FUNCTION pg_catalog.bit_smaller(bit, bit) RETURNS bit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','varbit_smaller';
create aggregate pg_catalog.max(bit) (SFUNC=pg_catalog.bit_larger, STYPE=bit);
create aggregate pg_catalog.min(bit) (SFUNC=pg_catalog.bit_smaller, STYPE=bit);
-- varbit
CREATE OR REPLACE FUNCTION pg_catalog.varbit_larger(varbit, varbit) RETURNS varbit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','varbit_larger';
CREATE OR REPLACE FUNCTION pg_catalog.varbit_smaller(varbit, varbit) RETURNS varbit LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','varbit_smaller';
create aggregate pg_catalog.max(varbit) (SFUNC=pg_catalog.varbit_larger, STYPE=varbit);
create aggregate pg_catalog.min(varbit) (SFUNC=pg_catalog.varbit_smaller, STYPE=varbit);

-- date +/- interval expr unit
DROP FUNCTION IF EXISTS pg_catalog.date_add (time, interval);
DROP FUNCTION IF EXISTS pg_catalog.date_sub (time, interval);
CREATE OR REPLACE FUNCTION pg_catalog.date_add (time, interval) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'date_add_time_interval';
CREATE OR REPLACE FUNCTION pg_catalog.op_time_add_intr (time, interval) RETURNS text AS $$ SELECT pg_catalog.date_add($1, $2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_time (interval, time) RETURNS text AS $$ SELECT pg_catalog.date_add($2, $1)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_sub (time, interval) RETURNS text AS $$ SELECT pg_catalog.date_add($1, -$2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_time_sub_intr (time, interval) RETURNS text AS $$ SELECT pg_catalog.date_sub($1, $2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_add(timestamp without time zone, interval) RETURNS timestamp without time zone LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'date_add_datetime_interval';
CREATE OR REPLACE FUNCTION pg_catalog.date_add(timestamptz, interval) RETURNS timestamptz LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'date_add_timestamp_interval';
CREATE OR REPLACE FUNCTION pg_catalog.date_sub(timestamp without time zone, interval) RETURNS timestamp without time zone AS $$ SELECT pg_catalog.date_add($1, -$2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_sub(timestamptz, interval) RETURNS timestamptz AS $$ SELECT pg_catalog.date_add($1, -$2) $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.date_add_interval(date, interval) RETURNS date LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'date_add_date_interval';

CREATE OR REPLACE FUNCTION pg_catalog.op_num_add_intr (numeric, interval) RETURNS text AS $$ SELECT pg_catalog.date_add($1, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_text_add_intr (text, interval) RETURNS text AS $$ SELECT pg_catalog.date_add($1, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_date_add_intr (date, interval) RETURNS date AS $$ SELECT pg_catalog.date_add_interval($1, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_dttm_add_intr (timestamp without time zone, interval) RETURNS timestamp without time zone AS $$ SELECT pg_catalog.date_add($1, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_tmsp_add_intr (timestamptz, interval) RETURNS timestamptz AS $$ SELECT pg_catalog.date_add($1, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_num (interval, numeric) RETURNS text AS $$ SELECT pg_catalog.date_add($2, $1) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_text (interval, text) RETURNS text AS $$ SELECT pg_catalog.date_add($2, $1) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_date (interval, date) RETURNS date AS $$ SELECT pg_catalog.date_add_interval($2, $1) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_dttm (interval, timestamp without time zone) RETURNS timestamp without time zone AS $$ SELECT pg_catalog.date_add($2, $1) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_tmsp (interval, timestamptz) RETURNS timestamptz AS $$ SELECT pg_catalog.date_add($2, $1) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_num_sub_intr (numeric, interval) RETURNS text AS $$ SELECT pg_catalog.date_sub($1, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_text_sub_intr (text, interval) RETURNS text AS $$ SELECT pg_catalog.date_sub($1, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_date_sub_intr (date, interval) RETURNS date AS $$ SELECT pg_catalog.date_add_interval($1, -$2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_dttm_sub_intr (timestamp without time zone, interval) RETURNS timestamp without time zone AS $$ SELECT pg_catalog.date_sub($1, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_tmsp_sub_intr (timestamptz, interval) RETURNS timestamptz AS $$ SELECT pg_catalog.date_sub($1, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_json_add_intr (json, interval) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_add(cast($1 as text), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_json (interval, json) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_add(cast($2 as text), $1)';
CREATE OR REPLACE FUNCTION pg_catalog.op_json_sub_intr (json, interval) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_sub(cast($1 as text), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.op_blob_add_intr (blob, interval) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_add(cast($1 as text), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_blob (interval, blob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_add(cast($2 as text), $1)';
CREATE OR REPLACE FUNCTION pg_catalog.op_blob_sub_intr (blob, interval) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_sub(cast($1 as text), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.op_lblob_add_intr (longblob, interval) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_add(cast($1 as text), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_lblob (interval, longblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_add(cast($2 as text), $1)';
CREATE OR REPLACE FUNCTION pg_catalog.op_lblob_sub_intr (longblob, interval) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_sub(cast($1 as text), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.op_mblob_add_intr (mediumblob, interval) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_add(cast($1 as text), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_mblob (interval, mediumblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_add(cast($2 as text), $1)';
CREATE OR REPLACE FUNCTION pg_catalog.op_mblob_sub_intr (mediumblob, interval) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_sub(cast($1 as text), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.op_tblob_add_intr (tinyblob, interval) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_add(cast($1 as text), $2)';
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_tblob (interval, tinyblob) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_add(cast($2 as text), $1)';
CREATE OR REPLACE FUNCTION pg_catalog.op_tblob_sub_intr (tinyblob, interval) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_sub(cast($1 as text), $2)';

CREATE OPERATOR pg_catalog.+ (leftarg = numeric, rightarg = interval, procedure = op_num_add_intr, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.+ (leftarg = text, rightarg = interval, procedure = op_text_add_intr, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.+ (leftarg = interval, rightarg = numeric, procedure = op_intr_add_num, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.+ (leftarg = interval, rightarg = text, procedure = op_intr_add_text, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.- (leftarg = numeric, rightarg = interval, procedure = op_num_sub_intr, commutator = operator(pg_catalog.-));
CREATE OPERATOR pg_catalog.- (leftarg = text, rightarg = interval, procedure = op_text_sub_intr, commutator = operator(pg_catalog.-));
CREATE OPERATOR pg_catalog.+ (leftarg = json, rightarg = interval, procedure = op_json_add_intr, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.+ (leftarg = interval, rightarg = json, procedure = op_intr_add_json, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.- (leftarg = json, rightarg = interval, procedure = op_json_sub_intr, commutator = operator(pg_catalog.-));
CREATE OPERATOR pg_catalog.+ (leftarg = blob, rightarg = interval, procedure = op_blob_add_intr, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.+ (leftarg = interval, rightarg = blob, procedure = op_intr_add_blob, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.- (leftarg = blob, rightarg = interval, procedure = op_blob_sub_intr, commutator = operator(pg_catalog.-));
CREATE OPERATOR pg_catalog.+ (leftarg = longblob, rightarg = interval, procedure = op_lblob_add_intr, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.+ (leftarg = interval, rightarg = longblob, procedure = op_intr_add_lblob, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.- (leftarg = longblob, rightarg = interval, procedure = op_lblob_sub_intr, commutator = operator(pg_catalog.-));
CREATE OPERATOR pg_catalog.+ (leftarg = mediumblob, rightarg = interval, procedure = op_mblob_add_intr, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.+ (leftarg = interval, rightarg = mediumblob, procedure = op_intr_add_mblob, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.- (leftarg = mediumblob, rightarg = interval, procedure = op_mblob_sub_intr, commutator = operator(pg_catalog.-));
CREATE OPERATOR pg_catalog.+ (leftarg = tinyblob, rightarg = interval, procedure = op_tblob_add_intr, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.+ (leftarg = interval, rightarg = tinyblob, procedure = op_intr_add_tblob, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.- (leftarg = tinyblob, rightarg = interval, procedure = op_tblob_sub_intr, commutator = operator(pg_catalog.-));

DO $$
BEGIN
        update pg_catalog.pg_operator set oprresult = 'date'::regtype, oprcode = 'op_date_add_intr'::regproc
            where oprname = '+' and oprleft = 'date'::regtype and oprright = 'interval'::regtype;
        update pg_catalog.pg_operator set oprresult = 'timestamp without time zone'::regtype, oprcode = 'op_dttm_add_intr'::regproc
            where oprname = '+' and oprleft = 'timestamp without time zone'::regtype and oprright = 'interval'::regtype;
        update pg_catalog.pg_operator set oprresult = 'timestamptz'::regtype, oprcode = 'op_tmsp_add_intr'::regproc
            where oprname = '+' and oprleft = 'timestamptz'::regtype and oprright = 'interval'::regtype;
        update pg_catalog.pg_operator set oprresult = 'text'::regtype, oprcode = 'op_time_add_intr'::regproc
            where oprname = '+' and oprleft = 'time'::regtype and oprright = 'interval'::regtype;
    
        update pg_catalog.pg_operator set oprresult = 'date'::regtype, oprcode = 'op_intr_add_date'::regproc
            where oprname = '+' and oprleft = 'interval'::regtype and oprright = 'date'::regtype;
        update pg_catalog.pg_operator set oprresult = 'timestamp without time zone'::regtype, oprcode = 'op_intr_add_dttm'::regproc
            where oprname = '+' and oprleft = 'interval'::regtype and oprright = 'timestamp without time zone'::regtype;
        update pg_catalog.pg_operator set oprresult = 'timestamptz'::regtype, oprcode = 'op_intr_add_tmsp'::regproc
            where oprname = '+' and oprleft = 'interval'::regtype and oprright = 'timestamptz'::regtype;
        update pg_catalog.pg_operator set oprresult = 'text'::regtype, oprcode = 'op_intr_add_time'::regproc
            where oprname = '+' and oprleft = 'interval'::regtype and oprright = 'time'::regtype;
        
        update pg_catalog.pg_operator set oprresult = 'date'::regtype, oprcode = 'op_date_sub_intr'::regproc
            where oprname = '-' and oprleft = 'date'::regtype and oprright = 'interval'::regtype;
        update pg_catalog.pg_operator set oprresult = 'timestamp without time zone'::regtype, oprcode = 'op_dttm_sub_intr'::regproc
            where oprname = '-' and oprleft = 'timestamp without time zone'::regtype and oprright = 'interval'::regtype;
        update pg_catalog.pg_operator set oprresult = 'timestamptz'::regtype, oprcode = 'op_tmsp_sub_intr'::regproc
            where oprname = '-' and oprleft = 'timestamptz'::regtype and oprright = 'interval'::regtype;
        update pg_catalog.pg_operator set oprresult = 'text'::regtype, oprcode = 'op_time_sub_intr'::regproc
            where oprname = '-' and oprleft = 'time'::regtype and oprright = 'interval'::regtype;
END
$$;

CREATE OR REPLACE FUNCTION pg_catalog.date_add(time, interval, boolean) RETURNS text LANGUAGE C STABLE STRICT as '$libdir/dolphin', 'date_add_explicit';
CREATE OR REPLACE FUNCTION pg_catalog.date_add(timestamp without time zone, interval, boolean) RETURNS timestamp without time zone AS $$ SELECT pg_catalog.date_add($1, $2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_add(timestamptz, interval, boolean) RETURNS timestamptz AS $$ SELECT pg_catalog.date_add($1, $2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_add(text, interval, boolean) RETURNS text AS $$ SELECT pg_catalog.date_add($1, $2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_add(numeric, interval, boolean) RETURNS text AS $$ SELECT pg_catalog.date_add($1, $2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_add(year, interval, boolean) RETURNS text AS $$ SELECT pg_catalog.date_add($1, $2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_add(date, interval, boolean) RETURNS text AS $$ SELECT pg_catalog.date_add($1, $2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_sub(time, interval, boolean) RETURNS text AS $$ SELECT pg_catalog.date_add($1, -$2, $3)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_sub(timestamp without time zone, interval, boolean) RETURNS timestamp without time zone AS $$ SELECT pg_catalog.date_add($1, -$2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_sub(timestamptz, interval, boolean) RETURNS timestamptz AS $$ SELECT pg_catalog.date_add($1, -$2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_sub(text, interval, boolean) RETURNS text AS $$ SELECT pg_catalog.date_add($1, -$2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_sub(numeric, interval, boolean) RETURNS text AS $$ SELECT pg_catalog.date_add($1, -$2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_sub(year, interval, boolean) RETURNS text AS $$ SELECT pg_catalog.date_add($1, -$2)  $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.date_sub(date, interval, boolean) RETURNS text AS $$ SELECT pg_catalog.date_add($1, -$2)  $$ LANGUAGE SQL;

CREATE OR REPLACE FUNCTION pg_catalog.op_enum_add_intr (anyenum, interval) RETURNS text AS $$ SELECT pg_catalog.op_text_add_intr($1::text, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_enum (interval, anyenum) RETURNS text AS $$ SELECT pg_catalog.op_intr_add_text($1, $2::text) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_enum_sub_intr (anyenum, interval) RETURNS text AS $$ SELECT pg_catalog.op_text_sub_intr($1::text, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_set_add_intr (anyset, interval) RETURNS text AS $$ SELECT pg_catalog.op_text_add_intr($1::text, $2) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_intr_add_set (interval, anyset) RETURNS text AS $$ SELECT pg_catalog.op_intr_add_text($1, $2::text) $$ LANGUAGE SQL;
CREATE OR REPLACE FUNCTION pg_catalog.op_set_sub_intr (anyset, interval) RETURNS text AS $$ SELECT pg_catalog.op_text_sub_intr($1::text, $2) $$ LANGUAGE SQL;

CREATE OPERATOR pg_catalog.+ (leftarg = anyenum, rightarg = interval, procedure = op_enum_add_intr, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.+ (leftarg = interval, rightarg = anyenum, procedure = op_intr_add_enum, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.- (leftarg = anyenum, rightarg = interval, procedure = op_enum_sub_intr, commutator = operator(pg_catalog.-));
CREATE OPERATOR pg_catalog.+ (leftarg = anyset, rightarg = interval, procedure = op_set_add_intr, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.+ (leftarg = interval, rightarg = anyset, procedure = op_intr_add_set, commutator = operator(pg_catalog.+));
CREATE OPERATOR pg_catalog.- (leftarg = anyset, rightarg = interval, procedure = op_set_sub_intr, commutator = operator(pg_catalog.-));

create or replace function pg_catalog.any2interval(anyelement, integer) returns interval LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','any2interval';
create or replace function pg_catalog.any2interval(anyelement, integer, integer) returns interval LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin','any2interval';

CREATE OR REPLACE FUNCTION pg_catalog.op_int1xor(int1, int1) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int1xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int2xor(int2, int2) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int2xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int4xor(int4, int4) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int4xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int8xor(int8, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint1xor(uint1, uint1) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint1xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint2xor(uint2, uint2) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint2xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint4xor(uint4, uint4) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint4xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint8xor(uint8, uint8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint8xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint1_xor_int1(uint1, int1) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint1_xor_int1($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int1_xor_uint1(int1, uint1) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int1_xor_uint1($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint2_xor_int2(uint2, int2) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint2_xor_int2($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int2_xor_uint2(int2, uint2) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int2_xor_uint2($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint4_xor_int4(uint4, int4) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint4_xor_int4($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int4_xor_uint4(int4, uint4) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int4_xor_uint4($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint8_xor_int8(uint8, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint8_xor_int8($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int8_xor_uint8(int8, uint8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_xor_uint8($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.blob_xor_blob(blob, blob) returns blob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blob_xor_blob';
CREATE OR REPLACE FUNCTION pg_catalog.mblob_xor_mblob(mediumblob, mediumblob) returns mediumblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blob_xor_blob';
CREATE OR REPLACE FUNCTION pg_catalog.lblob_xor_lblob(longblob, longblob) returns longblob LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blob_xor_blob';
CREATE OR REPLACE FUNCTION pg_catalog.binary_xor_binary(binary, binary) returns varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blob_xor_blob';
CREATE OR REPLACE FUNCTION pg_catalog.varbinary_xor_varbinary(varbinary, varbinary) returns varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blob_xor_blob';
CREATE OR REPLACE FUNCTION pg_catalog.tinyblob_xor_tinyblob(tinyblob, tinyblob) returns varbinary LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'blob_xor_blob';
CREATE OR REPLACE FUNCTION pg_catalog.op_blob_int_xor(blob, integer) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.blobxor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int_blob_xor(integer, blob) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.blobxor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int8_blob_xor(int8, blob) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.blobxor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_blob_int8_xor(blob, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.blobxor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_float8_blob_xor(float8, blob) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.blobxor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_blob_float8_xor(blob, float8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.blobxor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_boolxor(boolean, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int1xor($1::int1, $2::int1)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_float8_xor(boolean, float8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.dpow($1::float8, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_float8_bool_xor(float8, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.dpow($1, $2::float8)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_datexor(date, date) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.datexor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_timexor(time, time) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timexor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_date_time_xor(date, time) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_time_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_time_date_xor(time, date) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.time_date_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_time_text_xor(time, text) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.time_text_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_text_time_xor(text, time) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.text_time_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_date_text_xor(date, text) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_text_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_text_date_xor(text, date) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.text_date_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_date_int8_xor(date, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_int8_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int8_date_xor(int8, date) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_date_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_time_int8_xor(time, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.time_int8_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int8_time_xor(int8, time) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_time_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_date_float8_xor(date, float8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_float8_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_float8_date_xor(float8, date) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.float8_date_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_timestampxor(timestamp without time zone, timestamp without time zone) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestampxor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_timestamp_int8_xor(timestamp without time zone, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamp_int8_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int8_timestamp_xor(int8, timestamp without time zone) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_timestamp_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_timestamp_float8_xor(timestamp without time zone, float8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamp_float8_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_float8_timestamp_xor(float8, timestamp without time zone) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.float8_timestamp_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_timestamp_text_xor(timestamp without time zone, text) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamp_text_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_text_timestamp_xor(text, timestamp without time zone) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.text_timestamp_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_timestamptzxor(timestampTz, timestampTz) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamptzxor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_timestamptz_int8_xor(timestampTz, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamptz_int8_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int8_timestamptz_xor(int8, timestampTz) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_timestamptz_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_timestamptz_float8_xor(timestampTz, float8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamptz_float8_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_float8_timestamptz_xor(float8, timestampTz) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.float8_timestamptz_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_timestamptz_text_xor(timestampTz, text) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamptz_text_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_text_timestamptz_xor(text, timestampTz) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.text_timestamptz_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint8_xor_bool(uint8, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint8xor($1, $2::uint8)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint4_xor_bool(uint4, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint4xor($1, $2::uint8)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint2_xor_bool(uint2, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint2xor($1, $2::uint8)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint1_xor_bool(uint1, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint1xor($1, $2::uint8)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_xor_uint1(boolean, uint1) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint1xor($1::uint8, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_xor_uint2(boolean, uint2) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint2xor($1::uint8, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_xor_uint4(boolean, uint4) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint4xor($1::uint8, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_xor_uint8(boolean, uint8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.uint8xor($1::uint8, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bitxor(bit, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.bitxor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_dpow(float8, float8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.dpow($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.numeric_xor(numeric, numeric) returns int8 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'numeric_xor';
CREATE OR REPLACE FUNCTION pg_catalog.op_numeric_power(numeric, numeric) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.numeric_xor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_textxor(text, text) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.textxor($1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_xor_int1(boolean, int1) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int1xor($1::int1, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_xor_int2(boolean, int2) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int2xor($1::int2, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_xor_int4(boolean, int4) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int4xor($1::int4, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_xor_int8(boolean, int8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8xor($1::int8, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int1_xor_bool(int1, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int1xor($1, $2::int1)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int2_xor_bool(int2, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int2xor($1, $2::int2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int4_xor_bool(int4, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int4xor($1, $2::int4)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_int8_xor_bool(int8, boolean) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8xor($1, $2::int8)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_num_xor_bit(numeric, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.numeric_xor($1, $2::numeric)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bit_xor_num(bit, numeric) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.numeric_xor($1::numeric, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_uint8_xor_bit(uint8, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.numeric_xor($1::numeric, $2::numeric)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bit_xor_uint8(bit, uint8) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.numeric_xor($1::numeric, $2::numeric)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_date_bit_xor(date, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.date_int8_xor($1, $2::int8)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bit_date_xor(bit, date) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_date_xor($1::int8, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_timestamp_bit_xor(timestamp without time zone, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamp_int8_xor($1, $2::int8)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bit_timestamp_xor(bit, timestamp without time zone) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_timestamp_xor($1::int8, $2)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_timestamptz_bit_xor(timestampTz, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.timestamptz_int8_xor($1, $2::int8)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bit_timestamptz_xor(bit, timestampTz) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_timestamptz_xor($1::int8, $2)::uint8';
DO $for_upgrade_only$
DECLARE
  ans boolean;
  v_isinplaceupgrade boolean;
BEGIN
    select case when count(*)=1 then true else false end as ans from (select setting from pg_settings where name = 'upgrade_mode' and setting != '0') into ans;
    show isinplaceupgrade into v_isinplaceupgrade;
    -- we can do drop operator only during upgrade
    if ans = true and v_isinplaceupgrade = true then
        DROP OPERATOR IF EXISTS pg_catalog.^(int1, int1);
        CREATE OPERATOR pg_catalog.^ (leftarg = int1, rightarg = int1, procedure = pg_catalog.op_int1xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(int2, int2);
        CREATE OPERATOR pg_catalog.^ (leftarg = int2, rightarg = int2, procedure = pg_catalog.op_int2xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(int4, int4);
        CREATE OPERATOR pg_catalog.^ (leftarg = int4, rightarg = int4, procedure = pg_catalog.op_int4xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(int8, int8);
        CREATE OPERATOR pg_catalog.^ (leftarg = int8, rightarg = int8, procedure = pg_catalog.op_int8xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(uint1, uint1);
        CREATE OPERATOR pg_catalog.^ (leftarg = uint1, rightarg = uint1, procedure = pg_catalog.op_uint1xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(uint2, uint2);
        CREATE OPERATOR pg_catalog.^ (leftarg = uint2, rightarg = uint2, procedure = pg_catalog.op_uint2xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(uint4, uint4);
        CREATE OPERATOR pg_catalog.^ (leftarg = uint4, rightarg = uint4, procedure = pg_catalog.op_uint4xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(uint8, uint8);
        CREATE OPERATOR pg_catalog.^ (leftarg = uint8, rightarg = uint8, procedure = pg_catalog.op_uint8xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(uint1, int1);
        CREATE OPERATOR pg_catalog.^ (leftarg = uint1, rightarg = int1, procedure = pg_catalog.op_uint1_xor_int1);
        DROP OPERATOR IF EXISTS pg_catalog.^(int1, uint1);
        CREATE OPERATOR pg_catalog.^ (leftarg = int1, rightarg = uint1, procedure = pg_catalog.op_int1_xor_uint1);
        DROP OPERATOR IF EXISTS pg_catalog.^(uint2, int2);
        CREATE OPERATOR pg_catalog.^ (leftarg = uint2, rightarg = int2, procedure = pg_catalog.op_uint2_xor_int2);
        DROP OPERATOR IF EXISTS pg_catalog.^(int2, uint2);
        CREATE OPERATOR pg_catalog.^ (leftarg = int2, rightarg = uint2, procedure = pg_catalog.op_int2_xor_uint2);
        DROP OPERATOR IF EXISTS pg_catalog.^(uint4, int4);
        CREATE OPERATOR pg_catalog.^ (leftarg = uint4, rightarg = int4, procedure = pg_catalog.op_uint4_xor_int4);
        DROP OPERATOR IF EXISTS pg_catalog.^(int4, uint4);
        CREATE OPERATOR pg_catalog.^ (leftarg = int4, rightarg = uint4, procedure = pg_catalog.op_int4_xor_uint4);
        DROP OPERATOR IF EXISTS pg_catalog.^(uint8, int8);
        CREATE OPERATOR pg_catalog.^ (leftarg = uint8, rightarg = int8, procedure = pg_catalog.op_uint8_xor_int8);
        DROP OPERATOR IF EXISTS pg_catalog.^(int8, uint8);
        CREATE OPERATOR pg_catalog.^ (leftarg = int8, rightarg = uint8, procedure = pg_catalog.op_int8_xor_uint8);
        DROP OPERATOR IF EXISTS pg_catalog.^(blob, blob);
        CREATE OPERATOR pg_catalog.^(leftarg = blob, rightarg = blob, procedure = pg_catalog.blob_xor_blob);
        DROP OPERATOR IF EXISTS pg_catalog.^(mediumblob, mediumblob);
        CREATE OPERATOR pg_catalog.^(leftarg = mediumblob, rightarg = mediumblob, procedure = pg_catalog.mblob_xor_mblob);
        DROP OPERATOR IF EXISTS pg_catalog.^(longblob, longblob);
        CREATE OPERATOR pg_catalog.^(leftarg = longblob, rightarg = longblob, procedure = pg_catalog.lblob_xor_lblob);
        DROP OPERATOR IF EXISTS pg_catalog.^(binary, binary);
        CREATE OPERATOR pg_catalog.^(leftarg = binary, rightarg = binary, procedure = pg_catalog.binary_xor_binary);
        DROP OPERATOR IF EXISTS pg_catalog.^(varbinary, varbinary);
        CREATE OPERATOR pg_catalog.^(leftarg = varbinary, rightarg = varbinary, procedure = pg_catalog.varbinary_xor_varbinary);
        DROP OPERATOR IF EXISTS pg_catalog.^(tinyblob, tinyblob);
        CREATE OPERATOR pg_catalog.^(leftarg = tinyblob, rightarg = tinyblob, procedure = pg_catalog.tinyblob_xor_tinyblob);
        DROP OPERATOR IF EXISTS pg_catalog.^(blob, integer);
        CREATE OPERATOR pg_catalog.^(leftarg = blob, rightarg = integer, procedure = pg_catalog.op_blob_int_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(integer, blob);
        CREATE OPERATOR pg_catalog.^(leftarg = integer, rightarg = blob, procedure = pg_catalog.op_int_blob_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(int8, blob);
        CREATE OPERATOR pg_catalog.^(leftarg = int8, rightarg = blob, procedure = pg_catalog.op_int8_blob_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(blob, int8);
        CREATE OPERATOR pg_catalog.^(leftarg = blob, rightarg = int8, procedure = pg_catalog.op_blob_int8_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(float8, blob);
        CREATE OPERATOR pg_catalog.^(leftarg = float8, rightarg = blob, procedure = pg_catalog.op_float8_blob_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(blob, float8);
        CREATE OPERATOR pg_catalog.^(leftarg = blob, rightarg = float8, procedure = pg_catalog.op_blob_float8_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(boolean, boolean);
        CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = boolean, procedure = pg_catalog.op_boolxor);
        DROP OPERATOR IF EXISTS pg_catalog.^(boolean, float8);
        CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = float8, procedure = pg_catalog.op_bool_float8_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(float8, boolean);
        CREATE OPERATOR pg_catalog.^(leftarg = float8, rightarg = boolean, procedure = pg_catalog.op_float8_bool_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(date, date);
        CREATE OPERATOR pg_catalog.^(leftarg = date, rightarg = date, procedure = pg_catalog.op_datexor);
        DROP OPERATOR IF EXISTS pg_catalog.^(time, time);
        CREATE OPERATOR pg_catalog.^(leftarg = time, rightarg = time, procedure = pg_catalog.op_timexor);
        DROP OPERATOR IF EXISTS pg_catalog.^(date, time);
        CREATE OPERATOR pg_catalog.^(leftarg = date, rightarg = time, procedure = pg_catalog.op_date_time_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(time, date);
        CREATE OPERATOR pg_catalog.^(leftarg = time, rightarg = date, procedure = pg_catalog.op_time_date_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(time, text);
        CREATE OPERATOR pg_catalog.^(leftarg = time, rightarg = text, procedure = pg_catalog.op_time_text_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(text, time);
        CREATE OPERATOR pg_catalog.^(leftarg = text, rightarg = time, procedure = pg_catalog.op_text_time_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(date, text);
        CREATE OPERATOR pg_catalog.^(leftarg = date, rightarg = text, procedure = pg_catalog.op_date_text_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(text, date);
        CREATE OPERATOR pg_catalog.^(leftarg = text, rightarg = date, procedure = pg_catalog.op_text_date_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(date, int8);
        CREATE OPERATOR pg_catalog.^(leftarg = date, rightarg = int8, procedure = pg_catalog.op_date_int8_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(int8, date);
        CREATE OPERATOR pg_catalog.^(leftarg = int8, rightarg = date, procedure = pg_catalog.op_int8_date_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(time, int8);
        CREATE OPERATOR pg_catalog.^(leftarg = time, rightarg = int8, procedure = pg_catalog.op_time_int8_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(int8, time);
        CREATE OPERATOR pg_catalog.^(leftarg = int8, rightarg = time, procedure = pg_catalog.op_int8_time_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(date, float8);
        CREATE OPERATOR pg_catalog.^(leftarg = date, rightarg = float8, procedure = pg_catalog.op_date_float8_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(float8, date);
        CREATE OPERATOR pg_catalog.^(leftarg = float8, rightarg = date, procedure = pg_catalog.op_float8_date_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(timestamp without time zone, timestamp without time zone);
        CREATE OPERATOR pg_catalog.^(leftarg = timestamp without time zone, rightarg = timestamp without time zone, procedure = pg_catalog.op_timestampxor);
        DROP OPERATOR IF EXISTS pg_catalog.^(timestamp without time zone, int8);
        CREATE OPERATOR pg_catalog.^(leftarg = timestamp without time zone, rightarg = int8, procedure = pg_catalog.op_timestamp_int8_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(int8, timestamp without time zone);
        CREATE OPERATOR pg_catalog.^(leftarg = int8, rightarg = timestamp without time zone, procedure = pg_catalog.op_int8_timestamp_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(timestamp without time zone, float8);
        CREATE OPERATOR pg_catalog.^(leftarg = timestamp without time zone, rightarg = float8, procedure = pg_catalog.op_timestamp_float8_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(float8, timestamp without time zone);
        CREATE OPERATOR pg_catalog.^(leftarg = float8, rightarg = timestamp without time zone, procedure = pg_catalog.op_float8_timestamp_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(timestamp without time zone, text);
        CREATE OPERATOR pg_catalog.^(leftarg = timestamp without time zone, rightarg = text, procedure = pg_catalog.op_timestamp_text_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(text, timestamp without time zone);
        CREATE OPERATOR pg_catalog.^(leftarg = text, rightarg = timestamp without time zone, procedure = pg_catalog.op_text_timestamp_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(timestampTz, timestampTz);
        CREATE OPERATOR pg_catalog.^(leftarg = timestampTz, rightarg = timestampTz, procedure = pg_catalog.op_timestamptzxor);
        DROP OPERATOR IF EXISTS pg_catalog.^(timestampTz, int8);
        CREATE OPERATOR pg_catalog.^(leftarg = timestampTz, rightarg = int8, procedure = pg_catalog.op_timestamptz_int8_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(int8, timestampTz);
        CREATE OPERATOR pg_catalog.^(leftarg = int8, rightarg = timestampTz, procedure = pg_catalog.op_int8_timestamptz_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(timestampTz, float8);
        CREATE OPERATOR pg_catalog.^(leftarg = timestampTz, rightarg = float8, procedure = pg_catalog.op_timestamptz_float8_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(float8, timestampTz);
        CREATE OPERATOR pg_catalog.^(leftarg = float8, rightarg = timestampTz, procedure = pg_catalog.op_float8_timestamptz_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(timestampTz, text);
        CREATE OPERATOR pg_catalog.^(leftarg = timestampTz, rightarg = text, procedure = pg_catalog.op_timestamptz_text_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(text, timestampTz);
        CREATE OPERATOR pg_catalog.^(leftarg = text, rightarg = timestampTz, procedure = pg_catalog.op_text_timestamptz_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(uint8, boolean);
        CREATE OPERATOR pg_catalog.^(leftarg = uint8, rightarg = boolean, procedure = pg_catalog.op_uint8_xor_bool, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(uint4, boolean);
        CREATE OPERATOR pg_catalog.^(leftarg = uint4, rightarg = boolean, procedure = pg_catalog.op_uint4_xor_bool, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(uint2, boolean);
        CREATE OPERATOR pg_catalog.^(leftarg = uint2, rightarg = boolean, procedure = pg_catalog.op_uint2_xor_bool, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(uint1, boolean);
        CREATE OPERATOR pg_catalog.^(leftarg = uint1, rightarg = boolean, procedure = pg_catalog.op_uint1_xor_bool, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(boolean, uint1);
        CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = uint1, procedure = pg_catalog.op_bool_xor_uint1, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(boolean, uint2);
        CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = uint2, procedure = pg_catalog.op_bool_xor_uint2, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(boolean, uint4);
        CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = uint4, procedure = pg_catalog.op_bool_xor_uint4, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(boolean, uint8);
        CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = uint8, procedure = pg_catalog.op_bool_xor_uint8, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(bit, bit);
        CREATE OPERATOR pg_catalog.^ (leftarg = bit, rightarg = bit, procedure = pg_catalog.op_bitxor);
        DROP OPERATOR IF EXISTS pg_catalog.^(text, text);
        CREATE OPERATOR pg_catalog.^ (leftarg = text, rightarg = text, procedure = pg_catalog.op_textxor);
        DROP OPERATOR IF EXISTS pg_catalog.^(boolean, int1);
        CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = int1, procedure = pg_catalog.op_bool_xor_int1, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(boolean, int8);
        CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = int2, procedure = pg_catalog.op_bool_xor_int2, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(boolean, int8);
        CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = int4, procedure = pg_catalog.op_bool_xor_int4, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(boolean, int8);
        CREATE OPERATOR pg_catalog.^(leftarg = boolean, rightarg = int8, procedure = pg_catalog.op_bool_xor_int8, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(int8, boolean);
        CREATE OPERATOR pg_catalog.^(leftarg = int8, rightarg = boolean, procedure = pg_catalog.op_int8_xor_bool, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(int4, boolean);
        CREATE OPERATOR pg_catalog.^(leftarg = int4, rightarg = boolean, procedure = pg_catalog.op_int4_xor_bool, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(int2, boolean);
        CREATE OPERATOR pg_catalog.^(leftarg = int2, rightarg = boolean, procedure = pg_catalog.op_int2_xor_bool, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(int1, boolean);
        CREATE OPERATOR pg_catalog.^(leftarg = int1, rightarg = boolean, procedure = pg_catalog.op_int1_xor_bool, commutator=operator(pg_catalog.^));
        DROP OPERATOR IF EXISTS pg_catalog.^(numeric, bit);
        CREATE OPERATOR pg_catalog.^(leftarg = numeric, rightarg = bit, procedure = pg_catalog.op_num_xor_bit);
        DROP OPERATOR IF EXISTS pg_catalog.^(bit, numeric);
        CREATE OPERATOR pg_catalog.^(leftarg = bit, rightarg = numeric, procedure = pg_catalog.op_bit_xor_num);
        DROP OPERATOR IF EXISTS pg_catalog.^(uint8, bit);
        CREATE OPERATOR pg_catalog.^(leftarg = uint8, rightarg = bit, procedure = pg_catalog.op_uint8_xor_bit);
        DROP OPERATOR IF EXISTS pg_catalog.^(bit, uint8);
        CREATE OPERATOR pg_catalog.^(leftarg = bit, rightarg = uint8, procedure = pg_catalog.op_bit_xor_uint8);
        DROP OPERATOR IF EXISTS pg_catalog.^(date, bit);
        CREATE OPERATOR pg_catalog.^(leftarg = date, rightarg = bit, procedure = pg_catalog.op_date_bit_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(bit, date);
        CREATE OPERATOR pg_catalog.^(leftarg = bit, rightarg = date, procedure = pg_catalog.op_bit_date_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(timestamp without time zone, bit);
        CREATE OPERATOR pg_catalog.^(leftarg = timestamp without time zone, rightarg = bit, procedure = pg_catalog.op_timestamp_bit_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(bit, timestamp without time zone);
        CREATE OPERATOR pg_catalog.^(leftarg = bit, rightarg = timestamp without time zone, procedure = pg_catalog.op_bit_timestamp_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(timestampTz, bit);
        CREATE OPERATOR pg_catalog.^(leftarg = timestampTz, rightarg = bit, procedure = pg_catalog.op_timestamptz_bit_xor);
        DROP OPERATOR IF EXISTS pg_catalog.^(bit, timestampTz);
        CREATE OPERATOR pg_catalog.^(leftarg = bit, rightarg = timestampTz, procedure = pg_catalog.op_bit_timestamptz_xor);
    end if;
END
$for_upgrade_only$;

do $$
begin
    UPDATE pg_catalog.pg_operator SET oprresult = 'uint8'::regtype, oprcode = 'op_dpow'::regproc
        WHERE oprname = '^' AND oprleft = 'float8'::regtype AND oprright = 'float8'::regtype;
    UPDATE pg_catalog.pg_operator SET oprresult = 'uint8'::regtype, oprcode = 'op_numeric_power'::regproc
        WHERE oprname = '^' AND oprleft = 'numeric'::regtype AND oprright = 'numeric'::regtype;
end
$$;

CREATE OR REPLACE FUNCTION pg_catalog.int1_typmodin (_cstring) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_typmodin';
CREATE OR REPLACE FUNCTION pg_catalog.int1_typmodout (int) RETURNS cstring LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int1_typmodout';
CREATE OR REPLACE FUNCTION pg_catalog.int2_typmodin (_cstring) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_typmodin';
CREATE OR REPLACE FUNCTION pg_catalog.int2_typmodout (int) RETURNS cstring LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_typmodout';
CREATE OR REPLACE FUNCTION pg_catalog.int4_typmodin (_cstring) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_typmodin';
CREATE OR REPLACE FUNCTION pg_catalog.int4_typmodout (int) RETURNS cstring LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_typmodout';
CREATE OR REPLACE FUNCTION pg_catalog.int8_typmodin (_cstring) RETURNS int LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_typmodin';
CREATE OR REPLACE FUNCTION pg_catalog.int8_typmodout (int) RETURNS cstring LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_typmodout';

do $$
begin
update pg_catalog.pg_type set typmodin = 'int1_typmodin'::regproc, typmodout = 'int1_typmodout'::regproc where oid in('int1'::regtype, 'uint1'::regtype);
update pg_catalog.pg_type set typmodin = 'int2_typmodin'::regproc, typmodout = 'int2_typmodout'::regproc where oid in('int2'::regtype, 'uint2'::regtype);
update pg_catalog.pg_type set typmodin = 'int4_typmodin'::regproc, typmodout = 'int4_typmodout'::regproc where oid in('int4'::regtype, 'uint4'::regtype);
update pg_catalog.pg_type set typmodin = 'int8_typmodin'::regproc, typmodout = 'int8_typmodout'::regproc where oid in('int8'::regtype, 'uint8'::regtype);
end
$$;



CREATE FUNCTION pg_catalog.text_to_bit(text) RETURNS bit LANGUAGE C IMMUTABLE STRICT AS '$libdir/dolphin', 'text_to_bit';
CREATE CAST(text AS bit) WITH FUNCTION pg_catalog.text_to_bit(text) AS ASSIGNMENT;

DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(bit) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(binary) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(tinyblob) CASCADE;
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.inet_ntoa(nvarchar2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(year) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(json) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.inet_ntoa(int8) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa(int8) RETURNS varchar LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'inetntoa';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa(bit) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa(binary) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa(tinyblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa(blob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa(mediumblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa(longblob) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa(nvarchar2) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as varchar))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa(year) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';
CREATE OR REPLACE FUNCTION pg_catalog.inet_ntoa(json) RETURNS varchar LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.inet_ntoa(cast($1 as int8))';

-- sum
drop aggregate if exists pg_catalog.sum(uint1);
drop aggregate if exists pg_catalog.sum(uint2);
drop aggregate if exists pg_catalog.sum(uint4);

DROP FUNCTION IF EXISTS pg_catalog.uint1_sum(int8, uint1) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint2_sum(int8, uint2) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.uint4_sum(int8, uint4) CASCADE;

CREATE OR REPLACE FUNCTION pg_catalog.uint1_sum(numeric, uint1) RETURNS numeric LANGUAGE C AS  '$libdir/dolphin',  'uint1_sum';
CREATE OR REPLACE FUNCTION pg_catalog.uint2_sum(numeric, uint2) RETURNS numeric LANGUAGE C AS  '$libdir/dolphin',  'uint2_sum';
CREATE OR REPLACE FUNCTION pg_catalog.uint4_sum(numeric, uint4) RETURNS numeric LANGUAGE C AS  '$libdir/dolphin',  'uint4_sum';

create aggregate pg_catalog.sum(uint1) (SFUNC=uint1_sum, cFUNC=numeric_add, STYPE= numeric );
create aggregate pg_catalog.sum(uint2) (SFUNC=uint2_sum, cFUNC=numeric_add, STYPE= numeric );
create aggregate pg_catalog.sum(uint4) (SFUNC=uint4_sum, cFUNC=numeric_add, STYPE= numeric );

CREATE OR REPLACE FUNCTION pg_catalog.float8_sum(float8, float8) RETURNS float8 LANGUAGE C AS  '$libdir/dolphin',  'float8_sum';

CREATE OR REPLACE FUNCTION pg_catalog.float_sum(double precision, float4) RETURNS double precision LANGUAGE SQL IMMUTABLE as $$ SELECT pg_catalog.float8_sum($1, $2::float8) $$;
drop aggregate if exists pg_catalog.sum_ext(float4);
create aggregate pg_catalog.sum_ext(float4) (SFUNC=float_sum, cFUNC=float8pl, STYPE= double precision);

CREATE OR REPLACE FUNCTION pg_catalog.tinyint_sum(numeric, tinyint) RETURNS numeric LANGUAGE SQL IMMUTABLE as $$ SELECT pg_catalog.int8_sum($1, $2::int8) $$;
drop aggregate if exists pg_catalog.sum(tinyint);
create aggregate pg_catalog.sum(tinyint) (SFUNC=tinyint_sum, cFUNC=numeric_add, STYPE= numeric);

CREATE OR REPLACE FUNCTION pg_catalog.smallint_sum_ext(numeric, smallint) RETURNS numeric LANGUAGE SQL IMMUTABLE as $$ SELECT pg_catalog.int8_sum($1, $2::int8) $$;
drop aggregate if exists pg_catalog.sum_ext(smallint);
create aggregate pg_catalog.sum_ext(smallint) (SFUNC=smallint_sum_ext, cFUNC=numeric_add, STYPE= numeric);

CREATE OR REPLACE FUNCTION pg_catalog.int_sum_ext(numeric, int) RETURNS numeric LANGUAGE SQL IMMUTABLE as $$ SELECT pg_catalog.int8_sum($1, $2::int8) $$;
drop aggregate if exists pg_catalog.sum_ext(int);
create aggregate pg_catalog.sum_ext(int) (SFUNC=int_sum_ext, cFUNC=numeric_add, STYPE= numeric);

CREATE OR REPLACE FUNCTION pg_catalog.tinyint_sum(numeric, year) RETURNS numeric LANGUAGE SQL IMMUTABLE as $$ SELECT pg_catalog.int8_sum($1, $2::int8) $$;
drop aggregate if exists pg_catalog.sum(year);
create aggregate pg_catalog.sum(year) (SFUNC=tinyint_sum, cFUNC=numeric_add, STYPE= numeric);

CREATE OR REPLACE FUNCTION pg_catalog.text_sum(double precision, text) RETURNS double precision LANGUAGE SQL IMMUTABLE as $$ SELECT pg_catalog.float8_sum($1, $2::float8) $$;
drop aggregate if exists pg_catalog.sum(text);
create aggregate pg_catalog.sum(text) (SFUNC=text_sum, cFUNC=float8pl, STYPE= double precision);

CREATE OR REPLACE FUNCTION pg_catalog.anyset_sum(double precision, anyset) RETURNS double precision LANGUAGE SQL IMMUTABLE as $$ SELECT pg_catalog.float8_sum($1, $2::float8) $$;
drop aggregate if exists pg_catalog.sum(anyset);
create aggregate pg_catalog.sum(anyset) (SFUNC=anyset_sum, cFUNC=float8pl, STYPE= double precision);

CREATE OR REPLACE FUNCTION pg_catalog.anyenum_sum(double precision, anyenum) RETURNS double precision LANGUAGE SQL IMMUTABLE as $$ SELECT pg_catalog.float8_sum($1, $2::float8) $$;
drop aggregate if exists pg_catalog.sum(anyenum);
create aggregate pg_catalog.sum(anyenum) (SFUNC=anyenum_sum, cFUNC=float8pl, STYPE= double precision);

DROP FUNCTION IF EXISTS pg_catalog.set_native_password(text, text);
CREATE OR REPLACE FUNCTION pg_catalog.set_native_password(text, text, text) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'set_native_password';
DROP FUNCTION IF EXISTS pg_catalog.set_caching_sha2_password(text, text, text);
CREATE OR REPLACE FUNCTION pg_catalog.set_caching_sha2_password(text, text, text) RETURNS text LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'set_caching_sha2_password';
DROP FUNCTION IF EXISTS pg_catalog.round(text) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.round(time without time zone) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.round(timestamp with time zone) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.round(timestamp without time zone) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.round(anyenum) CASCADE;
DROP FUNCTION IF EXISTS pg_catalog.round(anyset) CASCADE;
CREATE OR REPLACE FUNCTION pg_catalog.round(text) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as double precision))::double precision';
CREATE OR REPLACE FUNCTION pg_catalog.round(time without time zone) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as double precision))::double precision';
CREATE OR REPLACE FUNCTION pg_catalog.round(timestamp with time zone) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as double precision))::double precision';
CREATE OR REPLACE FUNCTION pg_catalog.round(timestamp without time zone) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as double precision))::double precision';
CREATE OR REPLACE FUNCTION pg_catalog.round(anyenum) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as double precision))::double precision';
CREATE OR REPLACE FUNCTION pg_catalog.round(anyset) RETURNS double precision LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.round(cast($1 as double precision))::double precision';

CREATE OR REPLACE FUNCTION pg_catalog.substr(bit, bit) RETURNS bit LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.substring($1, $2::integer)';
CREATE OR REPLACE FUNCTION pg_catalog.substr(bytea, bit) RETURNS bytea LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.substring($1, $2::integer)';
CREATE OR REPLACE FUNCTION pg_catalog.substr(text, bit) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.substring($1, $2::integer)';
CREATE OR REPLACE FUNCTION pg_catalog.substr(bit, int, int) RETURNS bit LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.substring($1, $2, $3)';
CREATE OR REPLACE FUNCTION pg_catalog.substr(bit, int) RETURNS bit LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.substring($1, $2)';

drop cast if exists ("binary" as varchar);
drop cast if exists ("binary" as char);
CREATE CAST ("binary" AS varchar) WITH FUNCTION pg_catalog.Varlena2Varchar(anyelement) AS IMPLICIT;
CREATE CAST ("binary" AS char) WITH FUNCTION pg_catalog.Varlena2Bpchar(anyelement) AS IMPLICIT;

-- fix merge join
CREATE OR REPLACE FUNCTION pg_catalog.int8_cmp_uint1(int8, uint1)
    RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_cmp_uint1';
CREATE OR REPLACE FUNCTION pg_catalog.int8_cmp_uint2(int8, uint2)
    RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_cmp_uint2';
CREATE OR REPLACE FUNCTION pg_catalog.int8_cmp_uint4(int8, uint4)
    RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_cmp_uint4';
CREATE OR REPLACE FUNCTION pg_catalog.int8_cmp_uint8(int8, uint8)
    RETURNS int4 LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_cmp_uint8';

CREATE OR REPLACE FUNCTION pg_catalog.int2_eq_uint1(int2, uint1)
    RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int2_eq_uint1';

CREATE OR REPLACE FUNCTION pg_catalog.int4_eq_uint1(int4, uint1)
    RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int4_eq_uint1';

CREATE OR REPLACE FUNCTION pg_catalog.int8_eq_uint1(int8, uint1)
    RETURNS bool LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin',  'int8_eq_uint1';

CREATE OPERATOR pg_catalog.=(
    leftarg = int2, rightarg = uint1,
    procedure = pg_catalog.int2_eq_uint1, commutator = operator(pg_catalog.=),
    restrict = eqsel, join = eqjoinsel, HASHES, MERGES
);

CREATE OPERATOR pg_catalog.=(
    leftarg = int4, rightarg = uint1,
    procedure = pg_catalog.int4_eq_uint1, commutator = operator(pg_catalog.=),
    restrict = eqsel, join = eqjoinsel, HASHES, MERGES
);

CREATE OPERATOR pg_catalog.=(
    leftarg = int8, rightarg = uint1,
    procedure = pg_catalog.int8_eq_uint1, commutator = operator(pg_catalog.=),
    restrict = eqsel, join = eqjoinsel, HASHES, MERGES
);

CREATE OPERATOR CLASS pg_catalog.int8_uint_bt_ops
    FOR TYPE int8 USING btree FAMILY pg_catalog.integer_ops AS
        OPERATOR        3       =(int8, uint1),
        OPERATOR        3       =(int8, uint2),
        OPERATOR        3       =(int8, uint4),
        OPERATOR        3       =(int8, uint8),

        FUNCTION        1       pg_catalog.int8_cmp_uint1(int8,uint1),
        FUNCTION        1       pg_catalog.int8_cmp_uint2(int8,uint2),
        FUNCTION        1       pg_catalog.int8_cmp_uint4(int8,uint4),
        FUNCTION        1       pg_catalog.int8_cmp_uint8(int8,uint8);

CREATE OPERATOR CLASS pg_catalog.int8_uint_hash_ops
    FOR TYPE int8 USING hash family pg_catalog.integer_ops AS
        OPERATOR        1       =(int8, uint1),
        FUNCTION        1 (int8, uint1)  hashint8(int8);

DROP FUNCTION IF EXISTS pg_catalog.db_b_format("any", int4) cascade;
DROP FUNCTION IF EXISTS pg_catalog.db_b_format("any", int4, "any") cascade;
CREATE OR REPLACE FUNCTION pg_catalog.db_b_format("any", int8) RETURNS text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'db_b_format';
CREATE OR REPLACE FUNCTION pg_catalog.db_b_format("any", int8, "any") RETURNS text LANGUAGE C IMMUTABLE as '$libdir/dolphin', 'db_b_format_locale';

CREATE OR REPLACE FUNCTION pg_catalog.varchar_json(varchar) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'varchar_json';
CREATE CAST (varchar as json) WITH FUNCTION pg_catalog.varchar_json(varchar) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.varchar_json(text) RETURNS json LANGUAGE C IMMUTABLE STRICT as '$libdir/dolphin', 'text_json';
CREATE CAST (text as json) WITH FUNCTION pg_catalog.varchar_json(text) AS ASSIGNMENT;

CREATE OR REPLACE FUNCTION pg_catalog.float8_sum(float8, float8) RETURNS float8 LANGUAGE C IMMUTABLE AS '$libdir/dolphin',  'float8_sum';
CREATE OR REPLACE FUNCTION pg_catalog.float_sum(double precision, float4) RETURNS double precision LANGUAGE C IMMUTABLE AS '$libdir/dolphin',  'float_sum_ext';
CREATE OR REPLACE FUNCTION pg_catalog.tinyint_sum(numeric, tinyint) RETURNS numeric LANGUAGE C IMMUTABLE AS '$libdir/dolphin',  'tinyint_sum_ext';
CREATE OR REPLACE FUNCTION pg_catalog.smallint_sum_ext(numeric, smallint) RETURNS numeric LANGUAGE C IMMUTABLE AS '$libdir/dolphin',  'smallint_sum_ext';
CREATE OR REPLACE FUNCTION pg_catalog.int_sum_ext(numeric, int) RETURNS numeric LANGUAGE C IMMUTABLE AS '$libdir/dolphin',  'int_sum_ext';
CREATE OR REPLACE FUNCTION pg_catalog.year_sum(numeric, year) RETURNS numeric LANGUAGE C IMMUTABLE AS '$libdir/dolphin',  'year_sum_ext';
CREATE OR REPLACE FUNCTION pg_catalog.text_sum(double precision, text) RETURNS double precision LANGUAGE C IMMUTABLE AS '$libdir/dolphin',  'text_sum_ext';
CREATE OR REPLACE FUNCTION pg_catalog.anyset_sum(double precision, anyset) RETURNS double precision LANGUAGE C IMMUTABLE AS '$libdir/dolphin',  'set_sum_ext';

drop aggregate pg_catalog.sum(year);
create aggregate pg_catalog.sum(year) (SFUNC=year_sum, cFUNC=numeric_add, STYPE= numeric);
drop FUNCTION IF EXISTS pg_catalog.tinyint_sum(numeric, year);

-- xor between bool and bit,time
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_bit_xor(bool, bit) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8xor($1::int8, $2::int8)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bit_bool_xor(bit, bool) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8xor($1::int8, $2::int8)::uint8';
CREATE OPERATOR pg_catalog.^ (leftarg = bool, rightarg = bit, procedure = pg_catalog.op_bool_bit_xor);
CREATE OPERATOR pg_catalog.^ (leftarg = bit, rightarg = bool, procedure = pg_catalog.op_bit_bool_xor);

CREATE OR REPLACE FUNCTION pg_catalog.op_time_bool_xor(time, bool) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.time_int8_xor($1, $2::uint8)::uint8';
CREATE OR REPLACE FUNCTION pg_catalog.op_bool_time_xor(bool, time) returns uint8 LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.int8_time_xor($1::uint8, $2)::uint8';
CREATE OPERATOR pg_catalog.^ (leftarg = time without time zone, rightarg = bool, procedure = pg_catalog.op_time_bool_xor);
CREATE OPERATOR pg_catalog.^ (leftarg = bool, rightarg = time without time zone, procedure = pg_catalog.op_bool_time_xor);
CREATE or replace FUNCTION pg_catalog.replace(json, text, text) RETURNS text LANGUAGE SQL IMMUTABLE STRICT as 'select pg_catalog.replace($1::text, $2, $3)';
