Inheritance diagram for com.mapd.calcite.parser.HeavyDBTypeCoercion:

Collaboration diagram for com.mapd.calcite.parser.HeavyDBTypeCoercion:

Public Member Functions
	HeavyDBTypeCoercion (RelDataTypeFactory typeFactory, SqlValidator validator)

int	calculateTypeCoercionScore (SqlCallBinding callBinding, ExtTableFunction udtf)

RelDataType	getWiderTypeForTwo (RelDataType type1, RelDataType type2, boolean stringPromotion)

boolean	extTableFunctionTypeCoercion (SqlCallBinding callBinding, ExtTableFunction udtf)

Protected Member Functions
boolean	needToCast (SqlValidatorScope scope, SqlNode node, RelDataType toType)

Private Member Functions
int	calculateScoreForCursorOperand (SqlNode cursorOperand, int index, SqlValidatorScope scope, ExtTableFunction udtf)

void	coerceCursorType (SqlValidatorScope scope, SqlCall call, int index, SqlNode cursorOperand, ExtTableFunction udtf)

void	updateValidatedType (List< RelDataTypeField > typeList, SqlSelect selectNode, int operandIndex)

int	getScoreForTypes (RelDataType targetType, RelDataType originalType, boolean isCursorArgument)

void	coerceBinOpOperand (SqlBasicCall binOp, RelDataType targetType, SqlValidatorScope scope)

boolean	shouldCoerceBinOpOperand (SqlNode op, RelDataType targetType, SqlValidatorScope scope)

Detailed Description

Definition at line 31 of file HeavyDBTypeCoercion.java.

Constructor & Destructor Documentation

com.mapd.calcite.parser.HeavyDBTypeCoercion.HeavyDBTypeCoercion	(	RelDataTypeFactory	typeFactory,
		SqlValidator	validator
	)

inline

Definition at line 32 of file HeavyDBTypeCoercion.java.

                                                                                      {
     super(typeFactory, validator);
   }

Member Function Documentation

int com.mapd.calcite.parser.HeavyDBTypeCoercion.calculateScoreForCursorOperand	(	SqlNode	cursorOperand,
		int	index,
		SqlValidatorScope	scope,
		ExtTableFunction	udtf
	)

inlineprivate

Calculates a type coercion score for a single CURSOR() operand. CURSORS need special logic because their underlying types are composite types of one or multiple columns.

Definition at line 103 of file HeavyDBTypeCoercion.java.

References com.mapd.parser.server.ExtensionFunction.ExtArgumentType.Cursor, com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.getArgTypes(), com.mapd.calcite.parser.HeavyDBTypeCoercion.getScoreForTypes(), com.mapd.calcite.parser.HeavyDBTypeCoercion.getWiderTypeForTwo(), score, and com.mapd.calcite.parser.HeavyDBTypeCoercion.shouldCoerceBinOpOperand().

