The name of a function, created by CREATE FUNCTION,
which converts data from its external form to the type's
internal form.

OUTPUT output_function

The name of a function, created by CREATE FUNCTION,
which converts data from its internal form to a form
suitable for display.

element

The type being created is an array; this specifies the
type of the array elements.

delimiter

The delimiter character for the array.

default

The default text to be displayed to indicate "data not
present"

send_function

The name of a function, created by CREATE FUNCTION,
which converts data of this type into a form suitable for
transmission to another machine.

receive_function

The name of a function, created by CREATE FUNCTION,
which converts data of this type from a form suitable for
transmission from another machine to internal form.

Outputs

CREATE

Message returned if the type is successfully
created.

Description

CREATE TYPE allows the user to register
a new user data type with Postgres for use in the current data
base. The user who defines a type becomes its owner. typename is the name of the new type and
must be unique within the types defined for this database.

CREATE TYPE requires the registration
of two functions (using create function) before defining the
type. The representation of a new base type is determined by
input_function, which converts
the type's external representation to an internal representation
usable by the operators and functions defined for the type.
Naturally, output_function
performs the reverse transformation. Both the input and output
functions must be declared to take one or two arguments of type
"opaque".

New base data types can be fixed length, in which case
internallength is a positive
integer, or variable length, in which case Postgres assumes that
the new type has the same format as the Postgres-supplied data
type, "text". To indicate that a type is
variable-length, set internallength to VARIABLE. The external representation is
similarly specified using the externallength keyword.

To indicate that a type is an array and to indicate that a
type has array elements, indicate the type of the array element
using the element keyword. For example, to define an array of 4
byte integers ("int4"), specify

ELEMENT = int4

To indicate the delimiter to be used on arrays of this type,
delimiter can be set to a
specific character. The default delimiter is the comma
(",").

A default value is optionally available in case a user wants
some specific bit pattern to mean "data not present." Specify the
default with the DEFAULT keyword.

The optional functions send_function and receive_function are used when the
application program requesting Postgres services resides on a
different machine. In this case, the machine on which Postgres
runs may use a format for the data type different from that used
on the remote machine. In this case it is appropriate to convert
data items to a standard form when sending from the server to the
client and converting from the standard format to the machine
specific format when the server receives the data from the
client. If these functions are not specified, then it is assumed
that the internal format of the type is acceptable on all
relevant machine architectures. For example, single characters do
not have to be converted if passed from a Sun-4 to a DECstation,
but many other types do.

The optional flag, PASSEDBYVALUE,
indicates that operators and functions which use this data type
should be passed an argument by value rather than by reference.
Note that you may not pass by value types whose internal
representation is more than four bytes.

For new base types, a user can define operators, functions and
aggregates using the appropriate facilities described in this
section.

Array Types

Two generalized built-in functions, array_in and array_out,
exist for quick creation of variable-length array types. These
functions operate on arrays of any existing Postgres type.

Large Object Types

A "regular" Postgres type can only be 8192 bytes in length.
If you need a larger type you must create a Large Object type.
The interface for these types is discussed at length in
The PostgreSQL Programmer's Guide. The
length of all large object types is always VARIABLE.

Examples

This command creates the box data type and then uses the type
in a class definition:

Restrictions

Type names cannot begin with the underscore character ("_")
and can only be 31 characters long. This is because Postgres
silently creates an array type for each base type with a name
consisting of the base type's name prepended with an
underscore.

Notes

Refer to DROP TYPE to remove an
existing type.

See also CREATE FUNCTION, CREATE OPERATOR and the chapter on Large Objects
in the PostgreSQL Programmer's
Guide.