Package org.apache.calcite.rel.type

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:

    • deriveTimeFrameSet

      default TimeFrameSet deriveTimeFrameSet(TimeFrameSet frameSet)
      Returns a list of supported time frames.

      The validator calls this method with TimeFrames.CORE as an argument, and the default implementation of this method returns its input, and therefore CORE is the default time frame set.

      If you wish to use a custom time frame set, create an instance of RelDataTypeSystem that overrides this method. Your method should call TimeFrameSet.builder(), will probably add all or most of the time frames in the frameSet argument, and then call TimeFrameSet.Builder.build().

      Parameters:
      frameSet - Set of built-in time frames