Java Pair.getValue方法代码示例

import org.apache.calcite.util.Pair; //导入方法依赖的package包/类
@Override
public PhysicalPlan getPlan(SqlHandlerConfig config, String sql, SqlNode sqlNode) throws Exception {
  try{
    final ConvertedRelNode convertedRelNode = PrelTransformer.validateAndConvert(config, sqlNode);
    final RelDataType validatedRowType = convertedRelNode.getValidatedRowType();
    final RelNode queryRelNode = convertedRelNode.getConvertedNode();

    final Rel drel = PrelTransformer.convertToDrel(config, queryRelNode, validatedRowType);

    final Pair<Prel, String> convertToPrel = PrelTransformer.convertToPrel(config, drel);
    final Prel prel = convertToPrel.getKey();
    textPlan = convertToPrel.getValue();
    final PhysicalOperator pop = PrelTransformer.convertToPop(config, prel);
    final PhysicalPlan plan = PrelTransformer.convertToPlan(config, pop);
    logger.debug("Final Physical Plan {}", textPlan);
    PrelTransformer.log(config, "Dremio Plan", plan, logger);


    return plan;
  }catch(Exception ex){
    throw SqlExceptionHelper.coerceException(logger, sql, ex, true);
  }
}
 

import org.apache.calcite.util.Pair; //导入方法依赖的package包/类
public static boolean isSimpleColumnSelection(Project project) {
  HashSet<Integer> inputRefReferenced = new HashSet<>();
  for (Pair<RexNode, String> proj : project.getNamedProjects()) {
    if (proj.getKey().getKind() != SqlKind.INPUT_REF) {
      return false;
    }
    RexInputRef inputRef = (RexInputRef) proj.getKey();
    // If the input reference is again referenced, then it is not a simple column selection (since it is not a permutation).
    if (inputRefReferenced.contains(inputRef.getIndex())) {
      return false;
    }
    final String nameOfProjectField = proj.getValue();
    final String nameOfInput = project.getInput().getRowType().getFieldNames().get(inputRef.getIndex());
    // Renaming a column is not a simple column selection
    if (nameOfProjectField == null || !nameOfProjectField.equals(nameOfInput)) {
      return false;
    }
    inputRefReferenced.add(inputRef.getIndex());
  }
  return true;
}
 

import org.apache.calcite.util.Pair; //导入方法依赖的package包/类
public static DataContext of(RelDataType rowType,
    List<Pair<RexInputRef, RexNode>> usageList) {
  final int size = rowType.getFieldList().size();
  final Object[] values = new Object[size];
  for (Pair<RexInputRef, RexNode> elem : usageList) {
    Pair<Integer, ?> value = getValue(elem.getKey(), elem.getValue());
    if (value == null) {
      LOGGER.warn("{} is not handled for {} for checking implication",
          elem.getKey(), elem.getValue());
      return null;
    }
    int index = value.getKey();
    values[index] = value.getValue();
  }
  return new VisitorDataContext(values);
}
 

