Java SqlSumEmptyIsZeroAggFunction类代码示例

import org.apache.calcite.sql.fun.SqlSumEmptyIsZeroAggFunction; //导入依赖的package包/类
/**
 * Converts a call to an aggregate function to an expression.
 */
final SqlNode toSql(AggregateCall aggCall) {
    SqlOperator op = aggCall.getAggregation();
    if (op instanceof SqlSumEmptyIsZeroAggFunction) {
        op = SqlStdOperatorTable.SUM;
    }
    final List<SqlNode> operands = Expressions.list();
    for (int arg : aggCall.getArgList()) {
        operands.add(field(arg));
    }
    return op.createCall(
            aggCall.isDistinct() ? SqlSelectKeyword.DISTINCT.symbol(POS) : null,
            POS, operands.toArray(new SqlNode[operands.size()]));
}
 

import org.apache.calcite.sql.fun.SqlSumEmptyIsZeroAggFunction; //导入依赖的package包/类
/**
 * Converts a call to an aggregate function to an expression.
 */
public SqlNode toSql(AggregateCall aggCall) {
  SqlOperator op = (SqlAggFunction) aggCall.getAggregation();
  if (op instanceof SqlSumEmptyIsZeroAggFunction) {
    op = SqlStdOperatorTable.SUM;
  }
  final List<SqlNode> operands = Expressions.list();
  for (int arg : aggCall.getArgList()) {
    operands.add(field(arg));
  }
  return op.createCall(
      aggCall.isDistinct() ? SqlSelectKeyword.DISTINCT.symbol(POS) : null,
      POS, operands.toArray(new SqlNode[operands.size()]));
}
 

import org.apache.calcite.sql.fun.SqlSumEmptyIsZeroAggFunction; //导入依赖的package包/类
/** Converts a call to an aggregate function to an expression. */
public SqlNode toSql(AggregateCall aggCall) {
  SqlOperator op = aggCall.getAggregation();
  if (op instanceof SqlSumEmptyIsZeroAggFunction) {
    op = SqlStdOperatorTable.SUM;
  }
  final List<SqlNode> operands = Expressions.list();
  for (int arg : aggCall.getArgList()) {
    operands.add(field(arg));
  }
  return op.createCall(
      aggCall.isDistinct() ? SqlSelectKeyword.DISTINCT.symbol(POS) : null,
      POS, operands.toArray(new SqlNode[operands.size()]));
}
 

import org.apache.calcite.sql.fun.SqlSumEmptyIsZeroAggFunction; //导入依赖的package包/类
private RexNode reduceSum(
    Aggregate oldAggRel,
    AggregateCall oldCall,
    List<AggregateCall> newCalls,
    Map<AggregateCall, RexNode> aggCallMapping) {
  final int nGroups = oldAggRel.getGroupCount();
  RelDataTypeFactory typeFactory =
      oldAggRel.getCluster().getTypeFactory();
  RexBuilder rexBuilder = oldAggRel.getCluster().getRexBuilder();
  int arg = oldCall.getArgList().get(0);
  RelDataType argType =
      getFieldType(
          oldAggRel.getInput(),
          arg);
  RelDataType sumType =
      typeFactory.createTypeWithNullability(
          argType, argType.isNullable());
  SqlAggFunction sumZeroAgg = new SqlSumEmptyIsZeroAggFunction();
  AggregateCall sumZeroCall =
      new AggregateCall(
          sumZeroAgg,
          oldCall.isDistinct(),
          oldCall.getArgList(),
          sumType,
          null);
  final SqlCountAggFunction countAgg = (SqlCountAggFunction) SqlStdOperatorTable.COUNT;
  final RelDataType countType = countAgg.getReturnType(typeFactory);
  AggregateCall countCall =
      new AggregateCall(
          countAgg,
          oldCall.isDistinct(),
          oldCall.getArgList(),
          countType,
          null);

  // NOTE:  these references are with respect to the output
  // of newAggRel
  RexNode sumZeroRef =
      rexBuilder.addAggCall(
          sumZeroCall,
          nGroups,
          oldAggRel.indicator,
          newCalls,
          aggCallMapping,
          ImmutableList.of(argType));
  if (!oldCall.getType().isNullable()) {
    // If SUM(x) is not nullable, the validator must have determined that
    // nulls are impossible (because the group is never empty and x is never
    // null). Therefore we translate to SUM0(x).
    return sumZeroRef;
  }
  RexNode countRef =
      rexBuilder.addAggCall(
          countCall,
          nGroups,
          oldAggRel.indicator,
          newCalls,
          aggCallMapping,
          ImmutableList.of(argType));
  return rexBuilder.makeCall(SqlStdOperatorTable.CASE,
      rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
          countRef, rexBuilder.makeExactLiteral(BigDecimal.ZERO)),
          rexBuilder.constantNull(),
          sumZeroRef);
}
 

import org.apache.calcite.sql.fun.SqlSumEmptyIsZeroAggFunction; //导入依赖的package包/类
@Override
public void onMatch(RelOptRuleCall call) {
  final DrillAggregateRel oldAggRel = (DrillAggregateRel) call.rels[0];

  final Map<AggregateCall, RexNode> aggCallMapping = Maps.newHashMap();
  final List<AggregateCall> newAggregateCalls = Lists.newArrayList();
  for (AggregateCall oldAggregateCall : oldAggRel.getAggCallList()) {
    if(isConversionToSumZeroNeeded(oldAggregateCall.getAggregation(), oldAggregateCall.getType())) {
      final RelDataType argType = oldAggregateCall.getType();
      final RelDataType sumType = oldAggRel.getCluster().getTypeFactory()
          .createTypeWithNullability(argType, argType.isNullable());
      final SqlAggFunction sumZeroAgg = new DrillCalciteSqlAggFunctionWrapper(
          new SqlSumEmptyIsZeroAggFunction(), sumType);
      AggregateCall sumZeroCall =
          AggregateCall.create(
              sumZeroAgg,
              oldAggregateCall.isDistinct(),
              oldAggregateCall.getArgList(),
              -1,
              sumType,
              oldAggregateCall.getName());
      oldAggRel.getCluster().getRexBuilder()
          .addAggCall(sumZeroCall,
              oldAggRel.getGroupCount(),
              oldAggRel.indicator,
              newAggregateCalls,
              aggCallMapping,
              ImmutableList.of(argType));
    } else {
      newAggregateCalls.add(oldAggregateCall);
    }
  }

  try {
    call.transformTo(new DrillAggregateRel(
        oldAggRel.getCluster(),
        oldAggRel.getTraitSet(),
        oldAggRel.getInput(),
        oldAggRel.indicator,
        oldAggRel.getGroupSet(),
        oldAggRel.getGroupSets(),
        newAggregateCalls));
  } catch (InvalidRelException e) {
    tracer.warning(e.toString());
  }
}