<!-- $PostgreSQL: pgsql/doc/src/sgml/catalogs.sgml,v 2.179 2008/10/17 22:10:29 tgl Exp $ -->

<!-- $PostgreSQL: pgsql/doc/src/sgml/catalogs.sgml,v 2.180 2008/10/31 08:39:19 heikki Exp $ -->

<!--

Documentation of the system catalogs, directed toward PostgreSQL developers

-->

cannot be deduced from some generic rule. For example, casting between a

domain and its base type is not explicitly represented in

<structname>pg_cast</structname>. Another important exception is that

<quote>I/O conversion casts</>, those performed using a data type's own

I/O functions to convert to or from <type>text</> or other string types,

are not explicitly represented in <structname>pg_cast</structname>.

<quote>automatic I/O conversion casts</>, those performed using a data

type's own I/O functions to convert to or from <type>text</> or other

string types, are not explicitly represented in

<structname>pg_cast</structname>.

</para>

<table>

<entry><literal><link linkend="catalog-pg-proc"><structname>pg_proc</structname></link>.oid</literal></entry>

<entry>

The OID of the function to use to perform this cast. Zero is

stored if the data types are binary coercible (that is, no

run-time operation is needed to perform the cast)

stored if the cast method doesn't require a function.

</entry>

</row>

other cases

</entry>

</row>

<row>

<entry><structfield>castmethod</structfield></entry>

<entry><type>char</type></entry>

<entry></entry>

<entry>

Indicates how the cast is performed.

<literal>f</> means that the function specified in the <structfield>castfunc</> field is used.

<literal>i</> means that the input/output functions are used.

<literal>b</> means that the types are binary-coercible, thus no conversion is required

</entry>

</row>

</tbody>

</tgroup>

</table>

<!-- $PostgreSQL: pgsql/doc/src/sgml/ref/create_cast.sgml,v 1.29 2008/07/30 21:23:17 tgl Exp $ -->

<!-- $PostgreSQL: pgsql/doc/src/sgml/ref/create_cast.sgml,v 1.30 2008/10/31 08:39:20 heikki Exp $ -->

<refentry id="SQL-CREATECAST">

<refmeta>

CREATE CAST (<replaceable>sourcetype</replaceable> AS <replaceable>targettype</replaceable>)

WITHOUT FUNCTION

[ AS ASSIGNMENT | AS IMPLICIT ]

CREATE CAST (<replaceable>sourcetype</replaceable> AS <replaceable>targettype</replaceable>)

WITH INOUT

[ AS ASSIGNMENT | AS IMPLICIT ]

</synopsis>

</refsynopsisdiv>

binary compatible.)

</para>

<para>

You can define a cast as an <firstterm>I/O conversion cast</> using

the <literal>WITH INOUT</literal> syntax. An I/O conversion cast is

performed by invoking the output function of the source data type, and

passing the result to the input function of the target data type.

</para>

<para>

By default, a cast can be invoked only by an explicit cast request,

that is an explicit <literal>CAST(<replaceable>x</> AS

</listitem>

</varlistentry>

<varlistentry>

<term><literal>WITH INOUT</literal></term>

<listitem>

<para>

Indicates that the cast is an I/O conversion cast, performed by

invoking the output function of the source data type, and passing the

result to the input function of the target data type.

</para>

</listitem>

</varlistentry>

<varlistentry>

<term><literal>AS ASSIGNMENT</literal></term>

It is normally not necessary to create casts between user-defined types

and the standard string types (<type>text</>, <type>varchar</>, and

<type>char(<replaceable>n</>)</type>, as well as user-defined types that

are defined to be in the string category). <productname>PostgreSQL</> will

automatically handle a cast to a string type by invoking the other

type's output function, or conversely handle a cast from a string type

by invoking the other type's input function. These

automatically-provided casts are known as <firstterm>I/O conversion

casts</>. I/O conversion casts to string types are treated as

assignment casts, while I/O conversion casts from string types are

are defined to be in the string category). <productname>PostgreSQL</>

provides automatic I/O conversion casts for that. The automatic casts to

string types are treated as assignment casts, while the automatic casts

from string types are

explicit-only. You can override this behavior by declaring your own

cast to replace anI/O conversion cast, but usually the only reason to

cast to replace anautomatic cast, but usually the only reason to

do so is if you want the conversion to be more easily invokable than the

standard assignment-only or explicit-only setting. Another possible

reason is that you want the conversion to behave differently from the

Oidfuncid;

intnargs;

charcastcontext;

charcastmethod;

Relationrelation;

HeapTupletuple;

Datumvalues[Natts_pg_cast];

format_type_be(sourcetypeid),

format_type_be(targettypeid))));

if (stmt->func!=NULL)

castmethod=COERCION_METHOD_FUNCTION;

elseif(stmt->inout)

castmethod=COERCION_METHOD_INOUT;

castmethod=COERCION_METHOD_BINARY;

if (castmethod==COERCION_METHOD_FUNCTION)

{

Form_pg_procprocstruct;

ReleaseSysCache(tuple);

}

