Установил 8.1 с эмулятором HASP, потом влепил на ту же машину PostgreSQL 8.2, при попытке создания базы в 1CV8 Servers получается ошибка:
Ошибка создания информационной базы:
Ошибка информационной базы
Ошибка СУБД:
Error: syntax error at or near "(" at character 39

Что может быть не так?

(0) ИМХО: проблема в платформе. Приходится иметь дело с Delphi+PostgreSQL, такое частенько встречаю. Это синтаксическая ошибка, т.е. ошибка в тексте запроса

+(1) Эту ошибку выдает PostgreSQL

Как решить такую проблему???

(1) Спасибо. Разъяснил, утешил...
у нас такая же ошибка. Я думал, это где то в исходнике, при генерации пакета инсталляции . Все устанавливаем из диска от поставщика.
(0)А PostgreSQL на чем? Windows или Linux?

Windows XP SP2 RUS, потом предполагается установка на 2003.

(5)у нас на Linux, при формировании самой базы из клиента, такая штука вылетает. Офигеть. Где то у них косяк. А мы грешили ни Linux.

(3-6). ОС здесь ни при чем, синтаксис SQL-языка един, правда существует множество его диалектов и модификаций, и не важно Linux, Windows 98/2000/xp/2003... Дело в том, что при создании новой базы платформа 1С посылает серверу PostgreSQL SQL запросы на создание базы + в ней таблицы, индесы, секуенсы, триггеры, процедуры и т.д. ИМХО: где-то в каком-то из этих запросов разработчики влепили или ненужную скобку (это которая возле 39 символа текста запроса) или возле это скобки ошибка. Естетсвенно, нарушен синтаксис запроса + как следствие PostgreSQL посылает подальше. Так что, ребята, не парьтесь, это не ваша проблема. Повторяю, это лишь мое мнение, т.к. сам такие ошибки при разработке СУБД леплю, сразу и узнал.

(7) Как человек, который допускает такие же ошибки, ты можешь сказать, как быть в таком случае? Что можно сделать?

Я не парюсь. Отложил до лучших времен. Вот только как 1-эсники узнают об этом глюке?

(8) Если тексты этих запросов платформа берет из какого-нидь ресурсного файла, который не закриптован и его можно вычислтить и подправить (конечно, при условии, что 1С и УК РФ не будут против), тогда нет проблем. В других случаях могу сказать "упс", ждем-с релиза с иправлением этой "опечатки"

Кстати, а какой релиз-то? Можно попробовать (только попробовать!!!) взять предыдущий релиз платформы, в котором база создается без проблем, на нем создать, а потом установить эту платформу и поключить к созданной базе. Не думаю, что структура базы будет отличаться в релизах

(10) (11) Релиз 8.1.6.38... Других нема))

(12) Если есть подписка на ИТС, стяни с сайта 1С предыдущий релиз, он, по-моему базы без проблем создает.

(12) Внимательнее смотри (1) )))))
А можно как-то подправить создаваемую базу (он же не смотря на ошибку создает ее!) так, чтобы все это дело заработало?

(14) Надо очень хорошо знать структуру базы, которую создает платформа 1С 8.1, думаю что ее даже не все создатели 1С 8.1 знают. Ответ: теоретически "да", практически "нет". А после это ошибки хоть какие-то намеки на созданную базу в pgAdminIII есть?

(15) Да, база создается, но при попытке ее подключить 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

Мля! Ты еще сюда энциклопедию скопировал бы.
У нас Релиз 8.1.7.37 и тоже трабла такая же

В конце как раз ошибка и отмечена.

(19) Статей тут и так хватает, а решения этой проблемы нет.

А где он записывается, при создании базы?

(22) в папке Postgresql\data\pg_log

насколько я понимаю весь приведенный выше текст можно ввести в query и результат должен быть таким же?
вот что получаем в результате таких действий:

NOTICE:  type "mchar" is not yet defined
DETAIL:  Creating a shell type definition.

ERROR: could not access file "$libdir/mchar": No such file or directory
SQL state: 58P01

Да, именно так. Но надо потом еще действия моделировать. Дурдом какой то.

(24) Как это моделировать?

А название базы можно сюда? Или оно есть в постах, но влом читать все.

идите Вы так сказать в ... назовем это "жопой".... не надо про эмуляторы