HeapTupletuple;

Form_pg_operatorform;

charoprkind;

ListCell*arg;

tuple=SearchSysCache1(OPEROID,ObjectIdGetDatum(node->opno));

oprkind=form->oprkind;

Assert((oprkind=='r'&&list_length(node->args)==1)||

(oprkind=='l'&&list_length(node->args)==1)||

Assert((oprkind=='l'&&list_length(node->args)==1)||

(oprkind=='b'&&list_length(node->args)==2));

appendStringInfoChar(buf,'(');

if (oprkind=='r'||oprkind=='b')

if (oprkind=='b')

{

arg=list_head(node->args);

deparseExpr(lfirst(arg),context);

deparseExpr(linitial(node->args),context);

appendStringInfoChar(buf,' ');

}

deparseOperatorName(buf,form);

if (oprkind=='l'||oprkind=='b')

{

arg=list_tail(node->args);

appendStringInfoChar(buf,' ');

deparseExpr(lfirst(arg),context);

}

appendStringInfoChar(buf,' ');

deparseExpr(llast(node->args),context);

appendStringInfoChar(buf,')');

<structfield>oprkind</structfield> <type>char</type>

</para>

<para>

<literal>b</literal> = infix (<quote>both</quote>), <literal>l</literal> = prefix

(<quote>left</quote>), <literal>r</literal> =postfix(<quote>right</quote>)

<literal>b</literal> = infixoperator(<quote>both</quote>),

or <literal>l</literal> =prefix operator(<quote>left</quote>)

</para></entry>

</row>

(references <link linkend="catalog-pg-type"><structname>pg_type</structname></link>.<structfield>oid</structfield>)

</para>

<para>

Type of the left operand

Type of the left operand (0 if none)

</para></entry>

</row>

</table>

<para>

Unusedcolumn contain zeroes. For example, <structfield>oprleft</structfield>

Unusedcolumns contain zeroes. For example, <structfield>oprleft</structfield>

is zero for a prefix operator.

</para>

<para>

The data type(s) of the operator's arguments (optionally

schema-qualified). Write <literal>NONE</literal> for the missing argument

of a prefixor postfixoperator.

of a prefix operator.

</para>

</listitem>

</varlistentry>

<refsynopsisdiv>

<synopsis>

ALTER OPERATOR <replaceable>name</replaceable> ( { <replaceable>left_type</replaceable> | NONE } ,{<replaceable>right_type</replaceable> | NONE } )

ALTER OPERATOR <replaceable>name</replaceable> ( { <replaceable>left_type</replaceable> | NONE } , <replaceable>right_type</replaceable> )

OWNER TO { <replaceable>new_owner</replaceable> | CURRENT_ROLE | CURRENT_USER | SESSION_USER }

ALTER OPERATOR <replaceable>name</replaceable> ( { <replaceable>left_type</replaceable> | NONE } ,{<replaceable>right_type</replaceable> | NONE } )

ALTER OPERATOR <replaceable>name</replaceable> ( { <replaceable>left_type</replaceable> | NONE } , <replaceable>right_type</replaceable> )

SET SCHEMA <replaceable>new_schema</replaceable>

ALTER OPERATOR <replaceable>name</replaceable> ( { <replaceable>left_type</replaceable> | NONE } ,{<replaceable>right_type</replaceable> | NONE } )

ALTER OPERATOR <replaceable>name</replaceable> ( { <replaceable>left_type</replaceable> | NONE } , <replaceable>right_type</replaceable> )

SET ( { RESTRICT = { <replaceable class="parameter">res_proc</replaceable> | NONE }

| JOIN = { <replaceable class="parameter">join_proc</replaceable> | NONE }

} [, ... ] )

<term><replaceable class="parameter">right_type</replaceable></term>

<listitem>

<para>

The data type of the operator's right operand; write

<literal>NONE</literal> if the operator has no right operand.

The data type of the operator's right operand.

</para>

</listitem>

</varlistentry>

<para>

In an <literal>OPERATOR</literal> clause,

the operand data type(s) of the operator, or <literal>NONE</literal> to

signify aleft-unary or right-unary operator. Unlike the comparable

signify aprefix operator. Unlike the comparable

syntax in <command>CREATE OPERATOR CLASS</command>, the operand data types

must always be specified.

</para>

<para>

The data type(s) of the operator's arguments (optionally

