com.mapd.calcite.parser.ExtTableFunctionTypeChecker Class Reference

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

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

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 ()

Package Functions
	ExtTableFunctionTypeChecker (HeavyDBSqlOperatorTable opTable)

Package Attributes
final HeavyDBSqlOperatorTable	opTable

Detailed Description

Definition at line 30 of file ExtTableFunctionTypeChecker.java.

Constructor & Destructor Documentation

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

inlinepackage

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

References com.mapd.calcite.parser.ExtTableFunctionTypeChecker.doesOperandTypeMatch(), and com.mapd.calcite.parser.ExtTableFunctionTypeChecker.getOperatorOverloads().

                                                                                       {
    Set<ExtTableFunction> candidateOverloads = new HashSet<ExtTableFunction>(
            getOperatorOverloads(callBinding.getOperator()));

    // 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(callBinding.newValidationSignatureError());
      }
      return false;
    }

    // If there are candidates left, and the current bound operator
    // is not one of them, rewrite the call to use the 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 127 of file ExtTableFunctionTypeChecker.java.

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

                                                                              {
    String formalOperandName = tf.getExtendedParamNames().get(iFormalOperand);
    List<ExtensionFunction.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()) {
      ExtensionFunction.ExtArgumentType extType = formalFieldTypes.get(iFormal);
      SqlTypeName formalType = ExtensionFunction.toSqlTypeName(extType);
      SqlTypeName actualType = actualFieldList.get(iActual).getValue().getSqlTypeName();

      if (formalType == SqlTypeName.COLUMN_LIST) {
        ExtensionFunction.ExtArgumentType colListSubtype =
                ExtensionFunction.getValueType(extType);
        SqlTypeName colListType = ExtensionFunction.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 != 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 46 of file ExtTableFunctionTypeChecker.java.

References shared.contains(), com.mapd.calcite.parser.ExtTableFunctionTypeChecker.doesCursorOperandTypeMatch(), 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();

    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 tf.getArgTypes().get(iFormalOperand).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 202 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:

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

inline

Definition at line 210 of file ExtTableFunctionTypeChecker.java.

                                      {
    return Consistency.NONE;
  }

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

inline

Definition at line 198 of file ExtTableFunctionTypeChecker.java.

                                                     {
    return SqlOperandCountRanges.any();
  }

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

inline

Definition at line 184 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 37 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;
  }

Member Data Documentation

final HeavyDBSqlOperatorTable com.mapd.calcite.parser.ExtTableFunctionTypeChecker.opTable

package

Definition at line 31 of file ExtTableFunctionTypeChecker.java.

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

---

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/ExtTableFunctionTypeChecker.java