Java RexNode.accept方法代码示例

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
@Override
public Boolean visitCall(RexCall call) {
  if (call.getOperator() == SqlStdOperatorTable.ITEM) {
    final RexNode op0 = call.getOperands().get(0);
    final RexNode op1 = call.getOperands().get(1);

    if (op0 instanceof RexInputRef &&
        op1 instanceof RexLiteral && ((RexLiteral) op1).getTypeName() == SqlTypeName.CHAR) {
      return true;
    } else if (op0 instanceof RexCall &&
        op1 instanceof RexLiteral && ((RexLiteral) op1).getTypeName() == SqlTypeName.CHAR) {
      return op0.accept(this);
    }
  }

  return false;
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
@Test
public void halfTree(){
  final RexNode node =
      builder.makeCall(SqlStdOperatorTable.AND,
      builder.makeCall(SqlStdOperatorTable.EQUALS,
          builder.makeInputRef(factory.createSqlType(SqlTypeName.BIGINT), 0),
          builder.makeBigintLiteral(BigDecimal.ONE)
          ),
      builder.makeApproxLiteral(BigDecimal.ONE)
      );

  FindSimpleFilters finder = new FindSimpleFilters(builder);
  StateHolder holder = node.accept(finder);
  ImmutableList<RexCall> conditions = holder.getConditions();

  assertEquals(1, conditions.size());
  assertEquals(SqlKind.EQUALS, conditions.get(0).getKind());
  assertEquals(SqlKind.LITERAL, holder.getNode().getKind());
  assertTrue(holder.hasRemainingExpression());
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
@Test
public void doubleAnd(){
  final RexNode node =
      builder.makeCall(SqlStdOperatorTable.AND,
      builder.makeCall(SqlStdOperatorTable.EQUALS,
          builder.makeInputRef(factory.createSqlType(SqlTypeName.BIGINT), 0),
          builder.makeBigintLiteral(BigDecimal.ONE)
          ),
      builder.makeCall(SqlStdOperatorTable.EQUALS,
          builder.makeInputRef(factory.createSqlType(SqlTypeName.BIGINT), 0),
          builder.makeBigintLiteral(BigDecimal.ONE)
          )
      );

  FindSimpleFilters finder = new FindSimpleFilters(builder);
  StateHolder holder = node.accept(finder);
  ImmutableList<RexCall> conditions = holder.getConditions();

  assertEquals(2, conditions.size());
  assertEquals(SqlKind.EQUALS, conditions.get(0).getKind());
  assertEquals(SqlKind.EQUALS, conditions.get(1).getKind());
  assertFalse(holder.hasRemainingExpression());
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
@Override
public RelNode visit(LogicalJoin join) {
  RexNode node = join.getCondition();
  Set<List<String>> leftTables = getOriginTables(join.getLeft());
  Set<List<String>> rightTables = getOriginTables(join.getRight());
  InputCollector collector = new InputCollector(join);
  node.accept(collector);
  definitions.add(new JoinDefinition(join.getJoinType(), leftTables, rightTables, node, ImmutableMap.copyOf(collector.origins)));
  return super.visit(join);
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
private SchemaField visitCandidate(RexNode node){
  // build a qualified path.
  SchemaPath path = node.accept(new PathVisitor(scan.getRowType(), IndexMode.ALLOW));
  Preconditions.checkArgument(path != null, "Found an incomplete item path %s.", node);

  FieldAnnotation annotation = scan.getAnnotation(path);
  ElasticSpecialType specialType = scan.getSpecialTypeRecursive(path);
  Preconditions.checkArgument(!disallowedSpecialTypes.contains(specialType), "Unable to pushdown query, %s is of type %s.", path.getAsUnescapedPath(), specialType);
  TypedFieldId fieldId = scan.getBatchSchema().getFieldId(path);
  Preconditions.checkArgument(fieldId != null, "Unable to resolve item path %s.", node);
  CompleteType type = fieldId.getFinalType();

  return new SchemaField(fieldId.getFieldIds()[0], path, type, annotation, scan.getCluster().getTypeFactory(), specialType, isV5, isPainless);
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
public static ProjectPushInfo getColumns(RelDataType rowType, List<RexNode> projects) {
  final List<String> fieldNames = rowType.getFieldNames();
  if (fieldNames.isEmpty()) {
    return null;
  }

  RefFieldsVisitor v = new RefFieldsVisitor(rowType);
  for (RexNode exp : projects) {
    PathSegment segment = exp.accept(v);
    v.addColumn(segment);
  }

  return v.getInfo();

}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
@Override
public Expression visitCall(RexCall call) {

  SqlSyntax syntax = call.getOperator().getSyntax();
  if (!supportedRexCall(call)) {
    throw new PredicateAnalyzerException(format("Unsupported call: [%s]", call));
  }

  switch (syntax) {
    case BINARY:
      return binary(call);
    case POSTFIX:
      return postfix(call);
    case SPECIAL:
      switch (call.getKind()) {
        case CAST:
          return cast(call);
        case LIKE:
          SqlLikeOperator likeOperator = (SqlLikeOperator) call.getOperator();
          if (!likeOperator.isNegated()) {
            return binary(call);
          }
          throw new PredicateAnalyzerException(format("Unsupported call: [%s]", call));
        default:
          throw new PredicateAnalyzerException(format("Unsupported call: [%s]", call));
      }
    case FUNCTION:
      if (call.getOperator().getName().equalsIgnoreCase("CONTAINS")) {
        List<Expression> operands = Lists.newArrayList();
        for (RexNode node : call.getOperands()) {
          final Expression nodeExpr = node.accept(this);
          operands.add(nodeExpr);
        }
        String query = convertQueryString(operands.subList(0, operands.size() - 1), operands.get(operands.size() - 1));
        return QueryExpression.create(new NamedFieldExpression(null)).queryString(query);
      }
    default:
      throw new PredicateAnalyzerException(format("Unsupported syntax [%s] for call: [%s]", syntax, call));
  }
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
@Override
public Void visitCall(RexCall call) {
  if (call.getOperator() instanceof SqlFlattenOperator) {
    flattens.add(((SqlFlattenOperator)call.getOperator()).getIndex());
  }

  for (RexNode op : call.getOperands()) {
    op.accept(this);
  }

  return null;
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
@Override
public Boolean visitCall(RexCall paramRexCall) {
  if(paramRexCall.getOperator() instanceof DrillSqlOperator){
    return false;
  }else{
    for (RexNode operand : paramRexCall.operands) {
      if (!operand.accept(this)) {
        return false;
      }
    }
  }
  return true;
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
@Test
public void castANY(){
final RexNode node =
    builder.makeCast(
        factory.createSqlType(SqlTypeName.ANY),
        builder.makeBigintLiteral(BigDecimal.ONE)
    );

  FindSimpleFilters finder = new FindSimpleFilters(builder);
  StateHolder holder = node.accept(finder);
  ImmutableList<RexCall> conditions = holder.getConditions();

  assertEquals(0, conditions.size());
  assertEquals(builder.makeBigintLiteral(BigDecimal.ONE), holder.getNode());
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
@Override
public FunctionRender render(FunctionRenderer renderer, RexCall call) {
  List<Iterable<NullReference>> refs = new ArrayList<>();

  List<String> operands = Lists.newArrayListWithCapacity(call.getOperands().size());
  for (RexNode childCall : call.getOperands()) {
    FunctionRender r = childCall.accept(renderer.getVisitor());
    operands.add(r.getScript());
    refs.add(r.getNulls());
  }

  return new FunctionRender("( " + Joiner.on(" " + elasticName + " ").join(operands) + " )", Iterables.concat(refs));
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
@Override
public Boolean visitCall(RexCall call) {
  if (call.getOperator().getName().equalsIgnoreCase("flatten")) {
    return true;
  }

  for (RexNode op : call.getOperands()) {
    Boolean opResult = op.accept(this);
    if (opResult != null && opResult.booleanValue()) {
      return true;
    }
  }
  return false;
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
public static boolean hasFlatten(Project project){
  for(RexNode n : project.getChildExps()){
    if(n.accept(new FlattenFinder())){
      return true;
    }
  }
  return false;
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
public static RexNode convert(RexNode node, ElasticIntermediateScanPrel scan, Set<ElasticSpecialType> disallowedSpecialTypes){
  return node.accept(new SchemaingShuttle(scan, disallowedSpecialTypes));
}
 

import org.apache.calcite.rex.RexNode; //导入方法依赖的package包/类
public static boolean hasContainsCheckOrigin(RelNode node, RexNode rex, int index) {
  return rex.accept(new ContainsRexVisitor(true, node.getCluster().getMetadataQuery(), node, index));
}