import org.apache.calcite.util.Pair; //导入方法依赖的package包/类
@Override
public PhysicalPlan getPlan(SqlHandlerConfig config, String sql, SqlNode sqlNode) throws Exception {
  try{
    SqlCreateTable sqlCreateTable = SqlNodeUtil.unwrap(sqlNode, SqlCreateTable.class);

    // TODO: fix parser to disallow this
    if (sqlCreateTable.isSingleWriter() && !sqlCreateTable.getPartitionColumns().isEmpty()) {
      throw UserException.unsupportedError()
          .message("Cannot partition data and write to a single file at the same time.")
          .build(logger);
    }

    final String newTblName = sqlCreateTable.getName();

    final ConvertedRelNode convertedRelNode = PrelTransformer.validateAndConvert(config, sqlCreateTable.getQuery());
    final RelDataType validatedRowType = convertedRelNode.getValidatedRowType();
    final RelNode queryRelNode = convertedRelNode.getConvertedNode();

    final RelNode newTblRelNode =
        SqlHandlerUtil.resolveNewTableRel(false, sqlCreateTable.getFieldNames(), validatedRowType, queryRelNode);

    final AbstractSchema schemaInstance =
        SchemaUtilities.resolveToMutableSchemaInstance(config.getConverter().getDefaultSchema(), sqlCreateTable.getSchemaPath(), systemUser, MutationType.TABLE);
    final String schemaPath = schemaInstance.getFullSchemaName();

    if (SqlHandlerUtil.getTableFromSchema(schemaInstance, newTblName) != null) {
      throw UserException.validationError()
          .message("A table or view with given name [%s] already exists in schema [%s]", newTblName, schemaPath)
          .build(logger);
    }

    final long ringCount = config.getContext().getOptions().getOption(PlannerSettings.RING_COUNT);

    final RelNode newTblRelNodeWithPCol = SqlHandlerUtil.qualifyPartitionCol(newTblRelNode, sqlCreateTable.getPartitionColumns());

    PrelTransformer.log("Calcite", newTblRelNodeWithPCol, logger, null);

    final WriterOptions options = new WriterOptions(
        (int) ringCount,
        sqlCreateTable.getPartitionColumns(),
        sqlCreateTable.getSortColumns(),
        sqlCreateTable.getDistributionColumns(),
        sqlCreateTable.getPartitionDistributionStrategy(),
        sqlCreateTable.isSingleWriter());

    // Convert the query to Dremio Logical plan and insert a writer operator on top.
    Rel drel = convertToDrel(
        config,
        newTblRelNodeWithPCol,
        schemaInstance,
        newTblName,
        options,
        newTblRelNode.getRowType(),
        createStorageOptionsMap(config, sqlCreateTable.getFormatOptions()));

    final Pair<Prel, String> convertToPrel = PrelTransformer.convertToPrel(config, drel);
    final Prel prel = convertToPrel.getKey();
    textPlan = convertToPrel.getValue();
    PhysicalOperator pop = PrelTransformer.convertToPop(config, prel);
    PhysicalPlan plan = PrelTransformer.convertToPlan(config, pop);
    PrelTransformer.log(config, "Dremio Plan", plan, logger);

    return plan;

  }catch(Exception ex){
    throw SqlExceptionHelper.coerceException(logger, sql, ex, true);
  }
}
 

import org.apache.calcite.util.Pair; //导入方法依赖的package包/类
@Override
  public List<Explain> toResult(String sql, SqlNode sqlNode) throws Exception {
    try {
      final SqlExplain node = SqlNodeUtil.unwrap(sqlNode, SqlExplain.class);
      final SqlLiteral op = node.operand(2);
      final SqlExplain.Depth depth = (SqlExplain.Depth) op.getValue();

      final ResultMode mode;
      SqlExplainLevel level = SqlExplainLevel.ALL_ATTRIBUTES;

      if (node.getDetailLevel() != null) {
        level = node.getDetailLevel();
      }

      switch (depth) {
      case LOGICAL:
        mode = ResultMode.LOGICAL;
        break;
      case PHYSICAL:
        mode = ResultMode.PHYSICAL;
        break;
      default:
        throw new UnsupportedOperationException("Unknown depth " + depth);
      }

      final SqlNode innerNode = node.operand(0);

//      try(DisabledBlock block = toggle.openDisabledBlock()){
        Rel drel;
        final ConvertedRelNode convertedRelNode = PrelTransformer.validateAndConvert(config, innerNode);
        final RelDataType validatedRowType = convertedRelNode.getValidatedRowType();
        final RelNode queryRelNode = convertedRelNode.getConvertedNode();

        PrelTransformer.log("Calcite", queryRelNode, logger, null);
        drel = PrelTransformer.convertToDrel(config, queryRelNode, validatedRowType);

        if (mode == ResultMode.LOGICAL) {
          return Collections.singletonList(new Explain(RelOptUtil.toString(drel, level)));
        }

        final Pair<Prel, String> convertToPrel = PrelTransformer.convertToPrel(config, drel);
        final String text = convertToPrel.getValue();
        return Collections.singletonList(new Explain(text));
//      }
    } catch (Exception ex){
      throw SqlExceptionHelper.coerceException(logger, sql, ex, true);
    }
  }
 

import org.apache.calcite.util.Pair; //导入方法依赖的package包/类
@Override
public Pair<String, Long> getScrollAndTotalSizeThenSeekToHits() throws IOException {
  Pair<String, Long> scrollIdAndRecordCount = super.getScrollAndTotalSizeThenSeekToHits();
  recordCount = scrollIdAndRecordCount.getValue();
  return scrollIdAndRecordCount;
}