Referenced by com.mapd.calcite.parser.HeavyDBTypeCoercion.calculateTypeCoercionScore().

                                  {
     int score = 0;
 
     String formalOperandName = udtf.getExtendedParamNames().get(index);
     List<ExtArgumentType> formalFieldTypes =
             udtf.getCursorFieldTypes().get(formalOperandName);
 
     // If we are typechecking a CURSOR parameter for an overload where this parameter is
     // not a CURSOR/Column type, then it can never typecheck.
     if (udtf.getArgTypes().get(index) != ExtArgumentType.Cursor) {
       return -1;
     }
 
     if (formalFieldTypes == null || formalFieldTypes.size() == 0) {
       System.out.println(
               "Warning: UDTF has no CURSOR field subtype data. Proceeding assuming CURSOR typechecks.");
       // penalize implementations without subtype data, to favor ones that have better
       // type matches
       return 1000;
     }
 
     switch (cursorOperand.getKind()) {
       case SELECT: {
         SqlSelect selectNode = (SqlSelect) cursorOperand;
 
         int iFormal = 0, iActual = 0;
         for (; iActual < selectNode.getSelectList().size()
                 && iFormal < formalFieldTypes.size();
                 iActual++, iFormal++) {
           SqlNode selectOperand = selectNode.getSelectList().get(iActual);
           ExtArgumentType extType = formalFieldTypes.get(iFormal);
           RelDataType formalRelType = toRelDataType(extType, factory);
           RelDataType actualRelType = factory.createTypeWithNullability(
                   validator.deriveType(scope, selectOperand), true);
           RelDataType widerType = getWiderTypeForTwo(formalRelType, actualRelType, false);
 
           if (formalRelType.getSqlTypeName() == SqlTypeName.COLUMN_LIST) {
             ExtArgumentType colListSubtype = getValueType(extType);
             RelDataType formalSubtype = toRelDataType(colListSubtype, factory);
 
             if (isArrayType(colListSubtype)
                     && actualRelType.getSqlTypeName() == SqlTypeName.ARRAY) {
               ArraySqlType formalArrayType = (ArraySqlType) formalSubtype;
               ArraySqlType actualArrayType = (ArraySqlType) actualRelType;
               if (!SqlTypeUtil.sameNamedType(formalArrayType.getComponentType(),
                           actualArrayType.getComponentType())) {
                 // Arrays are not castable, so arrays whose underlying types don't match
                 // can fail early
                 return -1;
               }
             }
 
             widerType = getWiderTypeForTwo(actualRelType, formalSubtype, false);
             if (!SqlTypeUtil.sameNamedType(actualRelType, formalSubtype)) {
               if (widerType == null || widerType == actualRelType) {
                 // no common type, or actual type is wider than formal
                 return -1;
               }
             }
 
             int colListSize = 0;
             int numFormalArgumentsLeft = (formalFieldTypes.size() - 1) - iFormal;
             int maxColListSize =
                     selectNode.getSelectList().size() - numFormalArgumentsLeft - iActual;
             while (colListSize < maxColListSize) {
               SqlNode curOperand = selectNode.getSelectList().get(iActual + colListSize);
               actualRelType = scope.getValidator().deriveType(scope, curOperand);
               widerType = getWiderTypeForTwo(formalSubtype, actualRelType, false);
               if (!SqlTypeUtil.sameNamedType(actualRelType, formalSubtype)) {
                 if (widerType == null
                         || !SqlTypeUtil.sameNamedType(widerType, formalSubtype)) {
                   // no common type, or actual type is wider than formal
                   break;
                 } else if (widerType != formalSubtype) {
                   // formal subtype is narrower than widerType, we do not support
                   // downcasting
                   break;
                 } else {
                   score += getScoreForTypes(widerType, actualRelType, true);
                 }
               } else {
                 // Calcite considers the result of some binary operations as a wider type,
                 // even though they're not passed to the backend as such (FLOAT + literal
                 // == DOUBLE, for instance). We penalize these so that literal operands
                 // are casted regardless. (See QE-788)
                 score += shouldCoerceBinOpOperand(curOperand, widerType, scope) ? 100 : 0;
               }
               colListSize++;
             }
             iActual += colListSize - 1;
           } else if (actualRelType != formalRelType) {
             if (widerType == null) {
               // no common wider type
               return -1;
             } else if (!SqlTypeUtil.isTimestamp(widerType)
                     && SqlTypeUtil.sameNamedType(formalRelType, actualRelType)) {
               // TIMESTAMPs of different precision need coercion, but other structurally
               // equal types do not (i.e VARCHAR(1) and VARCHAR(10))
               continue;
             } else if (actualRelType == widerType
                     || !SqlTypeUtil.sameNamedType(widerType, formalRelType)) {
               // formal type is narrower than widerType or the provided actualType, we do
               // not support downcasting
               return -1;
             } else {
               score += getScoreForTypes(widerType, actualRelType, true);
             }
           } else {
             // Calcite considers the result of some binary operations as a wider type,
             // even though they're not passed to the backend as such (FLOAT + literal
             // == DOUBLE, for instance). We penalize these so that literal operands
             // are casted regardless. (See QE-788)
             score += shouldCoerceBinOpOperand(selectOperand, widerType, scope) ? 100 : 0;
           }
         }
 
         if (iActual < selectNode.getSelectList().size()) {
           return -1;
         }
         return score;
       }
       default: {
         System.out.println("Unsupported subquery kind in UDTF CURSOR input argument: "
                 + cursorOperand.getKind());
         return -1;
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

int com.mapd.calcite.parser.HeavyDBTypeCoercion.calculateTypeCoercionScore	(	SqlCallBinding	callBinding,
		ExtTableFunction	udtf
	)

inline

Calculates a type coercion score for a given call to a User-Defined Table Function, assuming the call is bound to overload . This is used to perform overload resolution and type checking while considering implicit type coercions are performed (automatic casting of input scalar/columnar arguments).

Definition at line 42 of file HeavyDBTypeCoercion.java.

References com.mapd.calcite.parser.HeavyDBTypeCoercion.calculateScoreForCursorOperand(), com.mapd.calcite.parser.HeavyDBTypeCoercion.getScoreForTypes(), com.mapd.calcite.parser.HeavyDBTypeCoercion.getWiderTypeForTwo(), and score.

Referenced by com.mapd.calcite.parser.ExtTableFunctionTypeChecker.checkOperandTypes().

                                                              {
     final List<ExtArgumentType> paramTypes = udtf.getArgTypes();
     SqlCall permutedCall = callBinding.permutedCall();
     assert paramTypes != null;
     int score = 0;
     for (int i = 0; i < permutedCall.operandCount(); i++) {
       SqlNode operand = permutedCall.operand(i);
 
       // DEFAULT operands should always type-check without any casting (they will be
       // filled in later during sql2rel translation)
       if (operand.getKind() == SqlKind.DEFAULT) {
         continue;
       }
 
       RelDataType actualRelType = validator.deriveType(callBinding.getScope(), operand);
       RelDataType formalRelType = toRelDataType(paramTypes.get(i), factory);
 
       if (actualRelType.getSqlTypeName() == SqlTypeName.CURSOR) {
         SqlCall cursorCall = (SqlCall) operand;
         int cursorScore = calculateScoreForCursorOperand(
                 cursorCall.operand(0), i, callBinding.getScope(), udtf);
         if (cursorScore < 0) {
           return -1;
         }
         score += cursorScore;
       } else if (actualRelType != formalRelType) {
         if (SqlTypeUtil.isInterval(actualRelType)
                 && SqlTypeUtil.isInterval(formalRelType)) {
           // intervals only need to match on whether they're YearMonth or Day
           IntervalSqlType actualInterval = (IntervalSqlType) actualRelType;
           IntervalSqlType formalInterval = (IntervalSqlType) formalRelType;
           if (actualInterval.getIntervalQualifier().isYearMonth()
                   == formalInterval.getIntervalQualifier().isYearMonth()) {
             continue;
           } else {
             return -1;
           }
         }
         RelDataType widerType = getWiderTypeForTwo(actualRelType, formalRelType, false);
         if (widerType == null) {
           return -1;
         } else if (!SqlTypeUtil.isTimestamp(widerType)
                 && SqlTypeUtil.sameNamedType(formalRelType, actualRelType)) {
           // TIMESTAMPs of different precision need coercion, but other structurally equal
           // types do not (i.e VARCHAR(1) and VARCHAR(10))
           continue;
         } else if (actualRelType == widerType) {
           return -1;
         } else if (widerType != actualRelType) {
           score += getScoreForTypes(widerType, actualRelType, false);
         }
       }
     }
     return score;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void com.mapd.calcite.parser.HeavyDBTypeCoercion.coerceBinOpOperand	(	SqlBasicCall	binOp,
		RelDataType	targetType,
		SqlValidatorScope	scope
	)

inlineprivate

Coerces operands of a binary operator to the given .

Definition at line 497 of file HeavyDBTypeCoercion.java.

Referenced by com.mapd.calcite.parser.HeavyDBTypeCoercion.coerceCursorType().

                                                                                {
     if (binOp.getKind() == SqlKind.AS) {
       binOp = binOp.operand(0);
     }
     coerceOperandType(scope, binOp, 0, targetType);
     coerceOperandType(scope, binOp, 1, targetType);
   }

Here is the caller graph for this function:

void com.mapd.calcite.parser.HeavyDBTypeCoercion.coerceCursorType	(	SqlValidatorScope	scope,
		SqlCall	call,
		int	index,
		SqlNode	cursorOperand,
		ExtTableFunction	udtf
	)

inlineprivate

Definition at line 304 of file HeavyDBTypeCoercion.java.

References com.mapd.calcite.parser.HeavyDBTypeCoercion.coerceBinOpOperand(), com.mapd.calcite.parser.HeavyDBTypeCoercion.getWiderTypeForTwo(), com.mapd.calcite.parser.HeavyDBTypeCoercion.shouldCoerceBinOpOperand(), and com.mapd.calcite.parser.HeavyDBTypeCoercion.updateValidatedType().

Referenced by com.mapd.calcite.parser.HeavyDBTypeCoercion.extTableFunctionTypeCoercion().

                                  {
     String formalOperandName = udtf.getExtendedParamNames().get(index);
     List<ExtArgumentType> formalFieldTypes =
             udtf.getCursorFieldTypes().get(formalOperandName);
     if (formalFieldTypes == null || formalFieldTypes.size() == 0) {
       return;
     }
 
     switch (cursorOperand.getKind()) {
       case SELECT: {
         SqlSelect selectNode = (SqlSelect) cursorOperand;
         int iFormal = 0, iActual = 0;
         List<RelDataTypeField> newValidatedTypeList = new ArrayList<>();
         for (; iActual < selectNode.getSelectList().size()
                 && iFormal < formalFieldTypes.size();
                 iFormal++, iActual++) {
           SqlNode selectOperand = selectNode.getSelectList().get(iActual);
           ExtArgumentType extType = formalFieldTypes.get(iFormal);
           RelDataType formalRelType = toRelDataType(extType, factory);
           RelDataType actualRelType = validator.deriveType(scope, selectOperand);
           RelDataType widerType = getWiderTypeForTwo(formalRelType, actualRelType, false);
 
           if (isColumnArrayType(extType) || isColumnListArrayType(extType)) {
             // Arrays can't be casted so don't bother trying
             updateValidatedType(newValidatedTypeList, selectNode, iActual);
             continue;
           }
 
           if (formalRelType.getSqlTypeName() == SqlTypeName.COLUMN_LIST) {
             ExtArgumentType colListSubtype = getValueType(extType);
             RelDataType formalSubtype = toRelDataType(colListSubtype, factory);
             widerType = getWiderTypeForTwo(actualRelType, formalSubtype, false);
 
             int colListSize = 0;
             int numFormalArgumentsLeft = (formalFieldTypes.size() - 1) - iFormal;
             int maxColListSize =
                     selectNode.getSelectList().size() - numFormalArgumentsLeft - iActual;
             while (colListSize < maxColListSize) {
               SqlNode curOperand = selectNode.getSelectList().get(iActual + colListSize);
               actualRelType = scope.getValidator().deriveType(scope, curOperand);
               widerType = getWiderTypeForTwo(formalSubtype, actualRelType, false);
               if (!SqlTypeUtil.sameNamedType(actualRelType, formalSubtype)) {
                 if (widerType == null) {
                   break;
                 } else if (actualRelType != widerType) {
                   coerceColumnType(scope,
                           selectNode.getSelectList(),
                           iActual + colListSize,
                           widerType);
                 }
               } else if (shouldCoerceBinOpOperand(curOperand, widerType, scope)) {
                 coerceBinOpOperand((SqlBasicCall) curOperand, widerType, scope);
               }
 
               updateValidatedType(
                       newValidatedTypeList, selectNode, iActual + colListSize);
               colListSize++;
             }
             iActual += colListSize - 1;
           } else if (actualRelType != formalRelType) {
             if (!SqlTypeUtil.isTimestamp(widerType)
                     && SqlTypeUtil.sameNamedType(actualRelType, formalRelType)) {
               updateValidatedType(newValidatedTypeList, selectNode, iActual);
               continue;
             }
             if (widerType != actualRelType) {
               coerceColumnType(scope, selectNode.getSelectList(), iActual, widerType);
             }
             updateValidatedType(newValidatedTypeList, selectNode, iActual);
           } else {
             if (shouldCoerceBinOpOperand(selectOperand, widerType, scope)) {
               coerceBinOpOperand((SqlBasicCall) selectOperand, widerType, scope);
             }
             // keep old validated type for argument that was not coerced
             updateValidatedType(newValidatedTypeList, selectNode, iActual);
           }
         }
         RelDataType newCursorStructType = factory.createStructType(newValidatedTypeList);
         RelDataType newCursorType = factory.createTypeWithNullability(newCursorStructType,
                 validator.getValidatedNodeType(selectNode).isNullable());
         validator.setValidatedNodeType(selectNode, newCursorType);
         break;
       }
       default: {
         return;
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

boolean com.mapd.calcite.parser.HeavyDBTypeCoercion.extTableFunctionTypeCoercion	(	SqlCallBinding	callBinding,
		ExtTableFunction	udtf
	)

inline

After a call has been bound to the lowest cost overload, this method performs any necessary coercion of input scalar/columnar arguments in the call.

Definition at line 258 of file HeavyDBTypeCoercion.java.

References com.mapd.calcite.parser.HeavyDBTypeCoercion.coerceCursorType(), and com.mapd.calcite.parser.HeavyDBTypeCoercion.getWiderTypeForTwo().

                                                              {
     boolean coerced = false;
     final List<ExtArgumentType> paramTypes = udtf.getArgTypes();
     SqlCall permutedCall = callBinding.permutedCall();
     for (int i = 0; i < permutedCall.operandCount(); i++) {
       SqlNode operand = permutedCall.operand(i);
       if (operand.getKind() == SqlKind.DEFAULT) {
         // DEFAULT operands don't need to be coerced, they will be filled in by
         // appropriately typed constants later
         continue;
       }
 
       RelDataType actualRelType = validator.deriveType(callBinding.getScope(), operand);
 
       if (actualRelType.getSqlTypeName() == SqlTypeName.CURSOR) {
         SqlCall cursorCall = (SqlCall) operand;
         coerceCursorType(
                 callBinding.getScope(), permutedCall, i, cursorCall.operand(0), udtf);
       }
 
       RelDataType formalRelType = toRelDataType(paramTypes.get(i), factory);
       if (actualRelType != formalRelType) {
         if (SqlTypeUtil.isInterval(actualRelType)
                 && SqlTypeUtil.isInterval(formalRelType)) {
           IntervalSqlType actualInterval = (IntervalSqlType) actualRelType;
           IntervalSqlType formalInterval = (IntervalSqlType) formalRelType;
           if (actualInterval.getIntervalQualifier().isYearMonth()
                   == formalInterval.getIntervalQualifier().isYearMonth()) {
             continue;
           }
         }
         RelDataType widerType = getWiderTypeForTwo(actualRelType, formalRelType, false);
         if (!SqlTypeUtil.isTimestamp(widerType)
                 && SqlTypeUtil.sameNamedType(formalRelType, actualRelType)) {
           // TIMESTAMPs of different precision need coercion, but other structurally equal
           // types do not (i.e VARCHAR(1) and VARCHAR(10))
           continue;
         }
         coerced = coerceOperandType(callBinding.getScope(), permutedCall, i, widerType)
                 || coerced;
       }
     }
     return coerced;
   }

Here is the call graph for this function:

int com.mapd.calcite.parser.HeavyDBTypeCoercion.getScoreForTypes	(	RelDataType	targetType,
		RelDataType	originalType,
		boolean	isCursorArgument
	)

inlineprivate

Returns a coercion score between an input type and a target type to be casted to. Currently we consider cursor arguments as 100x more expensive than scalar arguments. We also consider a 10x cost to cast from integer to floating point types, to favor overloads that conserve precision.

multiplier

Definition at line 464 of file HeavyDBTypeCoercion.java.

Referenced by com.mapd.calcite.parser.HeavyDBTypeCoercion.calculateScoreForCursorOperand(), and com.mapd.calcite.parser.HeavyDBTypeCoercion.calculateTypeCoercionScore().

                                                                                       {
     // we assume casting columns is 100x more expensive than casting scalars
     int baseScore = isCursorArgument ? 100 : 1;
     switch (originalType.getSqlTypeName()) {
       case TINYINT:
       case SMALLINT:
       case INTEGER:
       case BIGINT: {
         int multiplier = 1;
         if (SqlTypeUtil.isApproximateNumeric(targetType)) {
           // should favor keeping integer types over promoting to floating point
           multiplier = 10;
         } /* TODO: Re-enable cast to string types after ColumnList binding is resolved
          else if (SqlTypeUtil.inCharFamily(targetType)) {
            // promoting to char types should be a last resort
            multiplier = 1000;
          }*/
         return baseScore * multiplier;
       }
       default: {
         // promoting to char types should be a last resort
         /* TODO: Re-enable cast to string types after ColumnList binding is resolved
         int multiplier = (SqlTypeUtil.inCharFamily(targetType) ? 1000 : 1);
         */
         return baseScore ;
       }
     }
   }

Here is the caller graph for this function:

RelDataType com.mapd.calcite.parser.HeavyDBTypeCoercion.getWiderTypeForTwo	(	RelDataType	type1,
		RelDataType	type2,
		boolean	stringPromotion
	)

inline

We overload this to add a few additional useful rules that Calcite does not implement by default: TIMESTAMP() of lower precision should be castable to higher precision DOUBLE should be the widest type for {FLOAT, REAL, DOUBLE}

Definition at line 240 of file HeavyDBTypeCoercion.java.

Referenced by com.mapd.calcite.parser.HeavyDBTypeCoercion.calculateScoreForCursorOperand(), com.mapd.calcite.parser.HeavyDBTypeCoercion.calculateTypeCoercionScore(), com.mapd.calcite.parser.HeavyDBTypeCoercion.coerceCursorType(), and com.mapd.calcite.parser.HeavyDBTypeCoercion.extTableFunctionTypeCoercion().

                                                                          {
     RelDataType returnType = super.getWiderTypeForTwo(type1, type2, stringPromotion);
     if (SqlTypeUtil.isTimestamp(type1) && SqlTypeUtil.isTimestamp(type2)) {
       returnType = (type1.getPrecision() > type2.getPrecision()) ? type1 : type2;
     } else if ((SqlTypeUtil.isDouble(type1) || SqlTypeUtil.isDouble(type2))
             && (SqlTypeUtil.isApproximateNumeric(type1)
                     && SqlTypeUtil.isApproximateNumeric(type2))) {
       returnType = factory.createTypeWithNullability(
               factory.createSqlType(SqlTypeName.DOUBLE), true);
     }
     return returnType;
   }

Here is the caller graph for this function:

boolean com.mapd.calcite.parser.HeavyDBTypeCoercion.needToCast	(	SqlValidatorScope	scope,
		SqlNode	node,
		RelDataType	toType
	)

inlineprotected

We overload this specifically to REMOVE a rule Calcite uses: Calcite will not cast types in the NUMERIC type family across each other. Therefore, with Calcite's default rules, we would not cast INTEGER columns to BIGINT, or FLOAT to DOUBLE.

Definition at line 403 of file HeavyDBTypeCoercion.java.

                                                                      {
     RelDataType fromType = validator.deriveType(scope, node);
     // This depends on the fact that type validate happens before coercion.
     // We do not have inferred type for some node, i.e. LOCALTIME.
     if (fromType == null) {
       return false;
     }
 
     // This prevents that we cast a JavaType to normal RelDataType.
     if (fromType instanceof RelDataTypeFactoryImpl.JavaType
             && toType.getSqlTypeName() == fromType.getSqlTypeName()) {
       return false;
     }
 
     // Do not make a cast when we don't know specific type (ANY) of the origin node.
     if (toType.getSqlTypeName() == SqlTypeName.ANY
             || fromType.getSqlTypeName() == SqlTypeName.ANY) {
       return false;
     }
 
     // No need to cast between char and varchar.
     if (SqlTypeUtil.isCharacter(toType) && SqlTypeUtil.isCharacter(fromType)) {
       return false;
     }
 
     // Implicit type coercion does not handle nullability.
     if (SqlTypeUtil.equalSansNullability(factory, fromType, toType)) {
       return false;
     }
     // Should keep sync with rules in SqlTypeCoercionRule.
     assert SqlTypeUtil.canCastFrom(toType, fromType, true);
     return true;
   }

boolean com.mapd.calcite.parser.HeavyDBTypeCoercion.shouldCoerceBinOpOperand	(	SqlNode	op,
		RelDataType	targetType,
		SqlValidatorScope	scope
	)

inlineprivate

Determines if a binary operator's operands need to be coerced explicitly. Calcite considers the output of some binary operators involving literals as a wider type. As a consequence, some operations such as FLOAT + <float_literal> are type-inferenced to DOUBLE, and will typecheck against UDTFs that accept DOUBLE columns. However, these parameters are still sent to the backend as FLOATs. This method identifies these occurrences, so that they can be casted explicitly.

Definition at line 514 of file HeavyDBTypeCoercion.java.

Referenced by com.mapd.calcite.parser.HeavyDBTypeCoercion.calculateScoreForCursorOperand(), and com.mapd.calcite.parser.HeavyDBTypeCoercion.coerceCursorType().

                                                                        {
     if (op instanceof SqlBasicCall) {
       SqlBasicCall asCall = (SqlBasicCall) op;
       if (asCall.getOperator().getKind() == SqlKind.AS) {
         SqlNode op2 = asCall.operand(0);
         if (op2 instanceof SqlBasicCall) {
           asCall = (SqlBasicCall) op2;
         } else {
           return false;
         }
       }
       if (asCall.getOperator() instanceof SqlBinaryOperator) {
         SqlNode lhs = asCall.operand(0);
         SqlNode rhs = asCall.operand(1);
         RelDataType lhsType = validator.deriveType(scope, lhs);
         RelDataType rhsType = validator.deriveType(scope, rhs);
         // if neither operand is already the wider type, and at least one is a literal,
         // depending on precedence the result might falsely typecheck as the wider type
         if (lhsType != targetType && rhsType != targetType
                 && (lhs.getKind() == SqlKind.LITERAL
                         || rhs.getKind() == SqlKind.LITERAL)) {
           return true;
         }
       }
     }
     return false;
   }

Here is the caller graph for this function:

void com.mapd.calcite.parser.HeavyDBTypeCoercion.updateValidatedType	(	List< RelDataTypeField >	typeList,
		SqlSelect	selectNode,
		int	operandIndex
	)

inlineprivate

Updates validated type for CURSOR SqlNodes that had their underlying types coerced.

Definition at line 441 of file HeavyDBTypeCoercion.java.

Referenced by com.mapd.calcite.parser.HeavyDBTypeCoercion.coerceCursorType().

                                                                                    {
     SqlNode operand = selectNode.getSelectList().get(operandIndex);
     RelDataType newType = validator.getValidatedNodeType(operand);
     if (operand instanceof SqlCall) {
       SqlCall asCall = (SqlCall) operand;
       if (asCall.getOperator().getKind() == SqlKind.AS) {
         newType = validator.getValidatedNodeType(asCall.operand(0));
       }
     }
     RelDataTypeField oldTypeField =
             validator.getValidatedNodeType(selectNode).getFieldList().get(operandIndex);
     RelDataTypeField newTypeField = new RelDataTypeFieldImpl(
             oldTypeField.getName(), oldTypeField.getIndex(), newType);
     typeList.add(newTypeField);
   }

Here is the caller graph for this function:

The documentation for this class was generated from the following file:

/home/jenkins-slave/workspace/core-os-doxygen/java/calcite/src/main/java/com/mapd/calcite/parser/HeavyDBTypeCoercion.java

Public Member Functions

Protected Member Functions

Private Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation