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	checkOperandTypes (SqlCallBinding callBinding, boolean throwOnFailure)

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 58 of file ExtTableFunctionTypeChecker.java.

References com.mapd.calcite.parser.HeavyDBTypeCoercion.calculateTypeCoercionScore(), shared.contains(), 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 (accounting for possible default args).
     candidateOverloads.removeIf(tf
             -> (callBinding.getOperandCount()
                        < (tf.getArgTypes().size() - tf.getNumOptionalArguments()))
                     || (callBinding.getOperandCount() > tf.getArgTypes().size()));
 
     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);
     }
 
     // remove candidate calls that have DEFAULT values for operands which are
     // mandatory
     candidateOverloads.removeIf(tf
             -> IntStream
                        .range(0,
                                candidateBindings.get(tf)
                                        .permutedCall()
                                        .getOperandList()
                                        .size())
                        .anyMatch(idx
                                -> candidateBindings.get(tf)
                                                        .permutedCall()
                                                        .operand(idx)
                                                        .getKind()
                                                == SqlKind.DEFAULT
                                        && !tf.isArgumentOptional(idx)));
 
     // Compute a typechecking score for each candidate, taking into account type promotion
     HeavyDBTypeCoercion tc =
             (HeavyDBTypeCoercion) callBinding.getValidator().getTypeCoercion();
     Map<ExtTableFunction, Integer> scoredCandidates =
             new HashMap<ExtTableFunction, Integer>();
     candidateOverloads.stream().forEach(udtf
             -> scoredCandidates.put(udtf,
                     tc.calculateTypeCoercionScore(candidateBindings.get(udtf), udtf)));
 
     // Use the candidate with minimum cost
     ExtTableFunction minCandidate;
     try {
       minCandidate = Collections
                              .min(scoredCandidates.entrySet()
                                              .stream()
                                              .filter(entry -> entry.getValue() >= 0)
                                              .collect(Collectors.toSet()),
                                      Map.Entry.comparingByValue())
                              .getKey();
     } catch (NoSuchElementException e) {
       // If there are no candidates left, the call is invalid.
       if (throwOnFailure) {
         throw(newExtTableFunctionSignatureError(callBinding));
       }
       return false;
     }
 
     if (scoredCandidates.get(minCandidate) > 0) {
       tc.extTableFunctionTypeCoercion(candidateBindings.get(minCandidate), minCandidate);
     }
 
     // If there are candidates left, and the current bound operator
     // is not one of them, rewrite the call to use a better binding.
     ((SqlBasicCall) callBinding.getCall()).setOperator(minCandidate);
 
     return true;
   }

Here is the call graph for this function:

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

inline

Definition at line 172 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 203 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 180 of file ExtTableFunctionTypeChecker.java.

                                       {
     return Consistency.NONE;
   }

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

inline

Definition at line 168 of file ExtTableFunctionTypeChecker.java.

                                                      {
     return SqlOperandCountRanges.any();
   }

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

inline

Definition at line 154 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 54 of file ExtTableFunctionTypeChecker.java.

                                           {
     return false;
   }

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

inline

Definition at line 184 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 191 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()));
   }