built-in

BUILT-INS(INTRO)                  Postgres95                  BUILT-INS(INTRO)



DESCRIPTION
       This section describes the data types, functions and operators
       available to users in Postgres as it is distributed.

Built-in and System Types
BUILT-IN TYPES
       This section describes both built-in data types.  These Built-in types
       are are installed in every database.

       Users may add new types to Postgres using the define type command
       described in this manual.  User-defined types are not described in this
       section.

List of built-in types
     POSTGRES Type  Meaning
     abstime        absolute date and time
     aclitem        access control list item
     bool           boolean
     box            2-dimensional rectangle
     bpchar         blank-padded characters
     bytea          variable length array of bytes
     char           character
     char2          array of 2 characters
     char4          array of 4 characters
     char8          array of 8 characters
     char16         array of 16 characters
     cid            command identifier type
     date           ANSI SQL date type
     filename       large object filename
     int            alias for int4
     integer        alias for int4
     int2           two-byte signed integer
     int28          array of 8 int2
     int4           four-byte signed integer
     float          alias for float4
     float4         single-precision floating-point number
     float8         double-precision floating-point number
     lseg           2-dimensional line segment
     name           a multi-character type for storing system identifiers
     oid            object identifier type
     oid8           array of 8 oid
     oidchar16      oid and char16 composed
     oidint2        oid and int2 composed
     oidint4        oid and int4 composed
     path           variable-length array of lseg
     point          2-dimensional geometric point
     polygon        2-dimensional polygon
     real           alias for float4
     regproc        registered procedure
     reltime        relative date and time
     smgr           storage manager
     smallint       alias for int2
     text           variable length array of characters
     tid            tuple identifier type
     time           ANSI SQL time type
     tinterval      time interval
     varchar        variable-length characters
     xid            transaction identifier type


       As a rule, the built-in types are all either (1) internal types, in
       which case the user should not worry about their external format, or
       (2) have obvious formats.  The exceptions to this rule are the three
       time types.

Syntax of date and time types
ABSOLUTE TIME
       Absolute time is specified using the following syntax:
       Month  Day [ Hour : Minute : Second ]  Year [ Timezone ]

       where
            Month is Jan, Feb, ..., Dec
            Day is 1, 2, ..., 31
            Hour is 01, 02, ..., 24
            Minute is 00, 01, ..., 59
            Second is 00, 01, ..., 59
            Year is 1901, 1902, ..., 2038
       Valid dates are from Dec 13 20:45:53 1901 GMT to Jan 19 03:14:04 2038
       GMT.  As of Version 3.0, times are no longer read and written using
       Greenwich Mean Time; the input and output routines default to the local
       time zone.

       The special absolute time values “current”, “infinity” and “-infinity”
       are also provided.  “infinity” specifies a time later than any valid
       time, and “-infinity” specifies a time earlier than any valid time.
       “current” indicates that the current time should be substituted
       whenever this value appears in a computation.

       The strings “now” and “epoch” can be used to specify time values.
       “now” means the current time, and differs from “current” in that the
       current time is immediately substituted for it.  “epoch” means Jan 1
       00:00:00 1970 GMT.

RELATIVE TIME
       Relative time is specified with the following syntax:
       @ Quantity Unit [Direction]

       where
            Quantity is `1', `2', ...
            Unit is ``second'', ``minute'', ``hour'', ``day'', ``week'',
            ``month'' (30-days), or ``year'' (365-days),
            or PLURAL of these units.
            Direction is ``ago''

       (Note: Valid relative times are less than or equal to 68 years.)  In
       addition, the special relative time “Undefined RelTime” is provided.

TIME RANGES
       Time ranges are specified as:
       [ 'abstime' 'abstime']
       where abstime is a time in the absolute time format.  Special abstime
       values such as “current”, “infinity” and “-infinity” can be used.

