-<chapter Id="typeconv">
+<!-- doc/src/sgml/typeconv.sgml -->
+
+<chapter id="typeconv">
<title>Type Conversion</title>
- <sect1 id="typeconv-intro">
- <title>Introduction</title>
+<indexterm zone="typeconv">
+ <primary>data type</primary>
+ <secondary>conversion</secondary>
+</indexterm>
<para>
-<acronym>SQL</acronym> queries can, intentionally or not, require
-mixing of different data types in the same expression.
+<acronym>SQL</acronym> statements can, intentionally or not, require
+the mixing of different data types in the same expression.
<productname>PostgreSQL</productname> has extensive facilities for
evaluating mixed-type expressions.
</para>
<para>
-In many cases a user will not need
+In many cases a user does not need
to understand the details of the type conversion mechanism.
-However,
the implicit conversions done by <productname>PostgreSQL</productname>
+However, implicit conversions done by <productname>PostgreSQL</productname>
can affect the results of a query. When necessary, these results
-can be tailored by a user or programmer
-using <emphasis>explicit</emphasis> type coercion.
+can be tailored by using <emphasis>explicit</emphasis> type conversion.
</para>
<para>
operators.
</para>
-<para>
-The <citetitle>Programmer's Guide</citetitle> has more details on the exact algorithms used for
-implicit type conversion and coercion.
-</para>
- </sect1>
-
<sect1 id="typeconv-overview">
<title>Overview</title>
<acronym>SQL</acronym> is a strongly typed language. That is, every data item
has an associated data type which determines its behavior and allowed usage.
<productname>PostgreSQL</productname> has an extensible type system that is
-much more general and flexible than other <acronym>RDBMS</acronym> implementations.
+more general and flexible than other <acronym>SQL</acronym> implementations.
Hence, most type conversion behavior in <productname>PostgreSQL</productname>
-should be governed by general rules rather than by ad-hoc heuristics, to allow
-mixed-type expressions to be meaningful even with user-defined types.
+is governed by general rules rather than by <foreignphrase>ad hoc</>
+heuristics. This allows the use of mixed-type expressions even with
+user-defined types.
</para>
<para>
-The <productname>PostgreSQL</productname> scanner/parser decodes lexical
-elements into only five fundamental categories: integers, floats, strings,
-names, and keywords. Most extended types are first tokenized into
-strings. The <acronym>SQL</acronym> language definition allows specifying type
-names with strings, and this mechanism can be used in
+The <productname>PostgreSQL</productname> scanner/parser divides lexical
+elements into five fundamental categories: integers, non-integer numbers,
+strings, identifiers, and key words. Constants of most non-numeric types are
+first classified as strings. The <acronym>SQL</acronym> language definition
+allows specifying type names with strings, and this mechanism can be used in
<productname>PostgreSQL</productname> to start the parser down the correct
-path. For example, the query
+path. For example, the query:
<screen>
-tgl=> SELECT text 'Origin' AS "Label", point '(0,0)' AS "Value";
- Label | Value
+SELECT text 'Origin' AS "label", point '(0,0)' AS "value";
+
+ label | value
--------+-------
Origin | (0,0)
(1 row)
has two literal constants, of type <type>text</type> and <type>point</type>.
If a type is not specified for a string literal, then the placeholder type
-<firstterm>unknown</firstterm> is assigned initially, to be resolved in later
+<type>unknown</type> is assigned initially, to be resolved in later
stages as described below.
</para>
There are four fundamental <acronym>SQL</acronym> constructs requiring
distinct type conversion rules in the <productname>PostgreSQL</productname>
parser:
-</para>
<variablelist>
<varlistentry>
<term>
-Operators
+Function calls
</term>
<listitem>
<para>
-<productname>PostgreSQL</productname> allows expressions with
-prefix and postfix unary (one argument) operators,
-as well as binary (two argument) operators.
+Much of the <productname>PostgreSQL</productname> type system is built around a
+rich set of functions. Functions can have one or more arguments.
+Since <productname>PostgreSQL</productname> permits function
+overloading, the function name alone does not uniquely identify the function
+to be called; the parser must select the right function based on the data
+types of the supplied arguments.
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>
-Function calls
+Operators
</term>
<listitem>
<para>
-Much of the <productname>PostgreSQL</productname> type system is built around a
-rich set of functions. Function calls have one or more arguments which, for
-any specific query, must be matched to the functions available in the system
-catalog. Since <productname>PostgreSQL</productname> permits function
-overloading, the function name alone does not uniquely identify the function
-to be called; the parser must select the right function based on the data
-types of the supplied arguments.
+<productname>PostgreSQL</productname> allows expressions with
+prefix and postfix unary (one-argument) operators,
+as well as binary (two-argument) operators. Like functions, operators can
+be overloaded, so the same problem of selecting the right operator
+exists.
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>
-Query targets
+Value Storage
</term>
<listitem>
<para>
<acronym>SQL</acronym> <command>INSERT</command> and <command>UPDATE</command> statements place the results of
-expressions into a table. The expressions in the query must be matched up
+expressions into a table. The expressions in the statement must be matched up
with, and perhaps converted to, the types of the target columns.
</para>
</listitem>
</varlistentry>
<varlistentry>
<term>
-<literal>UNION</literal> and <literal>CASE</literal> constructs
+<literal>UNION</literal>, <literal>CASE</literal>, and related constructs
</term>
<listitem>
<para>
-Since all select results from a unionized <literal>SELECT</literal> statement must appear in a single
-set of columns, the types of the results
-of each <literal>SELECT</> clause must be matched up and converted to a uniform set.
-Similarly, the result expressions of a <literal>CASE</> construct must be coerced to
-a common type so that the <literal>CASE</> expression as a whole has a known output type.
+Since all query results from a unionized <command>SELECT</command> statement
+must appear in a single set of columns, the types of the results of each
+<command>SELECT</> clause must be matched up and converted to a uniform set.
+Similarly, the result expressions of a <literal>CASE</> construct must be
+converted to a common type so that the <literal>CASE</> expression as a whole
+has a known output type. The same holds for <literal>ARRAY</> constructs,
+and for the <function>GREATEST</> and <function>LEAST</> functions.
</para>
</listitem>
</varlistentry>
</variablelist>
-
-<para>
-Many of the general type conversion rules use simple conventions built on
-the <productname>PostgreSQL</productname> function and operator system tables.
-There are some heuristics included in the conversion rules to better support
-conventions for the <acronym>SQL</acronym> standard native types such as
-<type>smallint</type>, <type>integer</type>, and <type>real</type>.
</para>
<para>
-The <productname>PostgreSQL</productname> parser uses the convention that all
-type conversion functions take a single argument of the source type and are
-named with the same name as the target type. Any function meeting these
-criteria is considered to be a valid conversion function, and may be used
-by the parser as such. This simple assumption gives the parser the power
-to explore type conversion possibilities without hardcoding, allowing
-extended user-defined types to use these same features transparently.
+The system catalogs store information about which conversions, or
+<firstterm>casts</firstterm>, exist between which data types, and how to
+perform those conversions. Additional casts can be added by the user
+with the <xref linkend="sql-createcast">
+command. (This is usually
+done in conjunction with defining new data types. The set of casts
+between built-in types has been carefully crafted and is best not
+altered.)
</para>
-<para>
-An additional heuristic is provided in the parser to allow better guesses
-at proper behavior for <acronym>SQL</acronym> standard types. There are
-several basic <firstterm>type categories</firstterm> defined: <type>boolean</type>,
-<type>numeric</type>, <type>string</type>, <type>bitstring</type>, <type>datetime</type>, <type>timespan</type>, <type>geometric</type>, <type>network</type>,
-and user-defined. Each category, with the exception of user-defined, has
-a <firstterm>preferred type</firstterm> which is preferentially selected
-when there is ambiguity.
-In the user-defined category, each type is its own preferred type.
-Ambiguous expressions (those with multiple candidate parsing solutions)
-can often be resolved when there are multiple possible built-in types, but
-they will raise an error when there are multiple choices for user-defined
-types.
+<indexterm>
+ <primary>data type</primary>
+ <secondary>category</secondary>
+</indexterm>
+
+<para>
+An additional heuristic provided by the parser allows improved determination
+of the proper casting behavior among groups of types that have implicit casts.
+Data types are divided into several basic <firstterm>type
+categories</firstterm>, including <type>boolean</type>, <type>numeric</type>,
+<type>string</type>, <type>bitstring</type>, <type>datetime</type>,
+<type>timespan</type>, <type>geometric</type>, <type>network</type>, and
+user-defined. (For a list see <xref linkend="catalog-typcategory-table">;
+but note it is also possible to create custom type categories.) Within each
+category there can be one or more <firstterm>preferred types</firstterm>, which
+are preferred when there is a choice of possible types. With careful selection
+of preferred types and available implicit casts, it is possible to ensure that
+ambiguous expressions (those with multiple candidate parsing solutions) can be
+resolved in a useful way.
</para>
<para>
All type conversion rules are designed with several principles in mind:
-<itemizedlist mark="bullet" spacing="compact">
+<itemizedlist>
<listitem>
<para>
Implicit conversions should never have surprising or unpredictable outcomes.
<listitem>
<para>
-User-defined types, of which the parser has no a-priori knowledge, should be
-<quote>higher</quote> in the type hierarchy. In mixed-type expressions, native types shall always
-be converted to a user-defined type (of course, only if conversion is necessary).
-</para>
-</listitem>
-
-<listitem>
-<para>
-User-defined types are not related. Currently, <productname>PostgreSQL</productname>
-does not have information available to it on relationships between types, other than
-hardcoded heuristics for built-in types and implicit relationships based on available functions
-in the catalog.
-</para>
-</listitem>
-
-<listitem>
-<para>
-There should be no extra overhead from the parser or executor
+There should be no extra overhead in the parser or executor
if a query does not need implicit type conversion.
-That is, if a query is well formulated and the types already match up, then the query should proceed
+That is, if a query is well-formed and the types already match, then the query should execute
without spending extra time in the parser and without introducing unnecessary implicit conversion
-functions into the query.
+calls in the query.
</para>
+</listitem>
+<listitem>
<para>
Additionally, if a query usually requires an implicit conversion for a function, and
-if then the user defines an explicit function with the correct argument types, the parser
-should use this new function and will no longer do the implicit conversion using the old function.
+if then the user defines a new function with the correct argument types, the parser
+should use this new function and no longer do implicit conversion to use the old function.
</para>
</listitem>
</itemizedlist>
<sect1 id="typeconv-oper">
<title>Operators</title>
+<indexterm zone="typeconv-oper">
+ <primary>operator</primary>
+ <secondary>type resolution in an invocation</secondary>
+</indexterm>
+
<para>
- The operand types of an operator invocation are resolved following
- the procedure below. Note that this procedure is indirectly affected
- by the precedence of the involved operators. See <xref
- linkend="sql-precedence"> for more information.
+ The specific operator that is referenced by an operator expression
+ is determined using the following procedure.
+ Note that this procedure is indirectly affected
+ by the precedence of the operators involved, since that will determine
+ which sub-expressions are taken to be the inputs of which operators.
+ See <xref linkend="sql-precedence"> for more information.
</para>
<procedure>
-<title>Operand Type Resolution</title>
+<title>Operator Type Resolution</title>
-<step performance="required">
+<step id="op-resol-select" performance="required">
<para>
-Check for an exact match in the <classname>pg_operator</classname> system catalog.
+Select the operators to be considered from the
+<classname>pg_operator</classname> system catalog. If a non-schema-qualified
+operator name was used (the usual case), the operators
+considered are those with the matching name and argument count that are
+visible in the current search path (see <xref linkend="ddl-schemas-path">).
+If a qualified operator name was given, only operators in the specified
+schema are considered.
</para>
<substeps>
<step performance="optional">
<para>
-If one argument of a binary operator is <type>unknown</type> type,
+If the search path finds multiple operators with identical argument types,
+only the one appearing earliest in the path is considered. Operators with
+different argument types are considered on an equal footing regardless of
+search path position.
+</para>
+</step>
+</substeps>
+</step>
+
+<step id="op-resol-exact-match" performance="required">
+<para>
+Check for an operator accepting exactly the input argument types.
+If one exists (there can be only one exact match in the set of
+operators considered), use it.
+</para>
+
+<substeps>
+<step id="op-resol-exact-unknown" performance="optional">
+<para>
+If one argument of a binary operator invocation is of the <type>unknown</type> type,
then assume it is the same type as the other argument for this check.
-Other cases involving <type>unknown</type> will never find a match at
-this step.
+Invocations involving two <type>unknown</type> inputs, or a unary operator
+with an <type>unknown</type> input, will never find a match at this step.
+</para>
+</step>
+<step id="op-resol-exact-domain" performance="optional">
+<para>
+If one argument of a binary operator invocation is of the <type>unknown</type>
+type and the other is of a domain type, next check to see if there is an
+operator accepting exactly the domain's base type on both sides; if so, use it.
</para>
</step>
</substeps>
</step>
-<step performance="required">
+<step id="op-resol-best-match" performance="required">
<para>
Look for the best match.
</para>
<substeps>
<step performance="required">
<para>
-Make a list of all operators of the same name for which the input types
-match or can be coerced to match. (<type>unknown</type> literals are
-assumed to be coercible to anything for this purpose.) If there is only
-one, use it; else continue to the next step.
+Discard candidate operators for which the input types do not match
+and cannot be converted (using an implicit conversion) to match.
+<type>unknown</type> literals are
+assumed to be convertible to anything for this purpose. If only one
+candidate remains, use it; else continue to the next step.
</para>
</step>
<step performance="required">
<para>
-Run through all candidates and keep those with the most exact matches
-on input types. Keep all candidates if none have any exact matches.
-If only one candidate remains, use it; else continue to the next step.
+If any input argument is of a domain type, treat it as being of the
+domain's base type for all subsequent steps. This ensures that domains
+act like their base types for purposes of ambiguous-operator resolution.
</para>
</step>
<step performance="required">
<para>
-Run through all candidates and keep those with the most exact or
-binary-compatible matches on input types. Keep all candidates if none have
-any exact or binary-compatible matches.
+Run through all candidates and keep those with the most exact matches
+on input types. Keep all candidates if none have exact matches.
If only one candidate remains, use it; else continue to the next step.
</para>
</step>
<step performance="required">
<para>
-Run through all candidates and keep those that accept preferred types at
-the most positions where type coercion will be required.
+Run through all candidates and keep those that accept preferred types (of the
+input data type's type category) at the most positions where type conversion
+will be required.
Keep all candidates if none accept preferred types.
If only one candidate remains, use it; else continue to the next step.
</para>
</step>
<step performance="required">
<para>
-If any input arguments are <quote>unknown</quote>, check the type
+If any input arguments are <type>unknown</type>, check the type
categories accepted at those argument positions by the remaining
-candidates. At each position, select the "string" category if any
-candidate accepts that category (this bias towards string is appropriate
-since an unknown-type literal does look like a string). Otherwise, if
+candidates. At each position, select the <type>string</type> category
+if any
+candidate accepts that category. (This bias towards string is appropriate
+since an unknown-type literal looks like a string.) Otherwise, if
all the remaining candidates accept the same type category, select that
category; otherwise fail because the correct choice cannot be deduced
-without more clues. Also note whether any of the candidates accept a
-preferred data type within the selected category. Now discard operator
-candidates that do not accept the selected type category; furthermore,
-if any candidate accepts a preferred type at a given argument position,
+without more clues. Now discard
+candidates that do not accept the selected type category. Furthermore,
+if any candidate accepts a preferred type in that category,
discard candidates that accept non-preferred types for that argument.
+Keep all candidates if none survive these tests.
+If only one candidate remains, use it; else continue to the next step.
</para>
</step>
-<step performance="required">
-<para>
-If only one candidate remains, use it. If no candidate or more than one
-candidate remains,
-then fail.
+<step id="op-resol-last-unknown" performance="required">
+<para>
+If there are both <type>unknown</type> and known-type arguments, and all
+the known-type arguments have the same type, assume that the
+<type>unknown</type> arguments are also of that type, and check which
+candidates can accept that type at the <type>unknown</type>-argument
+positions. If exactly one candidate passes this test, use it.
+Otherwise, fail.
</para>
</step>
</substeps>
</step>
</procedure>
-<bridgehead renderas="sect2">Examples</bridgehead>
+<para>
+Some examples follow.
+</para>
<example>
-<title>Exponentiation Operator Type Resolution</title>
+<title>Factorial Operator Type Resolution</title>
<para>
-There is only one exponentiation
-operator defined in the catalog, and it takes arguments of type
-<type>double precision</type>.
-The scanner assigns an initial type of <type>integer</type> to both arguments
-of this query expression:
+There is only one factorial operator (postfix <literal>!</>)
+defined in the standard catalog, and it takes an argument of type
+<type>bigint</type>.
+The scanner assigns an initial type of <type>integer</type> to the argument
+in this query expression:
<screen>
-tgl=> SELECT 2 ^ 3 AS "Exp";
- Exp
------
- 8
-(1 row)
-</screen>
+SELECT 40 ! AS "40 factorial";
-So the parser does a type conversion on both operands and the query
-is equivalent to
-
-<screen>
-tgl=> SELECT CAST(2 AS double precision) ^ CAST(3 AS double precision) AS "Exp";
- Exp
------
- 8
+ 40 factorial
+--------------------------------------------------
+ 815915283247897734345611269596115894272000000000
(1 row)
</screen>
-or
+So the parser does a type conversion on the operand and the query
+is equivalent to:
<screen>
-tgl=> SELECT 2.0 ^ 3.0 AS "Exp";
- Exp
------
- 8
-(1 row)
+SELECT CAST(40 AS bigint) ! AS "40 factorial";
</screen>
-
-<note>
-<para>
-This last form has the least overhead, since no functions are called to do
-implicit type conversion. This is not an issue for small queries, but may
-have an impact on the performance of queries involving large tables.
-</para>
-</note>
</para>
</example>
<title>String Concatenation Operator Type Resolution</title>
<para>
-A string-like syntax is used for working with string types as well as for
-working with complex extended types.
+A string-like syntax is used for working with string types and for
+working with complex extension types.
Strings with unspecified type are matched with likely operator candidates.
</para>
<para>
An example with one unspecified argument:
<screen>
-tgl=> SELECT text 'abc' || 'def' AS "Text and Unknown";
- Text and Unknown
+SELECT text 'abc' || 'def' AS "text and unknown";
+
+ text and unknown
------------------
abcdef
(1 row)
<para>
In this case the parser looks to see if there is an operator taking <type>text</type>
for both arguments. Since there is, it assumes that the second argument should
-be interpreted as of type <type>text</type>.
+be interpreted as type <type>text</type>.
</para>
<para>
-Concatenation on unspecified types:
+Here is a concatenation of two values of unspecified types:
<screen>
-tgl=> SELECT 'abc' || 'def' AS "Unspecified";
- Unspecified
+SELECT 'abc' || 'def' AS "unspecified";
+
+ unspecified
-------------
abcdef
(1 row)
are specified in the query. So, the parser looks for all candidate operators
and finds that there are candidates accepting both string-category and
bit-string-category inputs. Since string category is preferred when available,
-that category is selected, and then the
-<quote>preferred type</quote> for strings, <type>text</type>, is used as the specific
-type to resolve the unknown literals to.
+that category is selected, and then the
+preferred type for strings, <type>text</type>, is used as the specific
+type to resolve the unknown-type literals as.
</para>
</example>
<example>
-<title>Absolute-Value and Factorial Operator Type Resolution</title>
+<title>Absolute-Value and Negation Operator Type Resolution</title>
<para>
The <productname>PostgreSQL</productname> operator catalog has several
entries for the prefix operator <literal>@</>, all of which implement
-absolute-value operations for various numeric datatypes. One of these
+absolute-value operations for various numeric data types. One of these
entries is for type <type>float8</type>, which is the preferred type in
the numeric category. Therefore, <productname>PostgreSQL</productname>
-will use that entry when faced with a non-numeric input:
+will use that entry when faced with an <type>unknown</> input:
<screen>
-tgl=> select @ text '-4.5' as "abs";
+SELECT @ '-4.5' AS "abs";
abs
-----
4.5
(1 row)
</screen>
-Here the system has performed an implicit text-to-float8 conversion
-before applying the chosen operator. We can verify that float8 and
-not some other type was used:
+Here the system has implicitly resolved the unknown-type literal as type
+<type>float8</type> before applying the chosen operator. We can verify that
+<type>float8</type> and not some other type was used:
<screen>
-tgl=> select @ text '-4.5e500' as "abs";
-ERROR: Input '-4.5e500' is out of range for float8
+SELECT @ '-4.5e500' AS "abs";
+
+ERROR: "-4.5e500" is out of range for type double precision
</screen>
</para>
<para>
-On the other hand, the postfix operator <literal>!</> (factorial)
-is defined only for integer datatypes, not for float8. So, if we
-try a similar case with <literal>!</>, we get:
+On the other hand, the prefix operator <literal>~</> (bitwise negation)
+is defined only for integer data types, not for <type>float8</type>. So, if we
+try a similar case with <literal>~</>, we get:
<screen>
-tgl=> select text '44' ! as "factorial";
-ERROR: Unable to identify a postfix operator '!' for type 'text'
- You may need to add parentheses or an explicit cast
+SELECT ~ '20' AS "negation";
+
+ERROR: operator is not unique: ~ "unknown"
+HINT: Could not choose a best candidate operator. You might need to add
+explicit type casts.
</screen>
-This happens because the system can't decide which of the several
-possible <literal>!</> operators should be preferred. We can help
+This happens because the system cannot decide which of the several
+possible <literal>~</> operators should be preferred. We can help
it out with an explicit cast:
<screen>
-tgl=> select cast(text '44' as int8) ! as "factorial";
- factorial
----------------------
- 2673996885588443136
+SELECT ~ CAST('20' AS int8) AS "negation";
+
+ negation
+----------
+ -21
+(1 row)
+</screen>
+</para>
+</example>
+
+<example>
+<title>Array Inclusion Operator Type Resolution</title>
+
+<para>
+Here is another example of resolving an operator with one known and one
+unknown input:
+<screen>
+SELECT array[1,2] <@ '{1,2,3}' as "is subset";
+
+ is subset
+-----------
+ t
(1 row)
</screen>
+The <productname>PostgreSQL</productname> operator catalog has several
+entries for the infix operator <literal><@</>, but the only two that
+could possibly accept an integer array on the left-hand side are
+array inclusion (<type>anyarray</> <literal><@</> <type>anyarray</>)
+and range inclusion (<type>anyelement</> <literal><@</> <type>anyrange</>).
+Since none of these polymorphic pseudo-types (see <xref
+linkend="datatype-pseudo">) are considered preferred, the parser cannot
+resolve the ambiguity on that basis.
+However, <xref linkend="op-resol-last-unknown"> tells
+it to assume that the unknown-type literal is of the same type as the other
+input, that is, integer array. Now only one of the two operators can match,
+so array inclusion is selected. (Had range inclusion been selected, we would
+have gotten an error, because the string does not have the right format to be
+a range literal.)
+</para>
+</example>
+
+<example>
+<title>Custom Operator on a Domain Type</title>
+
+<para>
+Users sometimes try to declare operators applying just to a domain type.
+This is possible but is not nearly as useful as it might seem, because the
+operator resolution rules are designed to select operators applying to the
+domain's base type. As an example consider
+<screen>
+CREATE DOMAIN mytext AS text CHECK(...);
+CREATE FUNCTION mytext_eq_text (mytext, text) RETURNS boolean AS ...;
+CREATE OPERATOR = (procedure=mytext_eq_text, leftarg=mytext, rightarg=text);
+CREATE TABLE mytable (val mytext);
+
+SELECT * FROM mytable WHERE val = 'foo';
+</screen>
+This query will not use the custom operator. The parser will first see if
+there is a <type>mytext</> <literal>=</> <type>mytext</> operator
+(<xref linkend="op-resol-exact-unknown">), which there is not;
+then it will consider the domain's base type <type>text</>, and see if
+there is a <type>text</> <literal>=</> <type>text</> operator
+(<xref linkend="op-resol-exact-domain">), which there is;
+so it resolves the <type>unknown</>-type literal as <type>text</> and
+uses the <type>text</> <literal>=</> <type>text</> operator.
+The only way to get the custom operator to be used is to explicitly cast
+the literal:
+<screen>
+SELECT * FROM mytable WHERE val = text 'foo';
+</screen>
+so that the <type>mytext</> <literal>=</> <type>text</> operator is found
+immediately according to the exact-match rule. If the best-match rules
+are reached, they actively discriminate against operators on domain types.
+If they did not, such an operator would create too many ambiguous-operator
+failures, because the casting rules always consider a domain as castable
+to or from its base type, and so the domain operator would be considered
+usable in all the same cases as a similarly-named operator on the base type.
</para>
</example>
<sect1 id="typeconv-func">
<title>Functions</title>
+<indexterm zone="typeconv-func">
+ <primary>function</primary>
+ <secondary>type resolution in an invocation</secondary>
+</indexterm>
+
<para>
- The argument types of function calls are resolved according to the
- following steps.
+ The specific function that is referenced by a function call
+ is determined using the following procedure.
</para>
<procedure>
-<title>Function Argument Type Resolution</title>
+<title>Function Type Resolution</title>
+
+<step performance="required">
+<para>
+Select the functions to be considered from the
+<classname>pg_proc</classname> system catalog. If a non-schema-qualified
+function name was used, the functions
+considered are those with the matching name and argument count that are
+visible in the current search path (see <xref linkend="ddl-schemas-path">).
+If a qualified function name was given, only functions in the specified
+schema are considered.
+</para>
+
+<substeps>
+<step performance="optional">
+<para>
+If the search path finds multiple functions of identical argument types,
+only the one appearing earliest in the path is considered. Functions of
+different argument types are considered on an equal footing regardless of
+search path position.
+</para>
+</step>
+<step performance="optional">
+<para>
+If a function is declared with a <literal>VARIADIC</> array parameter, and
+the call does not use the <literal>VARIADIC</> keyword, then the function
+is treated as if the array parameter were replaced by one or more occurrences
+of its element type, as needed to match the call. After such expansion the
+function might have effective argument types identical to some non-variadic
+function. In that case the function appearing earlier in the search path is
+used, or if the two functions are in the same schema, the non-variadic one is
+preferred.
+</para>
+</step>
+<step performance="optional">
+<para>
+Functions that have default values for parameters are considered to match any
+call that omits zero or more of the defaultable parameter positions. If more
+than one such function matches a call, the one appearing earliest in the
+search path is used. If there are two or more such functions in the same
+schema with identical parameter types in the non-defaulted positions (which is
+possible if they have different sets of defaultable parameters), the system
+will not be able to determine which to prefer, and so an <quote>ambiguous
+function call</> error will result if no better match to the call can be
+found.
+</para>
+</step>
+</substeps>
+</step>
<step performance="required">
<para>
-Check for an exact match in the <classname>pg_proc</classname> system catalog.
+Check for a function accepting exactly the input argument types.
+If one exists (there can be only one exact match in the set of
+functions considered), use it.
(Cases involving <type>unknown</type> will never find a match at
this step.)
-</para></step>
+</para>
+</step>
+
<step performance="required">
<para>
-If no exact match appears in the catalog, see whether the function call appears
-to be a trivial type coercion request. This happens if the function call
+If no exact match is found, see if the function call appears
+to be a special type conversion request. This happens if the function call
has just one argument and the function name is the same as the (internal)
name of some data type. Furthermore, the function argument must be either
-an unknown-type literal or a type that is binary-compatible with the named
-data type. When these conditions are met, the function argument is coerced
-to the named data type without any explicit function call.
+an unknown-type literal, or a type that is binary-coercible to the named
+data type, or a type that could be converted to the named data type by
+applying that type's I/O functions (that is, the conversion is either to or
+from one of the standard string types). When these conditions are met,
+the function call is treated as a form of <literal>CAST</> specification.
+ <footnote>
+ <para>
+ The reason for this step is to support function-style cast specifications
+ in cases where there is not an actual cast function. If there is a cast
+ function, it is conventionally named after its output type, and so there
+ is no need to have a special case. See
+ <xref linkend="sql-createcast">
+ for additional commentary.
+ </para>
+ </footnote>
</para>
</step>
<step performance="required">
<substeps>
<step performance="required">
<para>
-Make a list of all functions of the same name with the same number of
-arguments for which the input types
-match or can be coerced to match. (<type>unknown</type> literals are
-assumed to be coercible to anything for this purpose.) If there is only
-one, use it; else continue to the next step.
+Discard candidate functions for which the input types do not match
+and cannot be converted (using an implicit conversion) to match.
+<type>unknown</type> literals are
+assumed to be convertible to anything for this purpose. If only one
+candidate remains, use it; else continue to the next step.
</para>
</step>
<step performance="required">
<para>
-Run through all candidates and keep those with the most exact matches
-on input types. Keep all candidates if none have any exact matches.
-If only one candidate remains, use it; else continue to the next step.
+If any input argument is of a domain type, treat it as being of the
+domain's base type for all subsequent steps. This ensures that domains
+act like their base types for purposes of ambiguous-function resolution.
</para>
</step>
<step performance="required">
<para>
-Run through all candidates and keep those with the most exact or
-binary-compatible matches on input types. Keep all candidates if none have
-any exact or binary-compatible matches.
+Run through all candidates and keep those with the most exact matches
+on input types. Keep all candidates if none have exact matches.
If only one candidate remains, use it; else continue to the next step.
</para>
</step>
<step performance="required">
<para>
-Run through all candidates and keep those that accept preferred types at
-the most positions where type coercion will be required.
+Run through all candidates and keep those that accept preferred types (of the
+input data type's type category) at the most positions where type conversion
+will be required.
Keep all candidates if none accept preferred types.
If only one candidate remains, use it; else continue to the next step.
</para>
</step>
<step performance="required">
<para>
-If any input arguments are <type>unknown</type>, check the type categories accepted
+If any input arguments are <type>unknown</type>, check the type categories
+accepted
at those argument positions by the remaining candidates. At each position,
-select the <type>string</type> category if any candidate accepts that category
-(this bias towards string
-is appropriate since an unknown-type literal does look like a string).
+select the <type>string</type> category if any candidate accepts that category.
+(This bias towards string
+is appropriate since an unknown-type literal looks like a string.)
Otherwise, if all the remaining candidates accept the same type category,
select that category; otherwise fail because
-the correct choice cannot be deduced without more clues. Also note whether
-any of the candidates accept a preferred data type within the selected category.
-Now discard candidates that do not accept the selected type category;
-furthermore, if any candidate accepts a preferred type at a given argument
-position, discard candidates that accept non-preferred types for that
-argument.
+the correct choice cannot be deduced without more clues.
+Now discard candidates that do not accept the selected type category.
+Furthermore, if any candidate accepts a preferred type in that category,
+discard candidates that accept non-preferred types for that argument.
+Keep all candidates if none survive these tests.
+If only one candidate remains, use it; else continue to the next step.
</para>
</step>
<step performance="required">
<para>
-If only one candidate remains, use it. If no candidate or more than one
-candidate remains,
-then fail.
+If there are both <type>unknown</type> and known-type arguments, and all
+the known-type arguments have the same type, assume that the
+<type>unknown</type> arguments are also of that type, and check which
+candidates can accept that type at the <type>unknown</type>-argument
+positions. If exactly one candidate passes this test, use it.
+Otherwise, fail.
</para>
</step>
</substeps>
</step>
</procedure>
-<bridgehead renderas="sect2">Examples</bridgehead>
+<para>
+Note that the <quote>best match</> rules are identical for operator and
+function type resolution.
+Some examples follow.
+</para>
<example>
-<title>Factorial Function Argument Type Resolution</title>
+<title>Rounding Function Argument Type Resolution</title>
<para>
-There is only one <function>int4fac</function> function defined in the
-<classname>pg_proc</classname> catalog.
-So the following query automatically converts the <type>int2</type> argument
-to <type>int4</type>:
+There is only one <function>round</function> function that takes two
+arguments; it takes a first argument of type <type>numeric</type> and
+a second argument of type <type>integer</type>.
+So the following query automatically converts
+the first argument of type <type>integer</type> to
+<type>numeric</type>:
<screen>
-tgl=> SELECT int4fac(int2 '4');
- int4fac
----------
- 24
+SELECT round(4, 4);
+
+ round
+--------
+ 4.0000
(1 row)
</screen>
-and is actually transformed by the parser to
+That query is actually transformed by the parser to:
<screen>
-tgl=> SELECT int4fac(int4(int2 '4'));
- int4fac
----------
- 24
-(1 row)
+SELECT round(CAST (4 AS numeric), 4);
+</screen>
+</para>
+
+<para>
+Since numeric constants with decimal points are initially assigned the
+type <type>numeric</type>, the following query will require no type
+conversion and therefore might be slightly more efficient:
+<screen>
+SELECT round(4.0, 4);
</screen>
</para>
</example>
<title>Substring Function Type Resolution</title>
<para>
-There are two <function>substr</function> functions declared in <classname>pg_proc</classname>. However,
-only one takes two arguments, of types <type>text</type> and <type>int4</type>.
-</para>
+There are several <function>substr</function> functions, one of which
+takes types <type>text</type> and <type>integer</type>. If called
+with a string constant of unspecified type, the system chooses the
+candidate function that accepts an argument of the preferred category
+<literal>string</literal> (namely of type <type>text</type>).
-<para>
-If called with a string constant of unspecified type, the type is matched up
-directly with the only candidate function type:
<screen>
-tgl=> SELECT substr('1234', 3);
+SELECT substr('1234', 3);
+
substr
--------
34
<para>
If the string is declared to be of type <type>varchar</type>, as might be the case
-if it comes from a table, then the parser will try to coerce it to become <type>text</type>:
+if it comes from a table, then the parser will try to convert it to become <type>text</type>:
<screen>
-tgl=> SELECT substr(varchar '1234', 3);
+SELECT substr(varchar '1234', 3);
+
substr
--------
34
(1 row)
</screen>
-which is transformed by the parser to become
+
+This is transformed by the parser to effectively become:
<screen>
-tgl=> SELECT substr(text(varchar '1234'), 3);
- substr
---------
- 34
-(1 row)
+SELECT substr(CAST (varchar '1234' AS text), 3);
</screen>
</para>
<para>
<note>
<para>
-Actually, the parser is aware that <type>text</type> and <type>varchar</type>
-are <firstterm>binary compatible</>, meaning that one can be passed to a function that
+The parser learns from the <structname>pg_cast</> catalog that
+<type>text</type> and <type>varchar</type>
+are binary-compatible, meaning that one can be passed to a function that
accepts the other without doing any physical conversion. Therefore, no
-explicit type conversion call is really inserted in this case.
+type conversion call is really inserted in this case.
</para>
</note>
</para>
<para>
-And, if the function is called with an <type>int4</type>, the parser will
-try to convert that to <type>text</type>:
+And, if the function is called with an argument of type <type>integer</type>,
+the parser will try to convert that to <type>text</type>:
<screen>
-tgl=> SELECT substr(1234, 3);
- substr
---------
- 34
-(1 row)
+SELECT substr(1234, 3);
+ERROR: function substr(integer, integer) does not exist
+HINT: No function matches the given name and argument types. You might need
+to add explicit type casts.
</screen>
-which actually executes as
+
+This does not work because <type>integer</> does not have an implicit cast
+to <type>text</>. An explicit cast will work, however:
<screen>
-tgl=> SELECT substr(text(1234), 3);
+SELECT substr(CAST (1234 AS text), 3);
+
substr
--------
34
(1 row)
</screen>
-This succeeds because there is a conversion function text(int4) in the
-system catalog.
</para>
</example>
</sect1>
<sect1 id="typeconv-query">
-<title>Query Targets</title>
+<title>Value Storage</title>
<para>
- Values to be inserted into a table are coerced to the destination
- column's datatype according to the
+ Values to be inserted into a table are converted to the destination
+ column's data type according to the
following steps.
</para>
<procedure>
-<title>Query Target Type Resolution</title>
+<title>Value Storage Type Conversion</title>
<step performance="required">
<para>
Check for an exact match with the target.
-</para></step>
+</para>
+</step>
+
<step performance="required">
<para>
-Otherwise, try to coerce the expression to the target type. This will succeed
-if the two types are known binary-compatible, or if there is a conversion
-function. If the expression is an unknown-type literal, the contents of
+Otherwise, try to convert the expression to the target type. This is possible
+if an <firstterm>assignment cast</> between the two types is registered in the
+<structname>pg_cast</> catalog (see <xref linkend="sql-createcast">).
+Alternatively, if the expression is an unknown-type literal, the contents of
the literal string will be fed to the input conversion routine for the target
type.
-</para></step>
+</para>
+</step>
<step performance="required">
<para>
-If the target is a fixed-length type (e.g. <type>char</type> or <type>varchar</type>
-declared with a length) then try to find a sizing function for the target
-type. A sizing function is a function of the same name as the type,
-taking two arguments of which the first is that type and the second is an
-integer, and returning the same type. If one is found, it is applied,
-passing the column's declared length as the second parameter.
-</para></step>
+Check to see if there is a sizing cast for the target type. A sizing
+cast is a cast from that type to itself. If one is found in the
+<structname>pg_cast</> catalog, apply it to the expression before storing
+into the destination column. The implementation function for such a cast
+always takes an extra parameter of type <type>integer</type>, which receives
+the destination column's <structfield>atttypmod</> value (typically its
+declared length, although the interpretation of <structfield>atttypmod</>
+varies for different data types), and it may take a third <type>boolean</>
+parameter that says whether the cast is explicit or implicit. The cast
+function
+is responsible for applying any length-dependent semantics such as size
+checking or truncation.
+</para>
+</step>
</procedure>
<title><type>character</type> Storage Type Conversion</title>
<para>
-For a target column declared as <type>character(20)</type> the following query
-ensures that the target is sized correctly:
+For a target column declared as <type>character(20)</type> the following
+statement shows that the stored value is sized correctly:
<screen>
-tgl=> CREATE TABLE vv (v character(20));
-CREATE
-tgl=> INSERT INTO vv SELECT 'abc' || 'def';
-INSERT 392905 1
-tgl=> SELECT v, length(v) FROM vv;
- v | length
-----------------------+--------
- abcdef | 20
+CREATE TABLE vv (v character(20));
+INSERT INTO vv SELECT 'abc' || 'def';
+SELECT v, octet_length(v) FROM vv;
+
+ v | octet_length
+----------------------+--------------
+ abcdef | 20
(1 row)
</screen>
+</para>
+<para>
What has really happened here is that the two unknown literals are resolved
to <type>text</type> by default, allowing the <literal>||</literal> operator
to be resolved as <type>text</type> concatenation. Then the <type>text</type>
-result of the operator is coerced to <type>bpchar</type> (<quote>blank-padded
-char</>, the internal name of the character datatype) to match the target
-column type. (Since the parser knows that <type>text</type> and
-<type>bpchar</type> are binary-compatible, this coercion is implicit and does
+result of the operator is converted to <type>bpchar</type> (<quote>blank-padded
+char</>, the internal name of the <type>character</type> data type) to match the target
+column type. (Since the conversion from <type>text</type> to
+<type>bpchar</type> is binary-coercible, this conversion does
not insert any real function call.) Finally, the sizing function
-<literal>bpchar(bpchar, integer)</literal> is found in the system catalogs
+<literal>bpchar(bpchar, integer, boolean)</> is found in the system catalog
and applied to the operator's result and the stored column length. This
type-specific function performs the required length check and addition of
padding spaces.
</sect1>
<sect1 id="typeconv-union-case">
-<title><literal>UNION</> and <literal>CASE</> Constructs</title>
+<title><literal>UNION</literal>, <literal>CASE</literal>, and Related Constructs</title>
+
+<indexterm zone="typeconv-union-case">
+ <primary>UNION</primary>
+ <secondary>determination of result type</secondary>
+</indexterm>
+
+<indexterm zone="typeconv-union-case">
+ <primary>CASE</primary>
+ <secondary>determination of result type</secondary>
+</indexterm>
+
+<indexterm zone="typeconv-union-case">
+ <primary>ARRAY</primary>
+ <secondary>determination of result type</secondary>
+</indexterm>
+
+<indexterm zone="typeconv-union-case">
+ <primary>VALUES</primary>
+ <secondary>determination of result type</secondary>
+</indexterm>
+
+<indexterm zone="typeconv-union-case">
+ <primary>GREATEST</primary>
+ <secondary>determination of result type</secondary>
+</indexterm>
+
+<indexterm zone="typeconv-union-case">
+ <primary>LEAST</primary>
+ <secondary>determination of result type</secondary>
+</indexterm>
+
+<para>
+SQL <literal>UNION</> constructs must match up possibly dissimilar
+types to become a single result set. The resolution algorithm is
+applied separately to each output column of a union query. The
+<literal>INTERSECT</> and <literal>EXCEPT</> constructs resolve
+dissimilar types in the same way as <literal>UNION</>. The
+<literal>CASE</>, <literal>ARRAY</>, <literal>VALUES</>,
+<function>GREATEST</> and <function>LEAST</> constructs use the identical
+algorithm to match up their component expressions and select a result
+data type.
+</para>
+
+<procedure>
+<title>Type Resolution for <literal>UNION</literal>, <literal>CASE</literal>,
+and Related Constructs</title>
+
+<step performance="required">
+<para>
+If all inputs are of the same type, and it is not <type>unknown</type>,
+resolve as that type.
+</para>
+</step>
+<step performance="required">
<para>
-SQL <literal>UNION</> constructs must match up possibly dissimilar types to
-become a single result set. The resolution algorithm is applied separately
-to each output column of a union query. The <literal>INTERSECT</> and
-<literal>EXCEPT</> constructs resolve dissimilar types in the same way as
-<literal>UNION</>.
-A <literal>CASE</> construct also uses the identical algorithm to match up its
-component expressions and select a result datatype.
+If any input is of a domain type, treat it as being of the
+domain's base type for all subsequent steps.
+ <footnote>
+ <para>
+ Somewhat like the treatment of domain inputs for operators and
+ functions, this behavior allows a domain type to be preserved through
+ a <literal>UNION</> or similar construct, so long as the user is
+ careful to ensure that all inputs are implicitly or explicitly of that
+ exact type. Otherwise the domain's base type will be preferred.
+ </para>
+ </footnote>
</para>
-<procedure>
-<title><literal>UNION</> and <literal>CASE</> Type Resolution</title>
+</step>
<step performance="required">
<para>
If all inputs are of type <type>unknown</type>, resolve as type
-<type>text</type> (the preferred type for string category).
-Otherwise, ignore the <type>unknown</type> inputs while choosing the type.
-</para></step>
+<type>text</type> (the preferred type of the string category).
+Otherwise, <type>unknown</type> inputs are ignored for the purposes
+of the remaining rules.
+</para>
+</step>
<step performance="required">
<para>
If the non-unknown inputs are not all of the same type category, fail.
-</para></step>
+</para>
+</step>
<step performance="required">
<para>
-If one or more non-unknown inputs are of a preferred type in that category,
-resolve as that type.
-</para></step>
+Choose the first non-unknown input type which is a preferred type in
+that category, if there is one.
+</para>
+</step>
<step performance="required">
<para>
-Otherwise, resolve as the type of the first non-unknown input.
-</para></step>
+Otherwise, choose the last non-unknown input type that allows all the
+preceding non-unknown inputs to be implicitly converted to it. (There
+always is such a type, since at least the first type in the list must
+satisfy this condition.)
+</para>
+</step>
<step performance="required">
<para>
-Coerce all inputs to the selected type.
-</para></step>
+Convert all inputs to the selected type. Fail if there is not a
+conversion from a given input to the selected type.
+</para>
+</step>
</procedure>
-<bridgehead renderas="sect2">Examples</bridgehead>
+<para>
+Some examples follow.
+</para>
<example>
-<title>Underspecified Types in a Union</title>
+<title>Type Resolution with Underspecified Types in a Union</title>
<para>
<screen>
-tgl=> SELECT text 'a' AS "Text" UNION SELECT 'b';
- Text
+SELECT text 'a' AS "text" UNION SELECT 'b';
+
+ text
------
a
b
(2 rows)
</screen>
-Here, the unknown-type literal <literal>'b'</literal> will be resolved as type text.
+Here, the unknown-type literal <literal>'b'</literal> will be resolved to type <type>text</type>.
</para>
</example>
<example>
-<title>Type Conversion in a Simple Union</title>
+<title>Type Resolution in a Simple Union</title>
<para>
<screen>
-tgl=> SELECT 1.2 AS "Double" UNION SELECT 1;
- Double
---------
- 1
- 1.2
+SELECT 1.2 AS "numeric" UNION SELECT 1;
+
+ numeric
+---------
+ 1
+ 1.2
(2 rows)
</screen>
-The literal <literal>1.2</> is of type <type>double precision</>,
-the preferred type in the numeric category, so that type is used.
+The literal <literal>1.2</> is of type <type>numeric</>,
+and the <type>integer</type> value <literal>1</> can be cast implicitly to
+<type>numeric</>, so that type is used.
</para>
</example>
<example>
-<title>Type Conversion in a Transposed Union</title>
+<title>Type Resolution in a Transposed Union</title>
<para>
-Here the output type of the union is forced to match the type of
-the first clause in the union:
-
<screen>
-tgl=> SELECT 1 AS "All integers"
-tgl-> UNION SELECT CAST('2.2' AS REAL);
- All integers
---------------
- 1
- 2
+SELECT 1 AS "real" UNION SELECT CAST('2.2' AS REAL);
+
+ real
+------
+ 1
+ 2.2
(2 rows)
</screen>
+Here, since type <type>real</> cannot be implicitly cast to <type>integer</>,
+but <type>integer</> can be implicitly cast to <type>real</>, the union
+result type is resolved as <type>real</>.
</para>
+</example>
+</sect1>
+
+<sect1 id="typeconv-select">
+<title><literal>SELECT</literal> Output Columns</title>
+
+<indexterm zone="typeconv-select">
+ <primary>SELECT</primary>
+ <secondary>determination of result type</secondary>
+</indexterm>
+
<para>
-Since <type>REAL</type> is not a preferred type, the parser sees no reason
-to select it over <type>INTEGER</type> (which is what the 1 is), and instead
-falls back on the use-the-first-alternative rule.
-This example demonstrates that the preferred-type mechanism doesn't encode
-as much information as we'd like. Future versions of
-<productname>PostgreSQL</productname> may support a more general notion of
-type preferences.
+The rules given in the preceding sections will result in assignment
+of non-<type>unknown</> data types to all expressions in a SQL query,
+except for unspecified-type literals that appear as simple output
+columns of a <command>SELECT</> command. For example, in
+
+<screen>
+SELECT 'Hello World';
+</screen>
+
+there is nothing to identify what type the string literal should be
+taken as. In this situation <productname>PostgreSQL</> will fall back
+to resolving the literal's type as <type>text</>.
</para>
-</example>
+
+<para>
+When the <command>SELECT</> is one arm of a <literal>UNION</>
+(or <literal>INTERSECT</> or <literal>EXCEPT</>) construct, or when it
+appears within <command>INSERT ... SELECT</>, this rule is not applied
+since rules given in preceding sections take precedence. The type of an
+unspecified-type literal can be taken from the other <literal>UNION</> arm
+in the first case, or from the destination column in the second case.
+</para>
+
+<para>
+<literal>RETURNING</> lists are treated the same as <command>SELECT</>
+output lists for this purpose.
+</para>
+
+<note>
+ <para>
+ Prior to <productname>PostgreSQL</> 10, this rule did not exist, and
+ unspecified-type literals in a <command>SELECT</> output list were
+ left as type <type>unknown</>. That had assorted bad consequences,
+ so it's been changed.
+ </para>
+</note>
</sect1>
</chapter>
-
-<!-- Keep this comment at the end of the file
-Local variables:
-mode:sgml
-sgml-omittag:t
-sgml-shorttag:t
-sgml-minimize-attributes:nil
-sgml-always-quote-attributes:t
-sgml-indent-step:1
-sgml-indent-data:t
-sgml-parent-document:nil
-sgml-default-dtd-file:"./reference.ced"
-sgml-exposed-tags:nil
-sgml-local-catalogs:("/usr/lib/sgml/catalog")
-sgml-local-ecat-files:nil
-End:
--->
projects / postgresql / blobdiff