GoogleSQL for BigQuery supports conversion.Conversion includes, but isn't limited to, casting, coercion, andsupertyping.

• Casting is explicit conversion and uses theCAST() function.
• Coercion is implicit conversion, which GoogleSQL performsautomatically under the conditions described below.
• A supertype is a common type to which two or more expressions can be coerced.

There are also conversions that have their own function names, such asPARSE_DATE(). To learn more about these functions, seeConversion functions.

Comparison of casting and coercion

The following table summarizes all possible cast and coercion possibilities forGoogleSQL data types. TheCoerce to column applies to allexpressions of a given data type, (for example, acolumn), butliterals and parameters can also be coerced. Seeliteral coercion andquery parameter coercion for details.

Casting

Most data types can be cast from one type to another with theCAST function.When usingCAST, a query can fail if GoogleSQL is unable to performthe cast. If you want to protect your queries from these types of errors, youcan useSAFE_CAST. To learn more about the rules forCAST,SAFE_CAST andother casting functions, seeConversion functions.

Coercion

GoogleSQL coerces the result type of an argument expression to anothertype if needed to match function signatures. For example, if functionfunc()is defined to take a single argument of typeFLOAT64and an expression is used as an argument that has a result type ofINT64, then the result of the expression will becoerced toFLOAT64 type beforefunc() is computed.

Literal coercion

GoogleSQL supports the following literal coercions:

Literal coercion is needed when the actual literal type is different from thetype expected by the function in question. Forexample, if functionfunc() takes a DATE argument,then the expressionfunc("2014-09-27") is valid because thestring literal"2014-09-27" is coerced toDATE.

Literal conversion is evaluated at analysis time, and gives an error if theinput literal can't be converted successfully to the target type.

If you want to find the supertype for a set of input types, first determine theintersection of the set of supertypes for each input type. If that set is emptythen the input types have no common supertype. If that set is non-empty, thenthe common supertype is generally themost specific type in that set. Generally,the most specific type is the type with the most restrictive domain.

Examples

Exact and inexact types

Numeric types can be exact or inexact. For supertyping, if all of theinput types are exact types, then the resulting supertype can only be anexact type.

The following table contains a list of exact and inexact numeric data types.

Examples

Types specificity

Each type has a domain of values that it supports. A type with anarrow domain is more specific than a type with a wider domain. Exact typesare more specific than inexact types because inexact types have a wider rangeof domain values that are supported than exact types. For example,INT64 is more specific thanFLOAT64.

Supertypes and literals

Supertype rules for literals are more permissive than for normal expressions,and are consistent with implicit coercion rules. The following algorithm is usedwhen the input set of types includes types related to literals:

• If there exists non-literals in the set, find the set of common supertypesof the non-literals.
• If there is at least one possible supertype, find themost specific type towhich the remaining literal types can be implicitly coerced and return thatsupertype. Otherwise, there is no supertype.
• If the set only contains types related to literals, compute the supertype ofthe literal types.
• If all input types are related toNULL literals, then the resultingsupertype isINT64.
• If no common supertype is found, an error is produced.

Examples