Ошибка субд 58p01 1с

Постгрес патченный для 1с?

Это проблема установки расширения. В пг отсутствует тип mchar, без него 1ц работать не будет. Проблма решается дистро-специфично.

Вот полный лог постгреса за время создания базы:

2007-06-01 18:07:25 STATEMENT:   CREATE FUNCTION mchar_in(cstring)

    RETURNS mchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_out(mchar)

    RETURNS cstring

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_send(mchar)

    RETURNS bytea

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_recv(internal)

    RETURNS mchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE TYPE mchar (

        INTERNALLENGTH = -1,

       INPUT = mchar_in,

       OUTPUT = mchar_out,

       RECEIVE    = mchar_recv,

       SEND = mchar_send,

       STORAGE = extended

    );

   
    CREATE FUNCTION mchar(mchar, integer, boolean)

    RETURNS mchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE CAST (mchar as mchar)

    WITH FUNCTION mchar(mchar, integer, boolean) as IMPLICIT;

   
    CREATE FUNCTION mvarchar_in(cstring)

    RETURNS mvarchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_out(mvarchar)

    RETURNS cstring

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_send(mvarchar)

    RETURNS bytea

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_recv(internal)

    RETURNS mvarchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE TYPE mvarchar (

        INTERNALLENGTH = -1,

       INPUT = mvarchar_in,

       OUTPUT = mvarchar_out,

       RECEIVE    = mvarchar_recv,

       SEND = mvarchar_send,

       STORAGE = extended

    );

   
    CREATE FUNCTION mvarchar(mvarchar, integer, boolean)

    RETURNS mvarchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE CAST (mvarchar as mvarchar)

    WITH FUNCTION mvarchar(mvarchar, integer, boolean) as IMPLICIT;

   
    —Operations and functions

   
    CREATE FUNCTION length(mchar)

    RETURNS int4

    AS ‘$libdir/mchar’, ‘mchar_length’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION upper(mchar)

    RETURNS mchar

    AS ‘$libdir/mchar’, ‘mchar_upper’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION lower(mchar)

    RETURNS mchar

    AS ‘$libdir/mchar’, ‘mchar_lower’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_hash(mchar)

    RETURNS int4

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_concat(mchar, mchar)

    RETURNS    mchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE OPERATOR || (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_concat

    );

   
    CREATE FUNCTION mchar_like(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION like_escape(mchar, mchar)

    RETURNS mchar

    AS ‘$libdir/mchar’, ‘mchar_like_escape’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_notlike(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE OPERATOR ~~ (

       LEFTARG     =   mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_like,

       RESTRICT    =    likesel,

       JOIN        =    likejoinsel,

       NEGATOR        =    ‘!~~’

    );

   
    CREATE OPERATOR !~~ (

       LEFTARG     =   mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_notlike,

       RESTRICT    =    nlikesel,

       JOIN        =    nlikejoinsel,

       NEGATOR        =    ‘~~’

    );

   
    CREATE FUNCTION mchar_regexeq(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_regexne(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE OPERATOR ~ (

       LEFTARG     =   mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_regexeq,

       RESTRICT    =    regexeqsel,

       JOIN        =    regexeqjoinsel,

       NEGATOR        =    ‘!~’

    );

   
    CREATE OPERATOR !~ (

       LEFTARG     =   mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_regexne,

       RESTRICT    =    regexnesel,

       JOIN        =    regexnejoinsel,

       NEGATOR        =    ‘~’

    );

   
    CREATE FUNCTION similar_escape(mchar, mchar)

    RETURNS mchar

    AS ‘$libdir/mchar’, ‘mchar_similar_escape’

    LANGUAGE C IMMUTABLE;

   
    CREATE FUNCTION length(mvarchar)

    RETURNS int4

    AS ‘$libdir/mchar’, ‘mvarchar_length’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION upper(mvarchar)

    RETURNS mvarchar

    AS ‘$libdir/mchar’, ‘mvarchar_upper’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION lower(mvarchar)

    RETURNS mvarchar

    AS ‘$libdir/mchar’, ‘mvarchar_lower’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_hash(mvarchar)

    RETURNS int4

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_concat(mvarchar, mvarchar)

    RETURNS    mvarchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE OPERATOR || (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_concat

    );

   
    CREATE FUNCTION mvarchar_like(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION like_escape(mvarchar, mvarchar)

    RETURNS mvarchar

    AS ‘$libdir/mchar’, ‘mvarchar_like_escape’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_notlike(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE OPERATOR ~~ (

       LEFTARG     =   mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_like,

       RESTRICT    =    likesel,

       JOIN        =    likejoinsel,

       NEGATOR        =    ‘!~~’

    );

   
    CREATE OPERATOR !~~ (

       LEFTARG     =   mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_notlike,

       RESTRICT    =    nlikesel,

       JOIN        =    nlikejoinsel,

       NEGATOR        =    ‘~~’

    );

   
    CREATE FUNCTION mvarchar_regexeq(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_regexne(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE OPERATOR ~ (

       LEFTARG     =   mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_regexeq,

       RESTRICT    =    regexeqsel,

       JOIN        =    regexeqjoinsel,

       NEGATOR        =    ‘!~’

    );

   
    CREATE OPERATOR !~ (

       LEFTARG     =   mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_regexne,

       RESTRICT    =    regexnesel,

       JOIN        =    regexnejoinsel,

       NEGATOR        =    ‘~’

    );

   
    CREATE FUNCTION similar_escape(mvarchar, mvarchar)

    RETURNS mvarchar

    AS ‘$libdir/mchar’, ‘mvarchar_similar_escape’

    LANGUAGE C IMMUTABLE;

   
    CREATE FUNCTION substr (mchar, int4)

    RETURNS mchar

    AS ‘$libdir/mchar’, ‘mchar_substring_no_len’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION substr (mchar, int4, int4)

    RETURNS mchar

    AS ‘$libdir/mchar’, ‘mchar_substring’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION substr (mvarchar, int4)

    RETURNS mvarchar

    AS ‘$libdir/mchar’, ‘mvarchar_substring_no_len’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION substr (mvarchar, int4, int4)

    RETURNS mvarchar

    AS ‘$libdir/mchar’, ‘mvarchar_substring’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    — Comparing

    —    MCHAR

   
    CREATE FUNCTION mchar_icase_cmp(mchar, mchar)

    RETURNS int4

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_icase_eq(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_icase_ne(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_icase_lt(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_icase_le(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_icase_gt(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_icase_ge(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
   
    CREATE OPERATOR < (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_icase_lt,

       COMMUTATOR    =    ‘>’,

       NEGATOR        =    ‘>=’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR > (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_icase_gt,

       COMMUTATOR    =    ‘<‘,

       NEGATOR        =    ‘<=’,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR <= (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_icase_le,

       COMMUTATOR    =    ‘>=’,

       NEGATOR        =    ‘>’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR >= (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_icase_ge,

       COMMUTATOR    =    ‘<=’,

       NEGATOR        =    ‘<‘,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR = (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_icase_eq,

       COMMUTATOR    =    ‘=’,

       NEGATOR        =    ‘<>’,

       RESTRICT    =    eqsel,

       JOIN        =    eqjoinsel,

       SORT1        =    ‘<‘,

       SORT2        =    ‘<‘,

       HASHES

    );

   
    CREATE OPERATOR <> (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_icase_ne,

       COMMUTATOR    =    ‘<>’,

       NEGATOR        =    ‘=’,

       RESTRICT    =    neqsel,

       JOIN        =    neqjoinsel

    );

   
    CREATE FUNCTION mchar_case_cmp(mchar, mchar)

    RETURNS int4

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_case_eq(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_case_ne(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_case_lt(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_case_le(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_case_gt(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_case_ge(mchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
   
    CREATE OPERATOR &< (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_case_lt,

       COMMUTATOR    =    ‘&>’,

       NEGATOR        =    ‘&>=’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR &> (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_case_gt,

       COMMUTATOR    =    ‘&<‘,

       NEGATOR        =    ‘&<=’,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR &<= (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_case_le,

       COMMUTATOR    =    ‘&>=’,

       NEGATOR        =    ‘&>’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR &>= (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_case_ge,

       COMMUTATOR    =    ‘&<=’,

       NEGATOR        =    ‘&<‘,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR &= (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_case_eq,

       COMMUTATOR    =    ‘&=’,

       NEGATOR        =    ‘&<>’,

       RESTRICT    =    eqsel,

       JOIN        =    eqjoinsel,

       SORT1        =    ‘&<‘,

       SORT2        =    ‘&<‘

    );

   
    CREATE OPERATOR &<> (

       LEFTARG        =    mchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mchar_case_ne,

       COMMUTATOR    =    ‘&<>’,

       NEGATOR        =    ‘&=’,

       RESTRICT    =    neqsel,

       JOIN        =    neqjoinsel

    );

   
    —MVARCHAR

   
    CREATE FUNCTION mvarchar_icase_cmp(mvarchar, mvarchar)

    RETURNS int4

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_icase_eq(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_icase_ne(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_icase_lt(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_icase_le(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_icase_gt(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_icase_ge(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
   
    CREATE OPERATOR < (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_icase_lt,

       COMMUTATOR    =    ‘>’,

       NEGATOR        =    ‘>=’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR > (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_icase_gt,

       COMMUTATOR    =    ‘<‘,

       NEGATOR        =    ‘<=’,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR <= (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_icase_le,

       COMMUTATOR    =    ‘>=’,

       NEGATOR        =    ‘>’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR >= (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_icase_ge,

       COMMUTATOR    =    ‘<=’,

       NEGATOR        =    ‘<‘,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR = (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_icase_eq,

       COMMUTATOR    =    ‘=’,

       NEGATOR        =    ‘<>’,

       RESTRICT    =    eqsel,

       JOIN        =    eqjoinsel,

       SORT1        =    ‘<‘,

       SORT2        =    ‘<‘,

       HASHES

    );

   
    CREATE OPERATOR <> (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_icase_ne,

       COMMUTATOR    =    ‘<>’,

       NEGATOR        =    ‘=’,

       RESTRICT    =    neqsel,

       JOIN        =    neqjoinsel

    );

   
    CREATE FUNCTION mvarchar_case_cmp(mvarchar, mvarchar)

    RETURNS int4

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_case_eq(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_case_ne(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_case_lt(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_case_le(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_case_gt(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mvarchar_case_ge(mvarchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
   
    CREATE OPERATOR &< (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_case_lt,

       COMMUTATOR    =    ‘&>’,

       NEGATOR        =    ‘&>=’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR &> (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_case_gt,

       COMMUTATOR    =    ‘&<‘,

       NEGATOR        =    ‘&<=’,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR &<= (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_case_le,

       COMMUTATOR    =    ‘&>=’,

       NEGATOR        =    ‘&>’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR &>= (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_case_ge,

       COMMUTATOR    =    ‘&<=’,

       NEGATOR        =    ‘&<‘,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR &= (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_case_eq,

       COMMUTATOR    =    ‘&=’,

       NEGATOR        =    ‘&<>’,

       RESTRICT    =    eqsel,

       JOIN        =    eqjoinsel,

       SORT1        =    ‘&<‘,

       SORT2        =    ‘&<‘

    );

   
    CREATE OPERATOR &<> (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mvarchar_case_ne,

       COMMUTATOR    =    ‘&<>’,

       NEGATOR        =    ‘&=’,

       RESTRICT    =    neqsel,

       JOIN        =    neqjoinsel

    );

   
    —    MCHAR <> MVARCHAR

   
    CREATE FUNCTION mc_mv_icase_cmp(mchar, mvarchar)

    RETURNS int4

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mc_mv_icase_eq(mchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mc_mv_icase_ne(mchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mc_mv_icase_lt(mchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mc_mv_icase_le(mchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mc_mv_icase_gt(mchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mc_mv_icase_ge(mchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
   
    CREATE OPERATOR < (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mc_mv_icase_lt,

       COMMUTATOR    =    ‘>’,

       NEGATOR        =    ‘>=’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR > (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mc_mv_icase_gt,

       COMMUTATOR    =    ‘<‘,

       NEGATOR        =    ‘<=’,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR <= (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mc_mv_icase_le,

       COMMUTATOR    =    ‘>=’,

       NEGATOR        =    ‘>’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR >= (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mc_mv_icase_ge,

       COMMUTATOR    =    ‘<=’,

       NEGATOR        =    ‘<‘,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR = (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mc_mv_icase_eq,

       COMMUTATOR    =    ‘=’,

       NEGATOR        =    ‘<>’,

       RESTRICT    =    eqsel,

       JOIN        =    eqjoinsel,

       SORT1        =    ‘<‘,

       SORT2        =    ‘<‘

    );

   
    CREATE OPERATOR <> (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mc_mv_icase_ne,

       COMMUTATOR    =    ‘<>’,

       NEGATOR        =    ‘=’,

       RESTRICT    =    neqsel,

       JOIN        =    neqjoinsel

    );

   
    CREATE FUNCTION mc_mv_case_cmp(mchar, mvarchar)

    RETURNS int4

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mc_mv_case_eq(mchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mc_mv_case_ne(mchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mc_mv_case_lt(mchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mc_mv_case_le(mchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mc_mv_case_gt(mchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mc_mv_case_ge(mchar, mvarchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
   
    CREATE OPERATOR &< (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mc_mv_case_lt,

       COMMUTATOR    =    ‘&>’,

       NEGATOR        =    ‘&>=’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR &> (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mc_mv_case_gt,

       COMMUTATOR    =    ‘&<‘,

       NEGATOR        =    ‘&<=’,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR &<= (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mc_mv_case_le,

       COMMUTATOR    =    ‘&>=’,

       NEGATOR        =    ‘&>’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR &>= (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mc_mv_case_ge,

       COMMUTATOR    =    ‘&<=’,

       NEGATOR        =    ‘&<‘,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR &= (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mc_mv_case_eq,

       COMMUTATOR    =    ‘&=’,

       NEGATOR        =    ‘&<>’,

       RESTRICT    =    eqsel,

       JOIN        =    eqjoinsel,

       SORT1        =    ‘&<‘,

       SORT2        =    ‘&<‘

    );

   
    CREATE OPERATOR &<> (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mc_mv_case_ne,

       COMMUTATOR    =    ‘&<>’,

       NEGATOR        =    ‘&=’,

       RESTRICT    =    neqsel,

       JOIN        =    neqjoinsel

    );

   
    —    MVARCHAR <> MCHAR

   
    CREATE FUNCTION mv_mc_icase_cmp(mvarchar, mchar)

    RETURNS int4

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mv_mc_icase_eq(mvarchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mv_mc_icase_ne(mvarchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mv_mc_icase_lt(mvarchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mv_mc_icase_le(mvarchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mv_mc_icase_gt(mvarchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mv_mc_icase_ge(mvarchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
   
    CREATE OPERATOR < (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mv_mc_icase_lt,

       COMMUTATOR    =    ‘>’,

       NEGATOR        =    ‘>=’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR > (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mv_mc_icase_gt,

       COMMUTATOR    =    ‘<‘,

       NEGATOR        =    ‘<=’,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR <= (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mv_mc_icase_le,

       COMMUTATOR    =    ‘>=’,

       NEGATOR        =    ‘>’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR >= (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mv_mc_icase_ge,

       COMMUTATOR    =    ‘<=’,

       NEGATOR        =    ‘<‘,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR = (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mv_mc_icase_eq,

       COMMUTATOR    =    ‘=’,

       NEGATOR        =    ‘<>’,

       RESTRICT    =    eqsel,

       JOIN        =    eqjoinsel,

       SORT1        =    ‘<‘,

       SORT2        =    ‘<‘

    );

   
    CREATE OPERATOR <> (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mv_mc_icase_ne,

       COMMUTATOR    =    ‘<>’,

       NEGATOR        =    ‘=’,

       RESTRICT    =    neqsel,

       JOIN        =    neqjoinsel

    );

   
    CREATE FUNCTION mv_mc_case_cmp(mvarchar, mchar)

    RETURNS int4

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mv_mc_case_eq(mvarchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mv_mc_case_ne(mvarchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mv_mc_case_lt(mvarchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mv_mc_case_le(mvarchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mv_mc_case_gt(mvarchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mv_mc_case_ge(mvarchar, mchar)

    RETURNS bool

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
   
    CREATE OPERATOR &< (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mv_mc_case_lt,

       COMMUTATOR    =    ‘&>’,

       NEGATOR        =    ‘&>=’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR &> (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mv_mc_case_gt,

       COMMUTATOR    =    ‘&<‘,

       NEGATOR        =    ‘&<=’,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR &<= (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mv_mc_case_le,

       COMMUTATOR    =    ‘&>=’,

       NEGATOR        =    ‘&>’,

       RESTRICT    =    scalarltsel,

       JOIN        =    scalarltjoinsel

    );

   
    CREATE OPERATOR &>= (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mv_mc_case_ge,

       COMMUTATOR    =    ‘&<=’,

       NEGATOR        =    ‘&<‘,

       RESTRICT    =    scalargtsel,

       JOIN        =    scalargtjoinsel

    );

   
    CREATE OPERATOR &= (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mv_mc_case_eq,

       COMMUTATOR    =    ‘&=’,

       NEGATOR        =    ‘&<>’,

       RESTRICT    =    eqsel,

       JOIN        =    eqjoinsel,

       SORT1        =    ‘&<‘,

       SORT2        =    ‘&<‘

    );

   
    CREATE OPERATOR &<> (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mv_mc_case_ne,

       COMMUTATOR    =    ‘&<>’,

       NEGATOR        =    ‘&=’,

       RESTRICT    =    neqsel,

       JOIN        =    neqjoinsel

    );

   
    — MCHAR — VARCHAR operations

   
    CREATE FUNCTION mchar_mvarchar_concat(mchar, mvarchar)

    RETURNS    mvarchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE OPERATOR || (

       LEFTARG        =    mchar,

       RIGHTARG    =    mvarchar,

       PROCEDURE    =    mchar_mvarchar_concat

    );

   
    CREATE FUNCTION mvarchar_mchar_concat(mvarchar, mchar)

    RETURNS    mvarchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE OPERATOR || (

       LEFTARG        =    mvarchar,

       RIGHTARG    =    mchar,

       PROCEDURE    =    mvarchar_mchar_concat

    );

  &nb

CREATE FUNCTION mvarchar_mchar(mvarchar, integer, boolean)

    RETURNS mchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE CAST (mvarchar as mchar)

    WITH FUNCTION mvarchar_mchar(mvarchar, integer, boolean) as IMPLICIT;

   
    CREATE FUNCTION mchar_mvarchar(mchar, integer, boolean)

    RETURNS mvarchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE CAST (mchar as mvarchar)

    WITH FUNCTION mchar_mvarchar(mchar, integer, boolean) as IMPLICIT;

   
    — Aggregates

   
    CREATE FUNCTION mchar_larger(mchar, mchar)

    RETURNS mchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE AGGREGATE max (

       BASETYPE    =    mchar,

       SFUNC        =    mchar_larger,

       STYPE        =    mchar,

       SORTOP        =    ‘>’

    );

   
    CREATE FUNCTION mchar_smaller(mchar, mchar)

    RETURNS mchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE AGGREGATE min (

       BASETYPE    =    mchar,

       SFUNC        =    mchar_smaller,

       STYPE        =    mchar,

       SORTOP        =    ‘<‘

    );

   
    CREATE FUNCTION mvarchar_larger(mvarchar, mvarchar)

    RETURNS mvarchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE AGGREGATE max (

       BASETYPE    =    mvarchar,

       SFUNC        =    mvarchar_larger,

       STYPE        =    mvarchar,

       SORTOP        =    ‘>’

    );

   
    CREATE FUNCTION mvarchar_smaller(mvarchar, mvarchar)

    RETURNS mvarchar

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE AGGREGATE min (

       BASETYPE    =    mvarchar,

       SFUNC        =    mvarchar_smaller,

       STYPE        =    mvarchar,

       SORTOP        =    ‘<‘

    );

   
    — B-tree support

   
    CREATE OPERATOR CLASS mchar_icase_ops

    DEFAULT FOR TYPE mchar USING btree AS

            OPERATOR        1       <  ,

           OPERATOR        2       <= ,

           OPERATOR        3       =  ,

           OPERATOR        4       >= ,

           OPERATOR        5       >  ,

           FUNCTION        1       mchar_icase_cmp(mchar, mchar),

            OPERATOR        1       <  (mchar, mvarchar),

           OPERATOR        2       <= (mchar, mvarchar),

           OPERATOR        3       =  (mchar, mvarchar),

           OPERATOR        4       >= (mchar, mvarchar),

           OPERATOR        5       >  (mchar, mvarchar),

           FUNCTION        1       mc_mv_icase_cmp(mchar, mvarchar);

   
    CREATE OPERATOR CLASS mchar_icase_ops

    DEFAULT FOR TYPE mchar USING hash AS

           OPERATOR        1       =  ,

           FUNCTION        1       mchar_hash(mchar);

   
    CREATE OPERATOR CLASS mvarchar_icase_ops

    DEFAULT FOR TYPE mvarchar USING btree AS

            OPERATOR        1       <  ,

           OPERATOR        2       <= ,

           OPERATOR        3       =  ,

           OPERATOR        4       >= ,

           OPERATOR        5       >  ,

           FUNCTION        1       mvarchar_icase_cmp(mvarchar, mvarchar),

            OPERATOR        1       <  (mvarchar, mchar),

           OPERATOR        2       <= (mvarchar, mchar),

           OPERATOR        3       =  (mvarchar, mchar),

           OPERATOR        4       >= (mvarchar, mchar),

           OPERATOR        5       >  (mvarchar, mchar),

           FUNCTION        1       mv_mc_icase_cmp(mvarchar, mchar);

   
    CREATE OPERATOR CLASS mvarchar_icase_ops

    DEFAULT FOR TYPE mvarchar USING hash AS

           OPERATOR        1       =  ,

           FUNCTION        1       mvarchar_hash(mvarchar);

   
   
    — Index support for LIKE

   
    CREATE FUNCTION mchar_pattern_fixed_prefix(bool, internal, internal, internal, internal)

    RETURNS int4

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

   
    CREATE FUNCTION mchar_greaterstring(bool, internal)

    RETURNS internal

    AS ‘$libdir/mchar’

    LANGUAGE C IMMUTABLE RETURNS NULL ON NULL INPUT;

    —

    —

    —  FULLEQ

    —

    —

    CREATE OR REPLACE FUNCTION isfulleq_bool(bool, bool)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_bool(bool)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = bool,

       RIGHTARG    = bool,

       PROCEDURE    = isfulleq_bool,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS bool_fill_ops

     FOR TYPE bool USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_bool(bool);

   
    — For bytea

   
    CREATE OR REPLACE FUNCTION isfulleq_bytea(bytea, bytea)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_bytea(bytea)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = bytea,

       RIGHTARG    = bytea,

       PROCEDURE    = isfulleq_bytea,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS bytea_fill_ops

     FOR TYPE bytea USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_bytea(bytea);

   
    — For char

   
    CREATE OR REPLACE FUNCTION isfulleq_char(char, char)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_char(char)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = char,

       RIGHTARG    = char,

       PROCEDURE    = isfulleq_char,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS char_fill_ops

     FOR TYPE char USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_char(char);

   
    — For name

   
    CREATE OR REPLACE FUNCTION isfulleq_name(name, name)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_name(name)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = name,

       RIGHTARG    = name,

       PROCEDURE    = isfulleq_name,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS name_fill_ops

     FOR TYPE name USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_name(name);

   
    — For int8

   
    CREATE OR REPLACE FUNCTION isfulleq_int8(int8, int8)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_int8(int8)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = int8,

       RIGHTARG    = int8,

       PROCEDURE    = isfulleq_int8,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS int8_fill_ops

     FOR TYPE int8 USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_int8(int8);

   
    — For int2

   
    CREATE OR REPLACE FUNCTION isfulleq_int2(int2, int2)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_int2(int2)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = int2,

       RIGHTARG    = int2,

       PROCEDURE    = isfulleq_int2,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS int2_fill_ops

     FOR TYPE int2 USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_int2(int2);

   
    — For int2vector

   
    CREATE OR REPLACE FUNCTION isfulleq_int2vector(int2vector, int2vector)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_int2vector(int2vector)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = int2vector,

       RIGHTARG    = int2vector,

       PROCEDURE    = isfulleq_int2vector,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS int2vector_fill_ops

     FOR TYPE int2vector USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_int2vector(int2vector);

   
    — For int4

   
    CREATE OR REPLACE FUNCTION isfulleq_int4(int4, int4)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_int4(int4)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = int4,

       RIGHTARG    = int4,

       PROCEDURE    = isfulleq_int4,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS int4_fill_ops

     FOR TYPE int4 USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_int4(int4);

   
    — For text

   
    CREATE OR REPLACE FUNCTION isfulleq_text(text, text)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_text(text)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = text,

       RIGHTARG    = text,

       PROCEDURE    = isfulleq_text,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS text_fill_ops

     FOR TYPE text USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_text(text);

   
    — For oid

   
    CREATE OR REPLACE FUNCTION isfulleq_oid(oid, oid)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_oid(oid)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = oid,

       RIGHTARG    = oid,

       PROCEDURE    = isfulleq_oid,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS oid_fill_ops

     FOR TYPE oid USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_oid(oid);

   
    — For xid

   
    CREATE OR REPLACE FUNCTION isfulleq_xid(xid, xid)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_xid(xid)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = xid,

       RIGHTARG    = xid,

       PROCEDURE    = isfulleq_xid,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS xid_fill_ops

     FOR TYPE xid USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_xid(xid);

   
    — For cid

   
    CREATE OR REPLACE FUNCTION isfulleq_cid(cid, cid)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_cid(cid)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = cid,

       RIGHTARG    = cid,

       PROCEDURE    = isfulleq_cid,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS cid_fill_ops

     FOR TYPE cid USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_cid(cid);

   
    — For oidvector

   
    CREATE OR REPLACE FUNCTION isfulleq_oidvector(oidvector, oidvector)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_oidvector(oidvector)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = oidvector,

       RIGHTARG    = oidvector,

       PROCEDURE    = isfulleq_oidvector,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS oidvector_fill_ops

     FOR TYPE oidvector USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_oidvector(oidvector);

   
    — For float4

   
    CREATE OR REPLACE FUNCTION isfulleq_float4(float4, float4)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_float4(float4)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = float4,

       RIGHTARG    = float4,

       PROCEDURE    = isfulleq_float4,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS float4_fill_ops

     FOR TYPE float4 USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_float4(float4);

   
    — For float8

   
    CREATE OR REPLACE FUNCTION isfulleq_float8(float8, float8)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_float8(float8)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = float8,

       RIGHTARG    = float8,

       PROCEDURE    = isfulleq_float8,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS float8_fill_ops

     FOR TYPE float8 USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_float8(float8);

   
    — For abstime

   
    CREATE OR REPLACE FUNCTION isfulleq_abstime(abstime, abstime)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_abstime(abstime)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = abstime,

       RIGHTARG    = abstime,

       PROCEDURE    = isfulleq_abstime,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS abstime_fill_ops

     FOR TYPE abstime USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_abstime(abstime);

   
    — For reltime

   
    CREATE OR REPLACE FUNCTION isfulleq_reltime(reltime, reltime)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_reltime(reltime)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = reltime,

       RIGHTARG    = reltime,

       PROCEDURE    = isfulleq_reltime,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS reltime_fill_ops

     FOR TYPE reltime USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_reltime(reltime);

   
    — For macaddr

   
    CREATE OR REPLACE FUNCTION isfulleq_macaddr(macaddr, macaddr)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_macaddr(macaddr)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = macaddr,

       RIGHTARG    = macaddr,

       PROCEDURE    = isfulleq_macaddr,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS macaddr_fill_ops

     FOR TYPE macaddr USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_macaddr(macaddr);

   
    — For inet

   
    CREATE OR REPLACE FUNCTION isfulleq_inet(inet, inet)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_inet(inet)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = inet,

       RIGHTARG    = inet,

       PROCEDURE    = isfulleq_inet,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS inet_fill_ops

     FOR TYPE inet USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_inet(inet);

   
    — For cidr

   
    CREATE OR REPLACE FUNCTION isfulleq_cidr(cidr, cidr)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_cidr(cidr)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = cidr,

       RIGHTARG    = cidr,

       PROCEDURE    = isfulleq_cidr,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS cidr_fill_ops

     FOR TYPE cidr USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_cidr(cidr);

   
    — For varchar

   
    CREATE OR REPLACE FUNCTION isfulleq_varchar(varchar, varchar)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_varchar(varchar)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = varchar,

       RIGHTARG    = varchar,

       PROCEDURE    = isfulleq_varchar,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS varchar_fill_ops

     FOR TYPE varchar USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_varchar(varchar);

   
    — For date

   
    CREATE OR REPLACE FUNCTION isfulleq_date(date, date)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_date(date)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = date,

       RIGHTARG    = date,

       PROCEDURE    = isfulleq_date,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS date_fill_ops

     FOR TYPE date USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_date(date);

   
    — For time

   
    CREATE OR REPLACE FUNCTION isfulleq_time(time, time)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_time(time)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = time,

       RIGHTARG    = time,

       PROCEDURE    = isfulleq_time,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS time_fill_ops

     FOR TYPE time USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_time(time);

   
    — For timestamp

   
    CREATE OR REPLACE FUNCTION isfulleq_timestamp(timestamp, timestamp)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_timestamp(timestamp)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = timestamp,

       RIGHTARG    = timestamp,

       PROCEDURE    = isfulleq_timestamp,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS timestamp_fill_ops

     FOR TYPE timestamp USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_timestamp(timestamp);

   
    — For timestamptz

   
    CREATE OR REPLACE FUNCTION isfulleq_timestamptz(timestamptz, timestamptz)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_timestamptz(timestamptz)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = timestamptz,

       RIGHTARG    = timestamptz,

       PROCEDURE    = isfulleq_timestamptz,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS timestamptz_fill_ops

     FOR TYPE timestamptz USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_timestamptz(timestamptz);

   
    — For interval

   
    CREATE OR REPLACE FUNCTION isfulleq_interval(interval, interval)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_interval(interval)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = interval,

       RIGHTARG    = interval,

       PROCEDURE    = isfulleq_interval,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS interval_fill_ops

     FOR TYPE interval USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_interval(interval);

   
    — For timetz

   
    CREATE OR REPLACE FUNCTION isfulleq_timetz(timetz, timetz)

    RETURNS bool AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_timetz(timetz)

    RETURNS int4 AS ‘$libdir/fulleq’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
   
    CREATE OPERATOR == (

       LEFTARG        = timetz,

       RIGHTARG    = timetz,

       PROCEDURE    = isfulleq_timetz,

       COMMUTATOR    = ‘==’,

       RESTRICT    = eqsel,

       JOIN        = eqjoinsel,

       HASHES

    );

   
    CREATE OPERATOR CLASS timetz_fill_ops

     FOR TYPE timetz USING hash AS

       OPERATOR    1    ==,

       FUNCTION    1    fullhash_timetz(timetz);

   
    — For mchar

   
    CREATE OR REPLACE FUNCTION isfulleq_mchar(mchar, mchar)

    RETURNS bool AS ‘$libdir/mchar’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

     
    CREATE OR REPLACE FUNCTION fullhash_mchar(mchar)

    RETURNS int4 AS ‘$libdir/mchar’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OPERATOR == (

        LEFTARG     = mchar,

        RIGHTARG    = mchar,

        PROCEDURE   = isfulleq_mchar,

        COMMUTATOR  = ‘==’,

        RESTRICT    = eqsel,

        JOIN        = eqjoinsel,

        HASHES

    );

   
    CREATE OPERATOR CLASS mchar_fill_ops

     FOR TYPE mchar USING hash AS

        OPERATOR    1   ==,

        FUNCTION    1   fullhash_mchar(mchar);

   
    — For mvarchar

   
    CREATE OR REPLACE FUNCTION isfulleq_mvarchar(mvarchar, mvarchar)

    RETURNS bool AS ‘$libdir/mchar’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OR REPLACE FUNCTION fullhash_mvarchar(mvarchar)

    RETURNS int4 AS ‘$libdir/mchar’

    LANGUAGE C CALLED ON NULL INPUT IMMUTABLE;

   
    CREATE OPERATOR == (

        LEFTARG     = mvarchar,

        RIGHTARG    = mvarchar,

        PROCEDURE   = isfulleq_mvarchar,

        COMMUTATOR  = ‘==’,

        RESTRICT    = eqsel,

        JOIN        = eqjoinsel,

        HASHES

    );

   
    CREATE OPERATOR CLASS mvarchar_fill_ops

     FOR TYPE mvarchar USING hash AS

        OPERATOR    1   ==,

        FUNCTION    1   fullhash_mvarchar(mvarchar);

   
    CREATE OR REPLACE FUNCTION fasttruncate(text)

    RETURNS void AS ‘$libdir/fasttrun’

    LANGUAGE C RETURNS NULL ON NULL INPUT IMMUTABLE;

   
2007-06-01 18:07:25 WARNING:  there is no transaction in progress

2007-06-01 18:07:26 ERROR:  syntax error at or near «application» at character 24

2007-06-01 18:07:26 STATEMENT:  lock table pg_class in application share mode

2007-06-01 18:07:26 WARNING:  there is no transaction in progress

2007-06-01 18:07:26 ERROR:  syntax error at or near «(» at character 39

2007-06-01 18:07:26 STATEMENT:  create table Config (FileName mvarchar(128) not null primary key, Creation timestamp not null, Modified timestamp not null, Attributes int not null, DataSize int not null, BinaryData bytea not null)

2007-06-01 18:07:26 WARNING:  there is no transaction in progress