Interface RelDataTypeSystem

All Known Implementing Classes:
DelegatingTypeSystem, RelDataTypeSystemImpl

public interface RelDataTypeSystem
Type system.

Provides behaviors concerning type limits and behaviors. For example, in the default system, a DECIMAL can have maximum precision 19, but Hive overrides to 38.

The default implementation is DEFAULT.

  • Field Details

  • Method Details

    • getMaxScale

      int getMaxScale(SqlTypeName typeName)
      Returns the maximum scale of a given type.
    • getDefaultPrecision

      int getDefaultPrecision(SqlTypeName typeName)
      Returns default precision for this type if supported, otherwise -1 if precision is either unsupported or must be specified explicitly.
      Returns:
      Default precision
    • getMaxPrecision

      int getMaxPrecision(SqlTypeName typeName)
      Returns the maximum precision (or length) allowed for this type, or -1 if precision/length are not applicable for this type.
      Returns:
      Maximum allowed precision
    • getMaxNumericScale

      int getMaxNumericScale()
      Returns the maximum scale of a NUMERIC or DECIMAL type.
    • getMaxNumericPrecision

      int getMaxNumericPrecision()
      Returns the maximum precision of a NUMERIC or DECIMAL type.
    • getLiteral

      @Nullable String getLiteral(SqlTypeName typeName, boolean isPrefix)
      Returns the LITERAL string for the type, either PREFIX/SUFFIX.
    • isCaseSensitive

      boolean isCaseSensitive(SqlTypeName typeName)
      Returns whether the type is case sensitive.
    • isAutoincrement

      boolean isAutoincrement(SqlTypeName typeName)
      Returns whether the type can be auto increment.
    • getNumTypeRadix

      int getNumTypeRadix(SqlTypeName typeName)
      Returns the numeric type radix, typically 2 or 10. 0 means "not applicable".
    • deriveSumType

      RelDataType deriveSumType(RelDataTypeFactory typeFactory, RelDataType argumentType)
      Returns the return type of a call to the SUM aggregate function, inferred from its argument type.
    • deriveAvgAggType

      RelDataType deriveAvgAggType(RelDataTypeFactory typeFactory, RelDataType argumentType)
      Returns the return type of a call to the AVG, STDDEV or VAR aggregate functions, inferred from its argument type.
    • deriveCovarType

      RelDataType deriveCovarType(RelDataTypeFactory typeFactory, RelDataType arg0Type, RelDataType arg1Type)
      Returns the return type of a call to the COVAR aggregate function, inferred from its argument types.
    • deriveFractionalRankType

      RelDataType deriveFractionalRankType(RelDataTypeFactory typeFactory)
      Returns the return type of the CUME_DIST and PERCENT_RANK aggregate functions.
    • deriveRankType

      RelDataType deriveRankType(RelDataTypeFactory typeFactory)
      Returns the return type of the NTILE, RANK, DENSE_RANK, and ROW_NUMBER aggregate functions.
    • isSchemaCaseSensitive

      boolean isSchemaCaseSensitive()
      Whether two record types are considered distinct if their field names are the same but in different cases.
    • shouldConvertRaggedUnionTypesToVarying

      boolean shouldConvertRaggedUnionTypesToVarying()
      Whether the least restrictive type of a number of CHAR types of different lengths should be a VARCHAR type. And similarly BINARY to VARBINARY.
    • shouldUseDoubleMultiplication

      default boolean shouldUseDoubleMultiplication(RelDataTypeFactory typeFactory, RelDataType type1, RelDataType type2)
      Returns whether a decimal multiplication should be implemented by casting arguments to double values.

      Pre-condition: createDecimalProduct(type1, type2) != null

    • deriveDecimalPlusType

      default @Nullable RelDataType deriveDecimalPlusType(RelDataTypeFactory typeFactory, RelDataType type1, RelDataType type2)
      Infers the return type of a decimal addition. Decimal addition involves at least one decimal operand and requires both operands to have exact numeric types.

      Rules:

      • Let p1, s1 be the precision and scale of the first operand
      • Let p2, s2 be the precision and scale of the second operand
      • Let p, s be the precision and scale of the result
      • Let d be the number of whole digits in the result
      • Then the result type is a decimal with:
        • s = max(s1, s2)
        • p = max(p1 - s1, p2 - s2) + s + 1
      • p and s are capped at their maximum values
      Parameters:
      typeFactory - TypeFactory used to create output type
      type1 - Type of the first operand
      type2 - Type of the second operand
      Returns:
      Result type for a decimal addition
      See Also:
    • deriveDecimalMultiplyType

      default @Nullable RelDataType deriveDecimalMultiplyType(RelDataTypeFactory typeFactory, RelDataType type1, RelDataType type2)
      Infers the return type of a decimal multiplication. Decimal multiplication involves at least one decimal operand and requires both operands to have exact numeric types.

      The default implementation is SQL:2003 compliant.

      Rules:

      • Let p1, s1 be the precision and scale of the first operand
      • Let p2, s2 be the precision and scale of the second operand
      • Let p, s be the precision and scale of the result
      • Let d be the number of whole digits in the result
      • Then the result type is a decimal with:
        • p = p1 + p2)
        • s = s1 + s2
      • p and s are capped at their maximum values

      p and s are capped at their maximum values

      Parameters:
      typeFactory - TypeFactory used to create output type
      type1 - Type of the first operand
      type2 - Type of the second operand
      Returns:
      Result type for a decimal multiplication, or null if decimal multiplication should not be applied to the operands
      See Also:
    • deriveDecimalDivideType

      default @Nullable RelDataType deriveDecimalDivideType(RelDataTypeFactory typeFactory, RelDataType type1, RelDataType type2)
      Infers the return type of a decimal division. Decimal division involves at least one decimal operand and requires both operands to have exact numeric types.

      The default implementation is SQL:2003 compliant.

      Rules:

      • Let p1, s1 be the precision and scale of the first operand
      • Let p2, s2 be the precision and scale of the second operand
      • Let p, s be the precision and scale of the result
      • Let d be the number of whole digits in the result
      • Then the result type is a decimal with:
        • d = p1 - s1 + s2
        • s < max(6, s1 + p2 + 1)
        • p = d + s
      • p and s are capped at their maximum values
      Parameters:
      typeFactory - TypeFactory used to create output type
      type1 - Type of the first operand
      type2 - Type of the second operand
      Returns:
      Result type for a decimal division, or null if decimal division should not be applied to the operands
      See Also:
    • deriveDecimalModType

      default @Nullable RelDataType deriveDecimalModType(RelDataTypeFactory typeFactory, RelDataType type1, RelDataType type2)
      Infers the return type of a decimal modulus operation. Decimal modulus involves at least one decimal operand.

      The default implementation is SQL:2003 compliant: the declared type of the result is the declared type of the second operand (expression divisor).

      Parameters:
      typeFactory - TypeFactory used to create output type
      type1 - Type of the first operand
      type2 - Type of the second operand
      Returns:
      Result type for a decimal modulus, or null if decimal modulus should not be applied to the operands
      See Also: