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

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

Classes
interface	ExtTableFunctionErrors

Public Member Functions
boolean	isOptional (int argIndex)

boolean	doesOperandTypeMatch (ExtTableFunction tf, SqlCallBinding callBinding, SqlNode node, int iFormalOperand)

boolean	checkOperandTypes (SqlCallBinding callBinding, boolean throwOnFailure)

boolean	doesCursorOperandTypeMatch (ExtTableFunction tf, int iFormalOperand, RelDataType actualOperand)

List< ExtTableFunction >	getOperatorOverloads (SqlOperator op)

SqlOperandCountRange	getOperandCountRange ()

String	getAllowedSignatures (SqlOperator op, String opName)

Consistency	getConsistency ()

CalciteException	newExtTableFunctionNameError (SqlCallBinding callBinding, SqlNode operand, String operandName)

CalciteException	newExtTableFunctionSignatureError (SqlCallBinding callBinding)

String	getCallSignature (SqlCallBinding callBinding, SqlValidator validator, SqlValidatorScope scope)

Static Public Attributes
static final ExtTableFunctionErrors	UDTF_ERRORS

Package Functions
	ExtTableFunctionTypeChecker (HeavyDBSqlOperatorTable opTable)

Package Attributes
final HeavyDBSqlOperatorTable	opTable

Detailed Description

Definition at line 42 of file ExtTableFunctionTypeChecker.java.

Constructor & Destructor Documentation

com.mapd.calcite.parser.ExtTableFunctionTypeChecker.ExtTableFunctionTypeChecker ( HeavyDBSqlOperatorTable opTable )

inlinepackage

Definition at line 45 of file ExtTableFunctionTypeChecker.java.

References com.mapd.calcite.parser.ExtTableFunctionTypeChecker.opTable.

                                                                {
     this.opTable = opTable;
   }

Member Function Documentation

boolean com.mapd.calcite.parser.ExtTableFunctionTypeChecker.checkOperandTypes	(	SqlCallBinding	callBinding,
		boolean	throwOnFailure
	)

inline

Definition at line 88 of file ExtTableFunctionTypeChecker.java.

References shared.contains(), com.mapd.calcite.parser.ExtTableFunctionTypeChecker.doesOperandTypeMatch(), com.mapd.calcite.parser.ExtTableFunctionTypeChecker.getOperatorOverloads(), com.mapd.calcite.parser.ExtTableFunctionTypeChecker.newExtTableFunctionNameError(), and com.mapd.calcite.parser.ExtTableFunctionTypeChecker.newExtTableFunctionSignatureError().

                                                                                        {
     Set<ExtTableFunction> candidateOverloads = new HashSet<ExtTableFunction>(
             getOperatorOverloads(callBinding.getOperator()));
 
     for (SqlNode operand : callBinding.getCall().getOperandList()) {
       if (operand != null && operand.getKind() == SqlKind.ARGUMENT_ASSIGNMENT) {
         final SqlCall assignmentCall = (SqlCall) operand;
         final SqlIdentifier id = assignmentCall.operand(1);
         final String paramName = id.getSimple();
         if (!candidateOverloads.stream().anyMatch(
                     tf -> tf.getParamNames().contains(paramName))) {
           throw newExtTableFunctionNameError(callBinding, operand, id.getSimple());
         }
       }
     }
 
     // Remove all candidates whose number of formal args doesn't match the
     // call's number of real args.
     candidateOverloads.removeIf(
             tf -> tf.getArgTypes().size() != callBinding.getOperandCount());
 
     SqlNode[] operandArray = new SqlNode[callBinding.getCall().getOperandList().size()];
     for (Ord<SqlNode> arg : Ord.zip(callBinding.getCall().getOperandList())) {
       operandArray[arg.i] = arg.e;
     }
 
     // Construct a candidate call binding for each overload. We need to do this because
     // type inference of operands may differ depending on which operator is used. Thus,
     // typechecking needs to be done on a candidate call-by-call basis.
     HashMap<ExtTableFunction, SqlCallBinding> candidateBindings =
             new HashMap<>(candidateOverloads.size());
     for (ExtTableFunction tf : candidateOverloads) {
       SqlBasicCall newCall = new SqlBasicCall(
               tf, operandArray, callBinding.getCall().getParserPosition());
       SqlCallBinding candidateBinding = new SqlCallBinding(
               callBinding.getValidator(), callBinding.getScope(), newCall);
       candidateBindings.put(tf, candidateBinding);
     }
 
     for (int i = 0; i < operandArray.length; i++) {
       int idx = i;
       candidateOverloads.removeIf(tf
               -> !doesOperandTypeMatch(
                       tf, candidateBindings.get(tf), operandArray[idx], idx));
     }
 
     // If there are no candidates left, the call is invalid.
     if (candidateOverloads.size() == 0) {
       if (throwOnFailure) {
         throw(newExtTableFunctionSignatureError(callBinding));
       }
       return false;
     }
 
     // If there are candidates left, and the current bound operator
     // is not one of them, rewrite the call to use a better binding.
     if (!candidateOverloads.isEmpty()
             && !candidateOverloads.contains(callBinding.getOperator())) {
       ExtTableFunction optimal = candidateOverloads.iterator().next();
       ((SqlBasicCall) callBinding.getCall()).setOperator(optimal);
     }
 
     return true;
   }

