Whether casting from as to is valid.

Find the tightest common type of two types that might be used in a binary expression. This handles all numeric types except fixed-precision decimals interacting with each other or with primitive types, because in that case the precision and scale of the result depends on the operation. Those rules are implemented in DecimalPrecision.

Looking for a widened data type of a given sequence of data types with some acceptable loss of precision. E.g. there is no common type for double and decimal because double's range is larger than decimal, and yet decimal is more precise than double, but in union we would cast the decimal into double.

Finds a wider type when one or both types are decimals. If the wider decimal type exceeds system limitation, this rule will truncate the decimal type. If a decimal and other fractional types are compared, returns a double type.

Looking for a widened data type of two given data types with some acceptable loss of precision. E.g. there is no common type for double and decimal because double's range is larger than decimal, and yet decimal is more precise than double, but in union we would cast the decimal into double.

Check whether the given types are equal ignoring nullable, containsNull and valueContainsNull.

Given an expected data type, try to cast the expression and return the cast expression.

If the expression already fits the input type, we simply return the expression itself. If the expression has an incompatible type that cannot be implicitly cast, return None.

A collection of Rule that can be used to coerce differing types that participate in operations into compatible ones.

When getting a date field from a Timestamp column, cast the column as date type.

This is Spark's hack to make the implementation simple. In the default type coercion rules, the implicit cast rule does the work. However, The ANSI implicit cast rule doesn't allow converting Timestamp type as Date type, so we need to have this additional rule to make sure the date field extraction from Timestamp columns works.

Coerces the type of different branches of a CASE WHEN statement to a common type.

Coerces the types of Concat children to expected ones.

If spark.sql.function.concatBinaryAsString is false and all children types are binary, the expected types are binary. Otherwise, the expected ones are strings.

Hive only performs integral division with the DIV operator. The arguments to / are always converted to fractional types.

Coerces the types of Elt children to expected ones.

If spark.sql.function.eltOutputAsString is false and all children types are binary, the expected types are binary. Otherwise, the expected ones are strings.

This ensure that the types for various functions are as expected.

Coerces the type of different branches of If statement to a common type.

Casts types according to the expected input types for Expressions.

Handles type coercion for both IN expression with subquery and IN expressions without subquery. 1. In the first case, find the common type by comparing the left hand side (LHS) expression types against corresponding right hand side (RHS) expression derived from the subquery expression's plan output. Inject appropriate casts in the LHS and RHS side of IN expression.

2. In the second case, convert the value and in list expressions to the common operator type by looking at all the argument types and finding the closest one that all the arguments can be cast to. When no common operator type is found the original expression will be returned and an Analysis Exception will be raised at the type checking phase.

The DIV operator always returns long-type value. This rule cast the integral inputs to long type, to avoid overflow during calculation.

Coerces key types of two different MapType arguments of the MapZipWith expression to a common type.

A type coercion rule that implicitly casts procedure arguments to expected types.

Coerces NullTypes in the Stack expression to the column types of the corresponding positions.

A special rule to support string literal as the second argument of date_add/date_sub functions, to keep backward compatibility as a temporary workaround. TODO(SPARK-28589): implement ANSI type type coercion and handle string literals.

Widens the data types of the Unpivot values.

Widens the data types of the children of Union/Except/Intersect. 1. When ANSI mode is off: Loosely based on rules from "Hadoop: The Definitive Guide" 2nd edition, by Tom White

The implicit conversion rules can be summarized as follows:

• Any integral numeric type can be implicitly converted to a wider type.
• All the integral numeric types, FLOAT, and (perhaps surprisingly) STRING can be implicitly converted to DOUBLE.
• TINYINT, SMALLINT, and INT can all be converted to FLOAT.
• BOOLEAN types cannot be converted to any other type.
• Any integral numeric type can be implicitly converted to decimal type.
• two different decimal types will be converted into a wider decimal type for both of them.
• decimal type will be converted into double if there float or double together with it.

All types when UNION-ed with strings will be promoted to strings. Other string conversions are handled by PromoteStrings.

Widening types might result in loss of precision in the following cases:

• IntegerType to FloatType
• LongType to FloatType
• LongType to DoubleType
• DecimalType to Double

2. When ANSI mode is on: The implicit conversion is determined by the closest common data type from the precedent lists from left and right child. See the comments of Object AnsiTypeCoercion for details.

Cast WindowFrame boundaries to the type they operate upon.

ANSI type coercion helper that matches against date-time expressions in order to type coerce children to expected types.

Type coercion helper that matches against a CaseWhen expression in order to type coerce different branches to a common type.

Type coercion helper that matches against Concat expressions in order to type coerce expression's children to expected types.

Type coercion helper that matches against date-time expressions in order to type coerce children to expected types.

Type coercion helper that matches against Elt expression in order to type coerce expression's children to expected types.

Type coercion helper that matches against function expression in order to type coerce function argument types to expected types.

Type coercion helper that matches against an If expression in order to type coerce different branches to a common type.

Type coercion helper that matches against expression in order to type coerce expression's input types to expected types.

Type coercion helper that matches agaist In and InSubquery expressions in order to type coerce LHS and RHS to expected types.

Type coercion helper that matches against MapZipWith expressions in order to type coerce key types of input maps to a common type.

Type coercion helper that matches against WindowFrameTypeCoercion expression in order to type coerce window boundaries to the type they operate upon.