<!--

$PostgreSQL: pgsql/doc/src/sgml/ref/drop_operator.sgml,v 1.23 2003/11/29 19:51:38 pgsql Exp $

$PostgreSQL: pgsql/doc/src/sgml/ref/drop_operator.sgml,v 1.24 2003/12/02 00:26:59 tgl Exp $

PostgreSQL documentation

-->

<para>

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

for type <type>integer</type>:

for type <type>bigint</type>:

<programlisting>

DROP OPERATOR ! (integer, none);

DROP OPERATOR ! (bigint, none);

</programlisting>

</para>

</refsect1>

<!--

$PostgreSQL: pgsql/doc/src/sgml/typeconv.sgml,v 1.40 2003/12/01 21:53:15 momjian Exp $

$PostgreSQL: pgsql/doc/src/sgml/typeconv.sgml,v 1.41 2003/12/02 00:26:59 tgl Exp $

-->

<chapter Id="typeconv">

</example>

<example>

<title>Absolute-Value andFactorial Operator Type Resolution</title>

<title>Absolute-Value andNegation Operator Type Resolution</title>

<para>

The <productname>PostgreSQL</productname> operator catalog has several

ERROR: "-4.5e500" is out of range for type double precision

</screen>

</para>

<para>

On the other hand, the prefix operator <literal>~</> (bitwise negation)

is defined only for integer data types, not for <type>float8</type>. So, if we

try a similar case with <literal>~</>, we get:

<screen>

SELECT ~ '20' AS "negation";

ERROR: operator is not unique: ~ "unknown"

HINT: Could not choose a best candidate operator. You may need to add explicit

type casts.

</screen>

This happens because the system can't decide which of the several

possible <literal>~</> operators should be preferred. We can help

it out with an explicit cast:

<screen>

SELECT ~ CAST('20' AS int8) AS "negation";

negation

----------

-21

(1 row)

</screen>

</para>

</example>

</sect1>

numeric_fac(PG_FUNCTION_ARGS)

{

int64num=PG_GETARG_INT64(0);

NumericVarcount;

Numericres;

NumericVarfact;

NumericVarzerovar;

NumericVarresult;

Numericres;

if(num<1) {

if (num <=1)

{

res=make_result(&const_one);

PG_RETURN_NUMERIC(res);

}

init_var(&fact);

init_var(&count);

init_var(&result);

init_var(&zerovar);

zero_var(&zerovar);

int8_to_numericvar((int64)num,&result);

set_var_from_var(&const_one,&count);

for(num=num-1;num>0;num--) {

set_var_from_var(&result,&count);

int8_to_numericvar(num,&result);

int8_to_numericvar((int64)num,&fact);

for (num=num-1;num>1;num--)

{

int8_to_numericvar(num,&fact);

mul_var(&count,&fact,&result,count.dscale+fact.dscale);

mul_var(&result,&fact,&result,0);

}

res=make_result(&count);

res=make_result(&result);

free_var(&count);

free_var(&fact);

free_var(&result);

free_var(&zerovar);

PG_RETURN_NUMERIC(res);

}