Built-in operators and functions
OPERATORS
       Postgres provides a large number of built-in operators on system types.
       These operators are declared in the system catalog “pg_operator”.
       Every entry in “pg_operator” includes the object ID of the procedure
       that implements the operator.

       Users may invoke operators using the operator name, as in
       select * from emp where salary < 40000;
       Alternatively, users may call the functions that implement the
       operators directly.  In this case, the query above would be expressed
       as
       select * from emp where int4lt(salary, 40000);
       The rest of this section provides a list of the built-in operators and
       the functions that implement them.  Binary operators are listed first,
       followed by unary operators.

BINARY OPERATORS
       This list was generated from the Postgres system catalogs with the
       query:

       SELECT
            t0.typname AS result,
               t1.typname AS left_type,
               t2.typname AS right_type,
               o.oprname AS operatr,
               p.proname AS func_name
       FROM                pg_proc p, pg_type t0,
               pg_type t1, pg_type t2,
               pg_operator o
       WHERE               p.prorettype = t0.oid AND
               RegprocToOid(o.oprcode) = p.oid AND
            p.pronargs = 2 AND
            o.oprleft = t1.oid AND
            o.oprright = t2.oid
       ORDER BY result, left_type, right_type, operatr;

       These operations are cast in terms of SQL types and so are not directly
       usable as C function prototypes.

       Operators:

       general
            <=             less or equal
            <>             inequality
            <              less than
            <=             greater or equal
            >=             greater or equal
            >              greater than
            =              equality
            ~              A matches regular expression B, case-sensitive
            !~             A does not match regular expression B, case-sensitive
            ~*             A matches regular expression B, case-insensitive.
            !~*            A does not match regular expression B, case-insensitive
            ~~             A matches LIKE expression B, case-sensitive
            !~~            A does not match LIKE expression B, case-sensitive

            +              addition
            −              subtraction
            *              multiplication
            /              division
            %              modulus
            @              absolute value

       float8
            ^              exponentiation
            %              truncate to integer
            |/             square root
            ||/            cube root
            :              exponential function
            ;              natural logarithm

       point
            !<             A is left of B
            !>             A is right of B
            !^             A is above B
            !|             A is below B
            =|=            equality
            ===>           point inside box
            ===`           point on path
            <===>          distance between points

       box
            &&             boxes overlap
            &<             box A overlaps box B, but does not extend to right of box B
            &>             box A overlaps box B, but does not extend to left of box B
            <<             A is left of B
            =              area equal
            <              area less than
            <=             area less or equal
            >=             area greater or equal
            >              area greater than
            >>             A is right of B
            @              A is contained in B
            ~=             box equality
            ~=             A same as B
            ~              A contains B
            @@             center of box

       polygon
            &&             polygons overlap
            &<             A overlaps B but does not extend to right of B
            &>             A overlaps B but does not extend to left of B
            <<             A is left of B
            >>             A is right of B
            @              A is contained by B
            ~=             equality
            ~=             A same as B
            ~              A contains B

       tinterval
            #<=            interval length less or equal reltime
            #<>            interval length not equal to reltime.
            #<             interval length less than reltime
            #=             interval length equal to reltime
            #>=            interval length greater or equal reltime
            #>             interval length greater than reltime
            &&             intervals overlap
            <<             A contains B
            =              equality
            <>             interval bounded by two abstimes
            <?>            abstime in tinterval
            |              start of interval
            <#>            convert to interval

       result   |left_type |right_type|operatr|func_name
       ---------+----------+----------+-------+---------------
       _aclitem |_aclitem  |aclitem   |+      |aclinsert
       _aclitem |_aclitem  |aclitem   |-      |aclremove
       abstime  |abstime   |reltime   |+      |timepl
       abstime  |abstime   |reltime   |-      |timemi
       bool     |_abstime  |_abstime  |=      |array_eq
       bool     |_aclitem  |_aclitem  |=      |array_eq
       bool     |_aclitem  |aclitem   |~      |aclcontains
       bool     |_bool     |_bool     |=      |array_eq
       bool     |_box      |_box      |=      |array_eq
       bool     |_bytea    |_bytea    |=      |array_eq
       bool     |_char     |_char     |=      |array_eq
       bool     |_char16   |_char16   |=      |array_eq
       bool     |_cid      |_cid      |=      |array_eq
       bool     |_filename |_filename |=      |array_eq
       bool     |_float4   |_float4   |=      |array_eq
       bool     |_float8   |_float8   |=      |array_eq
       bool     |_int2     |_int2     |=      |array_eq
       bool     |_int28    |_int28    |=      |array_eq
       bool     |_int4     |_int4     |=      |array_eq
       bool     |_lseg     |_lseg     |=      |array_eq
       bool     |_name     |_name     |=      |array_eq
       bool     |_oid      |_oid      |=      |array_eq
       bool     |_oid8     |_oid8     |=      |array_eq
       bool     |_path     |_path     |=      |array_eq
       bool     |_point    |_point    |=      |array_eq
       bool     |_polygon  |_polygon  |=      |array_eq
       bool     |_ref      |_ref      |=      |array_eq
       bool     |_regproc  |_regproc  |=      |array_eq
       bool     |_reltime  |_reltime  |=      |array_eq
       bool     |_stub     |_stub     |=      |array_eq
       bool     |_text     |_text     |=      |array_eq
       bool     |_tid      |_tid      |=      |array_eq
       bool     |_tinterval|_tinterval|=      |array_eq
       bool     |_xid      |_xid      |=      |array_eq
       bool     |abstime   |abstime   |<      |abstimelt
       bool     |abstime   |abstime   |<=     |abstimele
       bool     |abstime   |abstime   |<>     |abstimene
       bool     |abstime   |abstime   |=      |abstimeeq
       bool     |abstime   |abstime   |>      |abstimegt
       bool     |abstime   |abstime   |>=     |abstimege
       bool     |abstime   |tinterval |<?>    |ininterval
       bool     |bool      |bool      |<>     |boolne
       bool     |bool      |bool      |=      |booleq
       bool     |box       |box       |&&     |box_overlap
       bool     |box       |box       |&<     |box_overleft
       bool     |box       |box       |&>     |box_overright
       bool     |box       |box       |<      |box_lt
       bool     |box       |box       |<<     |box_left
       bool     |box       |box       |<=     |box_le
       bool     |box       |box       |=      |box_eq
       bool     |box       |box       |>      |box_gt
       bool     |box       |box       |>=     |box_ge
       bool     |box       |box       |>>     |box_right
       bool     |box       |box       |@      |box_contained
       bool     |box       |box       |~      |box_contain
       bool     |box       |box       |~=     |box_same
       bool     |bpchar    |bpchar    |<      |bpcharlt
       bool     |bpchar    |bpchar    |<=     |bpcharle
       bool     |bpchar    |bpchar    |<>     |bpcharne
       bool     |bpchar    |bpchar    |=      |bpchareq
       bool     |bpchar    |bpchar    |>      |bpchargt
       bool     |bpchar    |bpchar    |>=     |bpcharge
       bool     |bpchar    |text      |!~     |textregexne
       bool     |bpchar    |text      |!~*    |texticregexne
       bool     |bpchar    |text      |!~~    |textnlike
       bool     |bpchar    |text      |~      |textregexeq
       bool     |bpchar    |text      |~*     |texticregexeq
       bool     |bpchar    |text      |~~     |textlike
       bool     |char      |char      |<      |charlt
       bool     |char      |char      |<=     |charle
       bool     |char      |char      |<>     |charne
       bool     |char      |char      |=      |chareq
       bool     |char      |char      |>      |chargt
       bool     |char      |char      |>=     |charge
       bool     |char16    |char16    |<      |char16lt
       bool     |char16    |char16    |<=     |char16le
       bool     |char16    |char16    |<>     |char16ne
       bool     |char16    |char16    |=      |char16eq
       bool     |char16    |char16    |>      |char16gt
       bool     |char16    |char16    |>=     |char16ge
       bool     |char16    |text      |!~     |char16regexne
       bool     |char16    |text      |!~*    |char16icregexne
       bool     |char16    |text      |!~~    |char16nlike
       bool     |char16    |text      |!~~    |char16nlike
       bool     |char16    |text      |~      |char16regexeq
       bool     |char16    |text      |~*     |char16icregexeq
       bool     |char16    |text      |~~     |char16like
       bool     |char16    |text      |~~     |char16like
       bool     |char2     |char2     |<      |char2lt
       bool     |char2     |char2     |<=     |char2le
       bool     |char2     |char2     |<>     |char2ne
       bool     |char2     |char2     |=      |char2eq
       bool     |char2     |char2     |>      |char2gt
       bool     |char2     |char2     |>=     |char2ge
       bool     |char2     |text      |!~     |char2regexne
       bool     |char2     |text      |!~*    |char2icregexne
       bool     |char2     |text      |!~~    |char2nlike
       bool     |char2     |text      |~      |char2regexeq
       bool     |char2     |text      |~*     |char2icregexeq
       bool     |char2     |text      |~~     |char2like
       bool     |char4     |char4     |<      |char4lt
       bool     |char4     |char4     |<=     |char4le
       bool     |char4     |char4     |<>     |char4ne
       bool     |char4     |char4     |=      |char4eq
       bool     |char4     |char4     |>      |char4gt
       bool     |char4     |char4     |>=     |char4ge
       bool     |char4     |text      |!~     |char4regexne
       bool     |char4     |text      |!~*    |char4icregexne
       bool     |char4     |text      |!~~    |char4nlike
       bool     |char4     |text      |~      |char4regexeq
       bool     |char4     |text      |~*     |char4icregexeq
       bool     |char4     |text      |~~     |char4like
       bool     |char8     |char8     |<      |char8lt
       bool     |char8     |char8     |<=     |char8le
       bool     |char8     |char8     |<>     |char8ne
       bool     |char8     |char8     |=      |char8eq
       bool     |char8     |char8     |>      |char8gt
       bool     |char8     |char8     |>=     |char8ge
       bool     |char8     |text      |!~     |char8regexne
       bool     |char8     |text      |!~*    |char8icregexne
       bool     |char8     |text      |!~~    |char8nlike
       bool     |char8     |text      |~      |char8regexeq
       bool     |char8     |text      |~*     |char8icregexeq
       bool     |char8     |text      |~~     |char8like
       bool     |date      |date      |<      |date_lt
       bool     |date      |date      |<=     |date_le
       bool     |date      |date      |<>     |date_ne
       bool     |date      |date      |=      |date_eq
       bool     |date      |date      |>      |date_gt
       bool     |date      |date      |>=     |date_ge
       bool     |float4    |float4    |<      |float4lt
       bool     |float4    |float4    |<=     |float4le
       bool     |float4    |float4    |<>     |float4ne
       bool     |float4    |float4    |=      |float4eq
       bool     |float4    |float4    |>      |float4gt
       bool     |float4    |float4    |>=     |float4ge
       bool     |float4    |float8    |<      |float48lt
       bool     |float4    |float8    |<=     |float48le
       bool     |float4    |float8    |<>     |float48ne
       bool     |float4    |float8    |=      |float48eq
       bool     |float4    |float8    |>      |float48gt
       bool     |float4    |float8    |>=     |float48ge
       bool     |float8    |float4    |<      |float84lt
       bool     |float8    |float4    |<=     |float84le
       bool     |float8    |float4    |<>     |float84ne
       bool     |float8    |float4    |=      |float84eq
       bool     |float8    |float4    |>      |float84gt
       bool     |float8    |float4    |>=     |float84ge
       bool     |float8    |float8    |<      |float8lt
       bool     |float8    |float8    |<=     |float8le
       bool     |float8    |float8    |<>     |float8ne
       bool     |float8    |float8    |=      |float8eq
       bool     |float8    |float8    |>      |float8gt
       bool     |float8    |float8    |>=     |float8ge
       bool     |int2      |int2      |<      |int2lt
       bool     |int2      |int2      |<=     |int2le
       bool     |int2      |int2      |<>     |int2ne
       bool     |int2      |int2      |=      |int2eq
       bool     |int2      |int2      |>      |int2gt
       bool     |int2      |int2      |>=     |int2ge
       bool     |int4      |int4      |<      |int4lt
       bool     |int4      |int4      |<=     |int4le
       bool     |int4      |int4      |<>     |int4ne
       bool     |int4      |int4      |=      |int4eq
       bool     |int4      |int4      |>      |int4gt
       bool     |int4      |int4      |>=     |int4ge
       bool     |int4      |name      |!!=    |int4notin
       bool     |int4      |oid       |=      |int4eqoid
       bool     |name      |name      |<      |namelt
       bool     |name      |name      |<=     |namele
       bool     |name      |name      |<>     |namene
       bool     |name      |name      |=      |nameeq
       bool     |name      |name      |>      |namegt
       bool     |name      |name      |>=     |namege
       bool     |name      |text      |!~     |nameregexne
       bool     |name      |text      |!~*    |nameicregexne
       bool     |name      |text      |!~~    |namenlike
       bool     |name      |text      |~      |nameregexeq
       bool     |name      |text      |~*     |nameicregexeq
       bool     |name      |text      |~~     |namelike
       bool     |oid       |int4      |=      |oideqint4
       bool     |oid       |name      |!!=    |oidnotin
       bool     |oid       |oid       |<      |int4lt
       bool     |oid       |oid       |<=     |int4le
       bool     |oid       |oid       |<>     |oidne
       bool     |oid       |oid       |=      |oideq
       bool     |oid       |oid       |>      |int4gt
       bool     |oid       |oid       |>=     |int4ge
       bool     |oidint2   |oidint2   |<      |oidint2lt
       bool     |oidint2   |oidint2   |<=     |oidint2le
       bool     |oidint2   |oidint2   |<>     |oidint2ne
       bool     |oidint2   |oidint2   |=      |oidint2eq
       bool     |oidint2   |oidint2   |>      |oidint2gt
       bool     |oidint2   |oidint2   |>=     |oidint2ge
       bool     |oidint4   |oidint4   |<      |oidint4lt
       bool     |oidint4   |oidint4   |<=     |oidint4le
       bool     |oidint4   |oidint4   |<>     |oidint4ne
       bool     |oidint4   |oidint4   |=      |oidint4eq
       bool     |oidint4   |oidint4   |>      |oidint4gt
       bool     |oidint4   |oidint4   |>=     |oidint4ge
       bool     |oidname   |oidname   |<      |oidnamelt
       bool     |oidname   |oidname   |<=     |oidnamele
       bool     |oidname   |oidname   |<>     |oidnamene
       bool     |oidname   |oidname   |=      |oidnameeq
       bool     |oidname   |oidname   |>      |oidnamegt
       bool     |oidname   |oidname   |>=     |oidnamege
       bool     |point     |box       |===>   |on_pb
       bool     |point     |path      |===`   |on_ppath
       bool     |point     |point     |!<     |point_left
       bool     |point     |point     |!>     |point_right
       bool     |point     |point     |!^     |point_above
       bool     |point     |point     |!    |point_below
       bool     |point     |point     |==   |point_eq
       bool     |polygon   |polygon   |&&     |poly_overlap
       bool     |polygon   |polygon   |&<     |poly_overleft
       bool     |polygon   |polygon   |&>     |poly_overright
       bool     |polygon   |polygon   |<<     |poly_left
       bool     |polygon   |polygon   |>>     |poly_right
       bool     |polygon   |polygon   |@      |poly_contained
       bool     |polygon   |polygon   |~      |poly_contain
       bool     |polygon   |polygon   |~=     |poly_same
       bool     |reltime   |reltime   |<      |reltimelt
       bool     |reltime   |reltime   |<=     |reltimele
       bool     |reltime   |reltime   |<>     |reltimene
       bool     |reltime   |reltime   |=      |reltimeeq
       bool     |reltime   |reltime   |>      |reltimegt
       bool     |reltime   |reltime   |>=     |reltimege
       bool     |text      |text      |!~     |textregexne
       bool     |text      |text      |!~*    |texticregexne
       bool     |text      |text      |!~~    |textnlike
       bool     |text      |text      |<      |text_lt
       bool     |text      |text      |<=     |text_le
       bool     |text      |text      |<>     |textne
       bool     |text      |text      |=      |texteq
       bool     |text      |text      |>      |text_gt
       bool     |text      |text      |>=     |text_ge
       bool     |text      |text      |~      |textregexeq
       bool     |text      |text      |~*     |texticregexeq
       bool     |text      |text      |~~     |textlike
       bool     |time      |time      |<      |time_lt
       bool     |time      |time      |<=     |time_le
       bool     |time      |time      |<>     |time_ne
       bool     |time      |time      |=      |time_eq
       bool     |time      |time      |>      |time_gt
       bool     |time      |time      |>=     |time_ge
       bool     |tinterval |reltime   |#<     |intervallenlt
       bool     |tinterval |reltime   |#<=    |intervallenle
       bool     |tinterval |reltime   |#<>    |intervallenne
       bool     |tinterval |reltime   |#=     |intervalleneq
       bool     |tinterval |reltime   |#>     |intervallengt
       bool     |tinterval |reltime   |#>=    |intervallenge
       bool     |tinterval |tinterval |&&     |intervalov
       bool     |tinterval |tinterval |<<     |intervalct
       bool     |tinterval |tinterval |=      |intervaleq
       bool     |varchar   |text      |!~     |textregexne
       bool     |varchar   |text      |!~*    |texticregexne
       bool     |varchar   |text      |!~~    |textnlike
       bool     |varchar   |text      |~      |textregexeq
       bool     |varchar   |text      |~*     |texticregexeq
       bool     |varchar   |text      |~~     |textlike
       bool     |varchar   |varchar   |<      |varcharlt
       bool     |varchar   |varchar   |<=     |varcharle
       bool     |varchar   |varchar   |<>     |varcharne
       bool     |varchar   |varchar   |=      |varchareq
       bool     |varchar   |varchar   |>      |varchargt
       bool     |varchar   |varchar   |>=     |varcharge
       char     |char      |char      |*      |charmul
       char     |char      |char      |+      |charpl
       char     |char      |char      |-      |charmi
       char     |char      |char      |/      |chardiv
       float4   |float4    |float4    |*      |float4mul
       float4   |float4    |float4    |+      |float4pl
       float4   |float4    |float4    |-      |float4mi
       float4   |float4    |float4    |/      |float4div
       float8   |float4    |float8    |*      |float48mul
       float8   |float4    |float8    |+      |float48pl
       float8   |float4    |float8    |-      |float48mi
       float8   |float4    |float8    |/      |float48div
       float8   |float8    |float4    |*      |float84mul
       float8   |float8    |float4    |+      |float84pl
       float8   |float8    |float4    |-      |float84mi
       float8   |float8    |float4    |/      |float84div
       float8   |float8    |float8    |*      |float8mul
       float8   |float8    |float8    |+      |float8pl
       float8   |float8    |float8    |-      |float8mi
       float8   |float8    |float8    |/      |float8div
       float8   |float8    |float8    |^      |dpow
       int2     |int2      |int2      |%      |int2mod
       int2     |int2      |int2      |*      |int2mul
       int2     |int2      |int2      |+      |int2pl
       int2     |int2      |int2      |-      |int2mi
       int2     |int2      |int2      |/      |int2div
       int4     |int2      |int4      |%      |int24mod
       int4     |int2      |int4      |*      |int24mul
       int4     |int2      |int4      |+      |int24pl
       int4     |int2      |int4      |-      |int24mi
       int4     |int2      |int4      |/      |int24div
       int4     |int2      |int4      |<      |int24lt
       int4     |int2      |int4      |<=     |int24le
       int4     |int2      |int4      |<>     |int24ne
       int4     |int2      |int4      |=      |int24eq
       int4     |int2      |int4      |>      |int24gt
       int4     |int2      |int4      |>=     |int24ge
       int4     |int4      |int2      |%      |int42mod
       int4     |int4      |int2      |*      |int42mul
       int4     |int4      |int2      |+      |int42pl
       int4     |int4      |int2      |-      |int42mi
       int4     |int4      |int2      |/      |int42div
       int4     |int4      |int2      |<      |int42lt
       int4     |int4      |int2      |<=     |int42le
       int4     |int4      |int2      |<>     |int42ne
       int4     |int4      |int2      |=      |int42eq
       int4     |int4      |int2      |>      |int42gt
       int4     |int4      |int2      |>=     |int42ge
       int4     |int4      |int4      |%      |int4mod
       int4     |int4      |int4      |*      |int4mul
       int4     |int4      |int4      |+      |int4pl
       int4     |int4      |int4      |-      |int4mi
       int4     |int4      |int4      |/      |int4div
       int4     |point     |point     |<===>  |pointdist
       tinterval|abstime   |abstime   |<#>    |mktinterval



