Man Linux: Main Page and Category List


       CREATE CAST - define a new cast


       CREATE CAST (sourcetype AS targettype)
           WITH FUNCTION funcname (argtypes)

       CREATE CAST (sourcetype AS targettype)

       CREATE CAST (sourcetype AS targettype)
           WITH INOUT


       CREATE  CAST  defines  a  new  cast.  A cast specifies how to perform a
       conversion between two data types. For example:

       SELECT CAST(42 AS float8);

       converts  the  integer  constant  42  to  type  float8  by  invoking  a
       previously  specified  function,  in  this  case  float8(int4).  (If no
       suitable cast has been defined, the conversion fails.)

       Two types can be binary coercible, which means that the conversion  can
       be  performed ‘‘for free’’ without invoking any function. This requires
       that corresponding values use the  same  internal  representation.  For
       instance,  the  types  text and varchar are binary coercible both ways.
       Binary coercibility is not necessarily a  symmetric  relationship.  For
       example,  the  cast  from  xml to text can be performed for free in the
       present implementation, but the reverse direction requires  a  function
       that  performs  at  least  a  syntax  check. (Two types that are binary
       coercible both ways are also referred to as binary compatible.)

       You can define a cast as an I/O conversion cast using  the  WITH  INOUT
       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.

       By  default,  a  cast  can be invoked only by an explicit cast request,
       that is an explicit CAST(x AS typename) or x::typename construct.

       If the cast is marked AS ASSIGNMENT then it can be  invoked  implicitly
       when  assigning  a  value  to  a  column  of the target data type.  For
       example, supposing that foo.f1 is a column of type text, then:

       INSERT INTO foo (f1) VALUES (42);

       will be allowed if the cast from type integer to type text is marked AS
       ASSIGNMENT,  otherwise not.  (We generally use the term assignment cast
       to describe this kind of cast.)

       If the cast is marked AS IMPLICIT then it can be invoked implicitly  in
       any  context,  whether  assignment  or internally in an expression. (We
       generally use the term implicit cast to describe this  kind  of  cast.)
       For example, consider this query:

       SELECT 2 + 4.0;

       The  parser  initially marks the constants as being of type integer and
       numeric respectively. There is no integer +  numeric  operator  in  the
       system  catalogs, but there is a numeric + numeric operator.  The query
       will therefore succeed if a cast from integer to numeric  is  available
       and  is marked AS IMPLICIT — which in fact it is. The parser will apply
       the implicit cast and resolve the query as if it had been written

       SELECT CAST ( 2 AS numeric ) + 4.0;

       Now, the catalogs also provide a cast from numeric to integer. If  that
       cast  were marked AS IMPLICIT — which it is not — then the parser would
       be faced  with  choosing  between  the  above  interpretation  and  the
       alternative of casting the numeric constant to integer and applying the
       integer + integer operator. Lacking any knowledge of  which  choice  to
       prefer, it would give up and declare the query ambiguous. The fact that
       only one of the two casts is implicit is the way in which we teach  the
       parser  to  prefer resolution of a mixed numeric-and-integer expression
       as numeric; there is no built-in knowledge about that.

       It is wise to be conservative  about  marking  casts  as  implicit.  An
       overabundance  of implicit casting paths can cause PostgreSQL to choose
       surprising interpretations of commands, or  to  be  unable  to  resolve
       commands  at all because there are multiple possible interpretations. A
       good rule of thumb is to make a  cast  implicitly  invokable  only  for
       information-preserving   transformations  between  types  in  the  same
       general type category. For example, the cast  from  int2  to  int4  can
       reasonably  be  implicit,  but  the  cast  from  float8  to int4 should
       probably be assignment-only. Cross-type-category casts, such as text to
       int4, are best made explicit-only.

              Note:  Sometimes  it  is  necessary  for usability or standards-
              compliance reasons to provide multiple implicit  casts  among  a
              set  of  types, resulting in ambiguity that cannot be avoided as
              above. The  parser  has  a  fallback  heuristic  based  on  type
              categories  and preferred types that can help to provide desired
              behavior in such cases. See  CREATE  TYPE  [create_type(7)]  for
              more information.

       To be able to create a cast, you must own the source or the target data
       type. To create a binary-coercible cast, you must be superuser.   (This
       restriction   is   made  because  an  erroneous  binary-coercible  cast
       conversion can easily crash the server.)


              The name of the source data type of the cast.

              The name of the target data type of the cast.

              The function used to perform the cast. The function name can  be
              schema-qualified.  If  it is not, the function will be looked up
              in the schema search path. The function’s result data type  must
              match  the  target type of the cast. Its arguments are discussed

              Indicates that the source type is binary-coercible to the target
              type, so no function is required to perform the cast.

              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

              Indicates that the cast can be invoked implicitly in  assignment

              Indicates  that  the  cast  can  be  invoked  implicitly  in any

       Cast implementation functions can have one  to  three  arguments.   The
       first  argument  type must be identical to or binary-coercible from the
       cast’s source type. The second  argument,  if  present,  must  be  type
       integer;  it receives the type modifier associated with the destination
       type, or -1 if there is none. The third argument, if present,  must  be
       type  boolean;  it receives true if the cast is an explicit cast, false
       otherwise.  (Bizarrely, the SQL standard  demands  different  behaviors
       for  explicit  and  implicit  casts  in  some  cases.  This argument is
       supplied for functions that  must  implement  such  casts.  It  is  not
       recommended  that you design your own data types so that this matters.)

       The return type of a cast function must  be  identical  to  or  binary-
       coercible to the cast’s target type.

       Ordinarily  a  cast  must  have different source and target data types.
       However, it is allowed to declare a  cast  with  identical  source  and
       target  types  if  it has a cast implementation function with more than
       one argument. This is used to represent type-specific  length  coercion
       functions  in the system catalogs. The named function is used to coerce
       a value of the type to the type modifier  value  given  by  its  second

       When  a  cast has different source and target types and a function that
       takes more than one argument, it represents converting from one type to
       another  and  applying a length coercion in a single step. When no such
       entry is available, coercion to  a  type  that  uses  a  type  modifier
       involves  two  steps, one to convert between data types and a second to
       apply the modifier.


       Use DROP CAST [drop_cast(7)] to remove user-defined casts.

       Remember that if you want to be able to convert  types  both  ways  you
       need to declare casts both ways explicitly.

       It is normally not necessary to create casts between user-defined types
       and the standard string types (text, varchar, and char(n), as  well  as
       user-defined  types  that  are  defined  to be in the string category).
       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 an
       automatic 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 type’s I/O function; but
       that is sufficiently surprising  that  you  should  think  twice  about
       whether  it’s  a  good  idea.  (A small number of the built-in types do
       indeed have different behaviors  for  conversions,  mostly  because  of
       requirements of the SQL standard.)

       Prior  to  PostgreSQL  7.3,  every function that had the same name as a
       data type, returned  that  data  type,  and  took  one  argument  of  a
       different  type was automatically a cast function.  This convention has
       been abandoned in face of the introduction of schemas and to be able to
       represent  binary-coercible  casts in the system catalogs. The built-in
       cast functions still follow this naming scheme, but  they  have  to  be
       shown as casts in the system catalog pg_cast as well.

       While  not required, it is recommended that you continue to follow this
       old convention of naming cast implementation functions after the target
       data type. Many users are used to being able to cast data types using a
       function-style notation, that is typename(x). This notation is in  fact
       nothing  more nor less than a call of the cast implementation function;
       it is not specially treated as a cast. If your conversion functions are
       not  named  to  support  this  convention  then you will have surprised
       users.  Since PostgreSQL allows overloading of the same  function  name
       with  different  argument  types,  there  is  no  difficulty  in having
       multiple conversion functions from different types  that  all  use  the
       target type’s name.

              Note: Actually the preceding paragraph is an oversimplification:
              there are two cases in which a function-call construct  will  be
              treated as a cast request without having matched it to an actual
              function.  If a function call name(x) does not exactly match any
              existing  function,  but  name  is  the  name of a data type and
              pg_cast provides a binary-coercible cast to this type  from  the
              type of x, then the call will be construed as a binary-coercible
              cast. This exception is made so that binary-coercible casts  can
              be  invoked  using  functional syntax, even though they lack any
              function. Likewise, if there is no pg_cast entry  but  the  cast
              would be to or from a string type, the call will be construed as
              an I/O conversion cast. This  exception  allows  I/O  conversion
              casts to be invoked using functional syntax.


       To  create  an  assignment cast from type bigint to type int4 using the
       function int4(bigint):

       CREATE CAST (bigint AS int4) WITH FUNCTION int4(bigint) AS ASSIGNMENT;

       (This cast is already predefined in the system.)


       The CREATE CAST command conforms to the SQL standard, except  that  SQL
       does  not make provisions for binary-coercible types or extra arguments
       to implementation functions.  AS IMPLICIT is  a  PostgreSQL  extension,


       CREATE  FUNCTION  [create_function(7)],  CREATE  TYPE [create_type(7)],
       DROP CAST [drop_cast(7)]