Java LogicalFilter.getCondition方法代码示例

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
public void onMatch(RelOptRuleCall call) {
  LogicalFilter filter = call.rel(0);
  MultiJoin multiJoin = call.rel(1);

  MultiJoin newMultiJoin =
      new MultiJoin(
          multiJoin.getCluster(),
          multiJoin.getInputs(),
          multiJoin.getJoinFilter(),
          multiJoin.getRowType(),
          multiJoin.isFullOuterJoin(),
          multiJoin.getOuterJoinConditions(),
          multiJoin.getJoinTypes(),
          multiJoin.getProjFields(),
          multiJoin.getJoinFieldRefCountsMap(),
          filter.getCondition());

  call.transformTo(newMultiJoin);
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
public RelNode convert(RelNode rel) {
    final LogicalFilter filter = (LogicalFilter) rel;

    return new JdbcFilter(
            rel.getCluster(),
            rel.getTraitSet().replace(getOut()),
            convert(filter.getInput(),
                    filter.getInput().getTraitSet().replace(getOut())),
            filter.getCondition());
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
public RelNode convert(RelNode rel) {
    final LogicalFilter filter = (LogicalFilter) rel;
    final RelTraitSet traitSet = filter.getTraitSet().replace(out);
    return new GremlinFilter(
            rel.getCluster(),
            traitSet,
            convert(filter.getInput(), out),
            filter.getCondition());
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
@Override
public void onMatch(RelOptRuleCall call) {
    LogicalFilter filter = call.rel(0);

    RelTraitSet origTraitSet = filter.getTraitSet();
    RelTraitSet traitSet = origTraitSet.replace(OLAPRel.CONVENTION).simplify();

    OLAPFilterRel olapFilter = new OLAPFilterRel(filter.getCluster(), traitSet, convert(filter.getInput(), traitSet), filter.getCondition());
    call.transformTo(olapFilter);
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
@Override public boolean matches(RelOptRuleCall call) {
  // Get the condition from the filter operation
  LogicalFilter filter = call.rel(0);
  RexNode condition = filter.getCondition();

  // Get field names from the scan operation
  CassandraTableScan scan = call.rel(1);
  Pair<List<String>, List<String>> keyFields = scan.cassandraTable.getKeyFields();
  Set<String> partitionKeys = new HashSet<String>(keyFields.left);
  List<String> fieldNames = CassandraRules.cassandraFieldNames(filter.getInput().getRowType());

  List<RexNode> disjunctions = RelOptUtil.disjunctions(condition);
  if (disjunctions.size() != 1) {
    return false;
  } else {
    // Check that all conjunctions are primary key equalities
    condition = disjunctions.get(0);
    for (RexNode predicate : RelOptUtil.conjunctions(condition)) {
      if (!isEqualityOnKey(predicate, fieldNames, partitionKeys, keyFields.right)) {
        return false;
      }
    }
  }

  // Either all of the partition keys must be specified or none
  return partitionKeys.size() == keyFields.left.size() || partitionKeys.size() == 0;
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
public RelNode convert(LogicalFilter filter, CassandraTableScan scan) {
  final RelTraitSet traitSet = filter.getTraitSet().replace(CassandraRel.CONVENTION);
  final Pair<List<String>, List<String>> keyFields = scan.cassandraTable.getKeyFields();
  return new CassandraFilter(
      filter.getCluster(),
      traitSet,
      convert(filter.getInput(), CassandraRel.CONVENTION),
      filter.getCondition(),
      keyFields.left,
      keyFields.right,
      scan.cassandraTable.getClusteringOrder());
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
public RelNode convert(RelNode rel) {
  final LogicalFilter filter = (LogicalFilter) rel;
  final RelTraitSet traitSet = filter.getTraitSet().replace(out);
  return new MongoFilter(
      rel.getCluster(),
      traitSet,
      convert(filter.getInput(), out),
      filter.getCondition());
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
public void onMatch(RelOptRuleCall call) {
  LogicalFilter oldFilter = call.rel(0);
  RexNode oldFilterCond = oldFilter.getCondition();

  if (RexUtil.findOperatorCall(
      SqlStdOperatorTable.IS_NOT_DISTINCT_FROM,
      oldFilterCond)
      == null) {
    // no longer contains isNotDistinctFromOperator
    return;
  }

  // Now replace all the "a isNotDistinctFrom b"
  // with the RexNode given by RelOptUtil.isDistinctFrom() method

  RemoveIsNotDistinctFromRexShuttle rewriteShuttle =
      new RemoveIsNotDistinctFromRexShuttle(
          oldFilter.getCluster().getRexBuilder());

  final RelFactories.FilterFactory factory =
      RelFactories.DEFAULT_FILTER_FACTORY;
  RelNode newFilterRel =
      factory.createFilter(oldFilter.getInput(),
          oldFilterCond.accept(rewriteShuttle));

  call.transformTo(newFilterRel);
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
public RelNode convert(RelNode rel) {
  final LogicalFilter filter = (LogicalFilter) rel;

  return new JdbcFilter(
      rel.getCluster(),
      rel.getTraitSet().replace(out),
      convert(filter.getInput(),
          filter.getInput().getTraitSet().replace(out)),
      filter.getCondition());
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
@Override public RelNode convert(RelNode relNode) {
  final LogicalFilter filter = (LogicalFilter) relNode;
  final RelTraitSet traitSet = filter.getTraitSet().replace(out);
  return new ElasticsearchFilter(relNode.getCluster(), traitSet,
    convert(filter.getInput(), out),
    filter.getCondition());
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
public RelNode convert(RelNode rel) {
  final LogicalFilter filter = (LogicalFilter) rel;
  return new EnumerableFilter(rel.getCluster(),
      rel.getTraitSet().replace(EnumerableConvention.INSTANCE),
      convert(filter.getInput(),
          filter.getInput().getTraitSet()
              .replace(EnumerableConvention.INSTANCE)),
      filter.getCondition());
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
public RelNode convert(RelNode rel) {
  LogicalFilter filter = (LogicalFilter) rel;

  return new JdbcRules.JdbcFilter(rel.getCluster(), rel.getTraitSet().replace(this.out), convert(filter.getInput(),
      filter.getInput().getTraitSet().replace(this.out)), filter.getCondition());
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
public RelNode convert(RelNode rel) {
  final LogicalFilter filter = (LogicalFilter) rel;
  final RelTraitSet traitSet = filter.getTraitSet().replace(PigRel.CONVENTION);
  return new PigFilter(rel.getCluster(), traitSet,
      convert(filter.getInput(), PigRel.CONVENTION), filter.getCondition());
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
public void onMatch(RelOptRuleCall call) {
  LogicalFilter filter = call.rel(0);
  LogicalTableFunctionScan funcRel = call.rel(1);
  Set<RelColumnMapping> columnMappings = funcRel.getColumnMappings();
  if (columnMappings == null || columnMappings.isEmpty()) {
    // No column mapping information, so no push-down
    // possible.
    return;
  }

  List<RelNode> funcInputs = funcRel.getInputs();
  if (funcInputs.size() != 1) {
    // TODO:  support more than one relational input; requires
    // offsetting field indices, similar to join
    return;
  }
  // TODO:  support mappings other than 1-to-1
  if (funcRel.getRowType().getFieldCount()
      != funcInputs.get(0).getRowType().getFieldCount()) {
    return;
  }
  for (RelColumnMapping mapping : columnMappings) {
    if (mapping.iInputColumn != mapping.iOutputColumn) {
      return;
    }
    if (mapping.derived) {
      return;
    }
  }
  final List<RelNode> newFuncInputs = new ArrayList<RelNode>();
  final RelOptCluster cluster = funcRel.getCluster();
  final RexNode condition = filter.getCondition();

  // create filters on top of each func input, modifying the filter
  // condition to reference the child instead
  RexBuilder rexBuilder = filter.getCluster().getRexBuilder();
  List<RelDataTypeField> origFields = funcRel.getRowType().getFieldList();
  // TODO:  these need to be non-zero once we
  // support arbitrary mappings
  int[] adjustments = new int[origFields.size()];
  for (RelNode funcInput : funcInputs) {
    RexNode newCondition =
        condition.accept(
            new RelOptUtil.RexInputConverter(
                rexBuilder,
                origFields,
                funcInput.getRowType().getFieldList(),
                adjustments));
    newFuncInputs.add(
        LogicalFilter.create(funcInput, newCondition));
  }

  // create a new UDX whose children are the filters created above
  LogicalTableFunctionScan newFuncRel =
      LogicalTableFunctionScan.create(cluster, newFuncInputs,
          funcRel.getCall(), funcRel.getElementType(), funcRel.getRowType(),
          columnMappings);
  call.transformTo(newFuncRel);
}
 

import org.apache.calcite.rel.logical.LogicalFilter; //导入方法依赖的package包/类
public boolean test(LogicalFilter input) {
  return input.getCondition() instanceof RexInputRef;
}