LEFT UNARY OPERATORS
       The table below gives the left unary operators that are registered in
       the system catalogs.

       This list was generated from the Postgres system catalogs with the
       query:

       SELECT o.oprname AS left_unary,
              right.typname AS operand,
              result.typname AS return_type
       FROM pg_operator o, pg_type right, pg_type result
       WHERE o.oprkind = 'l' AND          -- left unary
             o.oprright = right.oid AND
             o.oprresult = result.oid
       ORDER BY operand;

       left_unary|operand  |return_type
       ----------+---------+-----------
       @@        |box      |point
       @         |float4   |float4
       -         |float4   |float4
       ;         |float8   |float8
       :         |float8   |float8
       %         |float8   |float8
       /     |float8   |float8
       /       |float8   |float8
       @         |float8   |float8
       -         |float8   |float8
       -         |int2     |int2
       -         |int4     |int4
       !!        |int4     |int4
               |tinterval|abstime


RIGHT UNARY OPERATORS
       The table below gives the right unary operators that are registered in
       the system catalogs.

       This list was generated from the Postgres system catalogs with the
       query:

       SELECT o.oprname AS right_unary,
              left.typname AS operand,
              result.typname AS return_type
       FROM pg_operator o, pg_type left, pg_type result
       WHERE o.oprkind = 'r' AND          -- right unary
             o.oprleft = left.oid AND
             o.oprresult = result.oid
       ORDER BY operand;

       right_unary|operand|return_type
       -----------+-------+-----------
       %          |float8 |float8
       !          |int4   |int4


