The PostgreSQL type system
contains a number of special-purpose entries that are
collectively called pseudo-types. A
pseudo-type cannot be used as a column data type, but it can be
used to declare a function's argument or result type. Each of the
available pseudo-types is useful in situations where a function's
behavior does not correspond to simply taking or returning a
value of a specific SQL data
type. Table 8-23
lists the existing pseudo-types.

Indicates that a function accepts or returns a
null-terminated C string.

internal

Indicates that a function accepts or returns a
server-internal data type.

language_handler

A procedural language call handler is declared to
return language_handler.

record

Identifies a function returning an unspecified row
type.

trigger

A trigger function is declared to return trigger.

void

Indicates that a function returns no value.

opaque

An obsolete type name that formerly served all the
above purposes.

Functions coded in C (whether built-in or dynamically loaded)
can be declared to accept or return any of these pseudo data
types. It is up to the function author to ensure that the
function will behave safely when a pseudo-type is used as an
argument type.

Functions coded in procedural languages can use pseudo-types
only as allowed by their implementation languages. At present the
procedural languages all forbid use of a pseudo-type as argument
type, and allow only void and record as a result type (plus trigger when the function is used as a trigger). Some
also support polymorphic functions using the types anyarray, anyelement,
anyenum, and anynonarray.

The internal pseudo-type is used to
declare functions that are meant only to be called internally by
the database system, and not by direct invocation in an
SQL query. If a function has
at least one internal-type argument then it
cannot be called from SQL. To
preserve the type safety of this restriction it is important to
follow this coding rule: do not create any function that is
declared to return internal unless it has
at least one internal argument.