schema-qualified). Write <literal>NONE</literal> for the missing argument

of a prefixor postfixoperator.

of a prefix operator.

</para>

</listitem>

</varlistentry>

<para>

In an <literal>OPERATOR</literal> clause,

the operand data type(s) of the operator, or <literal>NONE</literal> to

signify aleft-unary or right-unary operator. The operand data

signify aprefix operator. The operand data

types can be omitted in the normal case where they are the same

as the operator class's data type.

</para>

</para>

<para>

At least one of <literal>LEFTARG</literal> and <literal>RIGHTARG</literal> must be defined. For

binary operators, both must be defined. For right unary

operators, only <literal>LEFTARG</literal> should be defined, while for left

unary operators only <literal>RIGHTARG</literal> should be defined.

</para>

<note>

<para>

Right unary, also called postfix, operators are deprecated and will be

removed in <productname>PostgreSQL</productname> version 14.

</para>

</note>

<para>

For binary operators, both <literal>LEFTARG</literal> and

<literal>RIGHTARG</literal> must be defined. For prefix operators only

<literal>RIGHTARG</literal> should be defined.

The <replaceable class="parameter">function_name</replaceable>

function must have been previously defined using <command>CREATE

FUNCTION</command> and must be defined to accept the correct number

<listitem>

<para>

The data type of the operator's left operand, if any.

This option would be omitted for aleft-unary operator.

This option would be omitted for aprefix operator.

</para>

</listitem>

</varlistentry>

<term><replaceable class="parameter">right_type</replaceable></term>

<listitem>

<para>

The data type of the operator's right operand, if any.

This option would be omitted for a right-unary operator.

The data type of the operator's right operand.

</para>

</listitem>

</varlistentry>

<refsynopsisdiv>

<synopsis>

DROP OPERATOR [ IF EXISTS ] <replaceable class="parameter">name</replaceable> ( { <replaceable class="parameter">left_type</replaceable> | NONE } ,{<replaceable class="parameter">right_type</replaceable> | NONE } ) [, ...] [ CASCADE | RESTRICT ]

DROP OPERATOR [ IF EXISTS ] <replaceable class="parameter">name</replaceable> ( { <replaceable class="parameter">left_type</replaceable> | NONE } , <replaceable class="parameter">right_type</replaceable> ) [, ...] [ CASCADE | RESTRICT ]

</synopsis>

</refsynopsisdiv>

<term><replaceable class="parameter">right_type</replaceable></term>

<listitem>

<para>

The data type of the operator's right operand; write

<literal>NONE</literal> if the operator has no right operand.

The data type of the operator's right operand.

</para>

</listitem>

</varlistentry>

</para>

<para>

Remove theleft unarybitwisecomplement operator

Remove the bitwise-complement prefix operator

<literal>~b</literal> for type <type>bit</type>:

<programlisting>

DROP OPERATOR ~ (none, bit);

</programlisting>

</para>

<para>

Remove the right unary factorial operator <literal>x!</literal>

for type <type>bigint</type>:

<programlisting>

DROP OPERATOR ! (bigint, none);

</programlisting></para>

<para>

Remove multiple operators in one command:

<programlisting>

DROP OPERATOR ~ (none, bit),! (bigint, none);

DROP OPERATOR ~ (none, bit),^ (integer, integer);

</programlisting></para>

</refsect1>

<para>

When working with non-SQL-standard operator names, you will usually

need to separate adjacent operators with spaces to avoid ambiguity.

For example, if you have defined aleft unary operator named <literal>@</literal>,

For example, if you have defined aprefix operator named <literal>@</literal>,

you cannot write <literal>X*@Y</literal>; you must write

<literal>X* @Y</literal> to ensure that

<productname>PostgreSQL</productname> reads it as two operator names

</indexterm>

<para>

There arethree possible syntaxes for an operator invocation:

There aretwo possible syntaxes for an operator invocation:

<simplelist>

<member><replaceable>expression</replaceable> <replaceable>operator</replaceable> <replaceable>expression</replaceable> (binary infix operator)</member>

<member><replaceable>operator</replaceable> <replaceable>expression</replaceable> (unary prefix operator)</member>

<member><replaceable>expression</replaceable> <replaceable>operator</replaceable> (unary postfix operator)</member>

</simplelist>

where the <replaceable>operator</replaceable> token follows the syntax