Here is the call graph for this function:

boolean com.mapd.calcite.parser.ExtTableFunctionTypeChecker.doesCursorOperandTypeMatch	(	ExtTableFunction	tf,
		int	iFormalOperand,
		RelDataType	actualOperand
	)

inline

Definition at line 153 of file ExtTableFunctionTypeChecker.java.

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

                                                                               {
     String formalOperandName = tf.getExtendedParamNames().get(iFormalOperand);
     List<ExtArgumentType> formalFieldTypes =
             tf.getCursorFieldTypes().get(formalOperandName);
     List<RelDataTypeField> actualFieldList = actualOperand.getFieldList();
 
     // runtime functions may not have CURSOR field type information, so we default
     // to old behavior of assuming they typecheck
     if (formalFieldTypes.size() == 0) {
       System.out.println(
               "Warning: UDTF has no CURSOR field subtype data. Proceeding assuming CURSOR typechecks.");
       return true;
     }
 
     int iFormal = 0;
     int iActual = 0;
     while (iActual < actualFieldList.size() && iFormal < formalFieldTypes.size()) {
       ExtArgumentType extType = formalFieldTypes.get(iFormal);
       SqlTypeName formalType = toSqlTypeName(extType);
       SqlTypeName actualType = actualFieldList.get(iActual).getValue().getSqlTypeName();
 
       if (formalType == SqlTypeName.COLUMN_LIST) {
         ExtArgumentType colListSubtype = getValueType(extType);
         SqlTypeName colListType = toSqlTypeName(colListSubtype);
 
         if (actualType != colListType) {
           return false;
         }
 
         int colListSize = 0;
         int numFormalArgumentsLeft = (formalFieldTypes.size() - 1) - iFormal;
         while (iActual + colListSize
                 < (actualFieldList.size() - numFormalArgumentsLeft)) {
           actualType =
                   actualFieldList.get(iActual + colListSize).getValue().getSqlTypeName();
           if (actualType != colListType) {
             break;
           }
           colListSize++;
         }
         iActual += colListSize - 1;
       } else if (formalType == SqlTypeName.ARRAY) {
         if (actualType != SqlTypeName.ARRAY) {
           return false;
         }
 
         SqlTypeName formalArraySubtype =
                 toSqlTypeName(getValueType(getValueType(extType)));
         SqlTypeName actualArraySubtype = actualFieldList.get(iActual)
                                                  .getValue()
                                                  .getComponentType()
                                                  .getSqlTypeName();
         if (formalArraySubtype != actualArraySubtype) {
           return false;
         }
       } else if (formalType != actualType) {
         return false;
       }
       iFormal++;
       iActual++;
     }
 
     if (iActual < actualFieldList.size()) {
       return false;
     }
 
     return true;
   }