{

funcid=InvalidOid;

nargs=0;

}

if (castmethod==COERCION_METHOD_BINARY)

{

int16typ1len;

int16typ2len;

chartyp1align;

chartyp2align;

funcid=InvalidOid;

nargs=0;

values[Anum_pg_cast_casttarget-1]=ObjectIdGetDatum(targettypeid);

values[Anum_pg_cast_castfunc-1]=ObjectIdGetDatum(funcid);

values[Anum_pg_cast_castcontext-1]=CharGetDatum(castcontext);

values[Anum_pg_cast_castmethod-1]=CharGetDatum(castmethod);

MemSet(nulls,' ',Natts_pg_cast);

COPY_NODE_FIELD(targettype);

COPY_NODE_FIELD(func);

COPY_SCALAR_FIELD(context);

COPY_SCALAR_FIELD(inout);

returnnewnode;

}

COMPARE_NODE_FIELD(targettype);

COMPARE_NODE_FIELD(func);

COMPARE_SCALAR_FIELD(context);

COMPARE_SCALAR_FIELD(inout);

return true;

}

n->targettype =$6;

n->func =$10;

n->context = (CoercionContext)$11;

n->inout =false;

$$ = (Node *)n;

}

| CREATE CAST'(' Typename AS Typename')'

n->targettype =$6;

n->func =NULL;

n->context = (CoercionContext)$10;

n->inout =false;

$$ = (Node *)n;

}

| CREATE CAST'(' Typename AS Typename')'

WITH INOUT cast_context

{

CreateCastStmt *n = makeNode(CreateCastStmt);

n->sourcetype =$4;

n->targettype =$6;

n->func =NULL;

n->context = (CoercionContext)$10;

n->inout =true;

$$ = (Node *)n;

}

;

if (ccontext >=castcontext)

{

*funcid=castForm->castfunc;

if (OidIsValid(*funcid))

result=COERCION_PATH_FUNC;

result=COERCION_PATH_RELABELTYPE;

switch (castForm->castmethod)

{

caseCOERCION_METHOD_FUNCTION:

result=COERCION_PATH_FUNC;

*funcid=castForm->castfunc;

break;

caseCOERCION_METHOD_INOUT:

result=COERCION_PATH_COERCEVIAIO;

break;

caseCOERCION_METHOD_BINARY:

result=COERCION_PATH_RELABELTYPE;

break;

default:

elog(ERROR,"unrecognized castmethod: %d",

(int)castForm->castmethod);

break;

}

}

ReleaseSysCache(tuple);

inti_casttarget;

inti_castfunc;

inti_castcontext;

inti_castmethod;

selectSourceSchema("pg_catalog");

if (g_fout->remoteVersion >=70300)

if (g_fout->remoteVersion >=80400)

{

appendPQExpBuffer(query,"SELECT tableoid, oid, "

"FROM pg_cast ORDER BY 3,4");

}

elseif (g_fout->remoteVersion >=70300)

{

appendPQExpBuffer(query,"SELECT tableoid, oid, "

"FROM pg_cast ORDER BY 3,4");

}

{

appendPQExpBuffer(query,"SELECT 0 as tableoid, p.oid, "

i_casttarget=PQfnumber(res,"casttarget");

i_castfunc=PQfnumber(res,"castfunc");

i_castcontext=PQfnumber(res,"castcontext");

i_castmethod=PQfnumber(res,"castmethod");

for (i=0;i<ntups;i++)

{

castinfo[i].casttarget=atooid(PQgetvalue(res,i,i_casttarget));

castinfo[i].castfunc=atooid(PQgetvalue(res,i,i_castfunc));

castinfo[i].castcontext=*(PQgetvalue(res,i,i_castcontext));

castinfo[i].castmethod=*(PQgetvalue(res,i,i_castmethod));

getFormattedTypeName(cast->castsource,zeroAsNone),

getFormattedTypeName(cast->casttarget,zeroAsNone));

if (!OidIsValid(cast->castfunc))

appendPQExpBuffer(defqry,"WITHOUT FUNCTION");

switch(cast->castmethod)

{

appendPQExpBuffer(defqry,"WITH FUNCTION %s.",

fmtId(funcInfo->dobj.namespace->dobj.name));

appendPQExpBuffer(defqry,"%s",

format_function_signature(funcInfo, true));

caseCOERCION_METHOD_BINARY:

appendPQExpBuffer(defqry,"WITHOUT FUNCTION");

break;

caseCOERCION_METHOD_INOUT:

appendPQExpBuffer(defqry,"WITH INOUT");

break;

caseCOERCION_METHOD_FUNCTION:

appendPQExpBuffer(defqry,"WITH FUNCTION %s.",

fmtId(funcInfo->dobj.namespace->dobj.name));

appendPQExpBuffer(defqry,"%s",

format_function_signature(funcInfo, true));

break;

default:

write_msg(NULL,"WARNING: bogus value in pg_cast.castmethod field\n");

}

if (cast->castcontext=='a')