rules of <xref linkend="sql-syntax-operators"/>, or is one of the

<listitem>

<para>

<productname>PostgreSQL</productname> allows expressions with

prefixand postfix unary(one-argument) operators,

as well asbinary (two-argument) operators. Like functions, operators can

prefix (one-argument) operators,

as well asinfix (two-argument) operators. Like functions, operators can

be overloaded, so the same problem of selecting the right operator

exists.

</para>

<para>

If one argument of a binary operator invocation is of the <type>unknown</type> type,

then assume it is the same type as the other argument for this check.

Invocations involving two <type>unknown</type> inputs, or aunary operator

Invocations involving two <type>unknown</type> inputs, or aprefix operator

with an <type>unknown</type> input, will never find a match at this step.

</para>

</step>

</para>

<para>

<productname>PostgreSQL</productname> supportsleft unary, right

unary,andbinary operators. Operators can be

<productname>PostgreSQL</productname> supportsprefix

andinfix operators. Operators can be

overloaded;<indexterm><primary>overloading</primary><secondary>operators</secondary></indexterm>

that is, the same operator name can be used for different operators

that have different numbers and types of operands. When a query is

</para>

<para>

We've shown how to create a binary operator here. To createunary

operators, just omitone of<literal>leftarg</literal> (for left unary) or

<literal>rightarg</literal> (for right unary).The <literal>function</literal>

We've shown how to create a binary operator here. To createa prefix

operator, just omitthe<literal>leftarg</literal>.

The <literal>function</literal>

clause and the argument clauses are the only required items in

<command>CREATE OPERATOR</command>. The <literal>commutator</literal>

clause shown in the example is an optional hint to the query

<para>

Unlike commutators, a pair of unary operators could validly be marked

as each other's negators; that would mean (A x) equals NOT (B x)

for all x, or the equivalent for right unary operators.

for all x.

</para>

<para>

OpernameGetCandidates(List*names,charoprkind,boolmissing_schema_ok)

values[Anum_pg_operator_oprname-1]=NameGetDatum(&oname);

values[Anum_pg_operator_oprnamespace-1]=ObjectIdGetDatum(operatorNamespace);

values[Anum_pg_operator_oprowner-1]=ObjectIdGetDatum(GetUserId());

values[Anum_pg_operator_oprkind-1]=CharGetDatum(leftTypeId ?(rightTypeId ?'b' :'r') :'l');

values[Anum_pg_operator_oprkind-1]=CharGetDatum(leftTypeId ?'b' :'l');

values[Anum_pg_operator_oprcanmerge-1]=BoolGetDatum(false);

values[Anum_pg_operator_oprcanhash-1]=BoolGetDatum(false);

values[Anum_pg_operator_oprleft-1]=ObjectIdGetDatum(leftTypeId);

values[Anum_pg_operator_oprname-1]=NameGetDatum(&oname);

values[Anum_pg_operator_oprnamespace-1]=ObjectIdGetDatum(operatorNamespace);

values[Anum_pg_operator_oprowner-1]=ObjectIdGetDatum(GetUserId());

values[Anum_pg_operator_oprkind-1]=CharGetDatum(leftTypeId ?(rightTypeId ?'b' :'r') :'l');

values[Anum_pg_operator_oprkind-1]=CharGetDatum(leftTypeId ?'b' :'l');

values[Anum_pg_operator_oprcanmerge-1]=BoolGetDatum(canMerge);

values[Anum_pg_operator_oprcanhash-1]=BoolGetDatum(canHash);

values[Anum_pg_operator_oprleft-1]=ObjectIdGetDatum(leftTypeId);

if (typeName2)

typeId2=typenameTypeId(NULL,typeName2);

if (!OidIsValid(typeId1)&& !OidIsValid(typeId2))

ereport(ERROR,

(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

errmsg("at least one of leftarg or rightarg must be specified")));

errmsg("operator argument types must be specified")));

if (!OidIsValid(typeId2))

ereport(ERROR,

(errcode(ERRCODE_INVALID_FUNCTION_DEFINITION),

errmsg("operator right argument type must be specified"),

errdetail("Postfix operators are not supported.")));

if (typeName1)

{

}

{

printf("%s ", ((opname!=NULL) ?opname :"(invalid operator)"));

print_expr(get_leftop((constExpr*)e),rtable);

}