Here is the caller graph for this function:

boolean com.mapd.calcite.parser.ExtTableFunctionTypeChecker.doesOperandTypeMatch	(	ExtTableFunction	tf,
		SqlCallBinding	callBinding,
		SqlNode	node,
		int	iFormalOperand
	)

inline

Definition at line 58 of file ExtTableFunctionTypeChecker.java.

References shared.contains(), com.mapd.calcite.parser.ExtTableFunctionTypeChecker.doesCursorOperandTypeMatch(), com.mapd.calcite.parser.HeavyDBSqlOperatorTable.ExtTableFunction.getArgTypes(), run_benchmark_import.type, and typeName().

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

                               {
     SqlCall permutedCall = callBinding.permutedCall();
     SqlNode permutedOperand = permutedCall.operand(iFormalOperand);
     RelDataType type;
 
     // For candidate calls to incompatible operators, type inference of operands may fail.
     // In that case, we just catch the exception and invalidade the candidate.
     try {
       type = callBinding.getValidator().deriveType(
               callBinding.getScope(), permutedOperand);
     } catch (Exception e) {
       return false;
     }
     SqlTypeName typeName = type.getSqlTypeName();
     SqlTypeFamily formalTypeFamily =
             toSqlTypeName(tf.getArgTypes().get(iFormalOperand)).getFamily();
 
     if (typeName == SqlTypeName.CURSOR) {
       SqlCall cursorCall = (SqlCall) permutedOperand;
       RelDataType cursorType = callBinding.getValidator().deriveType(
               callBinding.getScope(), cursorCall.operand(0));
       return doesCursorOperandTypeMatch(tf, iFormalOperand, cursorType);
     } else {
       return formalTypeFamily.getTypeNames().contains(typeName);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

String com.mapd.calcite.parser.ExtTableFunctionTypeChecker.getAllowedSignatures	(	SqlOperator	op,
		String	opName
	)

inline

Definition at line 241 of file ExtTableFunctionTypeChecker.java.

References com.mapd.calcite.parser.ExtTableFunctionTypeChecker.getOperatorOverloads().

                                                                     {
     List<ExtTableFunction> overloads = getOperatorOverloads(op);
     return String.join(System.lineSeparator() + "\t",
             overloads.stream()
                     .map(tf -> tf.getExtendedSignature())
                     .collect(Collectors.toList()));
   }

Here is the call graph for this function:

String com.mapd.calcite.parser.ExtTableFunctionTypeChecker.getCallSignature	(	SqlCallBinding	callBinding,
		SqlValidator	validator,
		SqlValidatorScope	scope
	)

inline

Definition at line 272 of file ExtTableFunctionTypeChecker.java.

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

                                                                                        {
     List<String> signatureList = new ArrayList<>();
     for (final SqlNode operand : callBinding.permutedCall().getOperandList()) {
       final RelDataType argType = validator.deriveType(scope, operand);
       if (null == argType) {
         continue;
       } else if (argType.getSqlTypeName() == SqlTypeName.CURSOR) {
         SqlCall cursorCall = (SqlCall) operand;
         RelDataType cursorType = callBinding.getValidator().deriveType(
                 callBinding.getScope(), cursorCall.operand(0));
         StringBuilder cursorTypeName = new StringBuilder();
         cursorTypeName.append("CURSOR[");
         for (int j = 0; j < cursorType.getFieldList().size(); j++) {
           if (j > 0) {
             cursorTypeName.append(",");
           }
           cursorTypeName.append(
                   cursorType.getFieldList().get(j).getType().getSqlTypeName());
         }
         cursorTypeName.append("]");
         signatureList.add(cursorTypeName.toString());
       } else {
         signatureList.add(argType.toString());
       }
     }
     return SqlUtil.getOperatorSignature(callBinding.getOperator(), signatureList);
   }

Here is the caller graph for this function:

Consistency com.mapd.calcite.parser.ExtTableFunctionTypeChecker.getConsistency ( )

inline

Definition at line 249 of file ExtTableFunctionTypeChecker.java.

                                       {
     return Consistency.NONE;
   }

SqlOperandCountRange com.mapd.calcite.parser.ExtTableFunctionTypeChecker.getOperandCountRange ( )

inline

Definition at line 237 of file ExtTableFunctionTypeChecker.java.

                                                      {
     return SqlOperandCountRanges.any();
   }

List<ExtTableFunction> com.mapd.calcite.parser.ExtTableFunctionTypeChecker.getOperatorOverloads ( SqlOperator op )

inline

Definition at line 223 of file ExtTableFunctionTypeChecker.java.

Referenced by com.mapd.calcite.parser.ExtTableFunctionTypeChecker.checkOperandTypes(), and com.mapd.calcite.parser.ExtTableFunctionTypeChecker.getAllowedSignatures().

                                                                      {
     List<SqlOperator> overloads = new ArrayList<>();
     opTable.lookupOperatorOverloads(op.getNameAsId(),
             SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION,
             SqlSyntax.FUNCTION,
             overloads,
             SqlNameMatchers.liberal());
 
     return overloads.stream()
             .filter(p -> p instanceof ExtTableFunction)
             .map(p -> (ExtTableFunction) p)
             .collect(Collectors.toList());
   }

Here is the caller graph for this function:

boolean com.mapd.calcite.parser.ExtTableFunctionTypeChecker.isOptional ( int argIndex )

inline

Definition at line 49 of file ExtTableFunctionTypeChecker.java.

                                           {
     // We need to mark all arguments as optional, otherwise Calcite may invalidate some
     // valid calls during the validation process. This is because if it previously bound
     // the call to a UDTF operator that receives more arguments, it fills up the missing
     // arguments with DEFAULTs. DEFAULT arguments however will not get to the typechecking
     // stage if they are not optional for that oeprator.
     return true;
   }

CalciteException com.mapd.calcite.parser.ExtTableFunctionTypeChecker.newExtTableFunctionNameError	(	SqlCallBinding	callBinding,
		SqlNode	operand,
		String	operandName
	)

inline

Definition at line 253 of file ExtTableFunctionTypeChecker.java.

References com.mapd.calcite.parser.ExtTableFunctionTypeChecker.ExtTableFunctionErrors.paramNameMismatch(), and com.mapd.calcite.parser.ExtTableFunctionTypeChecker.UDTF_ERRORS.

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

                                                                            {
     return callBinding.getValidator().newValidationError(operand,
             UDTF_ERRORS.paramNameMismatch(
                     callBinding.getOperator().getName(), operandName));
   }

Here is the call graph for this function:

Here is the caller graph for this function:

CalciteException com.mapd.calcite.parser.ExtTableFunctionTypeChecker.newExtTableFunctionSignatureError ( SqlCallBinding callBinding )

inline

Definition at line 260 of file ExtTableFunctionTypeChecker.java.

References com.mapd.calcite.parser.ExtTableFunctionTypeChecker.getCallSignature().

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

                                                                                         {
     return callBinding.getValidator().newValidationError(callBinding.permutedCall(),
             UDTF_ERRORS.typeMismatch(callBinding.getOperator().getName(),
                     getCallSignature(callBinding,
                             callBinding.getValidator(),
                             callBinding.getScope()),
                     System.getProperty("line.separator") + "\t"
                             + callBinding.getOperator().getAllowedSignatures()));
   }