AGGREGATE FUNCTIONS
       The table below gives the aggregate functions that are registered in
       the system catalogs.

       This list was generated from the Postgres system catalogs with the
       query:

       SELECT a.aggname, t.typname
       FROM pg_aggregate a, pg_type t
       WHERE a.aggbasetype = t.oid
       ORDER BY aggname, typname;

       aggname|typname
       -------+-------
       avg    |float4
       avg    |float8
       avg    |int2
       avg    |int4
       max    |float4
       max    |float8
       max    |int2
       max    |int4
       min    |float4
       min    |float8
       min    |int2
       min    |int4
       sum    |float4
       sum    |float8
       sum    |int2
       sum    |int4

       count is also available.


SEE ALSO
       For examples on specifying literals of built-in types, see SQL(l).

BUGS
       Although most of the input and output functions correponding to the
       base types (e.g., integers and floating point numbers) do some error-
       checking, none of them are particularly rigorous about it.  More
       importantly, almost none of the operators and functions (e.g., addition
       and multiplication) perform any error-checking at all.  Consequently,
       many of the numeric operations will (for example) silently underflow or
       overflow.

       Some of the input and output functions are not invertible.  That is,
       the result of an output function may lose precision when compared to
       the original input.



Postgres95                         11/05/95                   BUILT-INS(INTRO)