Java Util.FoundOne方法代码示例

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Returns whether a given node contains a {@link SqlInOperator}.
 *
 * @param node a RexNode tree
 */
private static boolean containsInOperator(
	SqlNode node) {
	try {
		SqlVisitor<Void> visitor =
			new SqlBasicVisitor<Void>() {
				public Void visit(SqlCall call) {
					if (call.getOperator() instanceof SqlInOperator) {
						throw new Util.FoundOne(call);
					}
					return super.visit(call);
				}
			};
		node.accept(visitor);
		return false;
	} catch (Util.FoundOne e) {
		Util.swallow(e, null);
		return true;
	}
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Returns whether a given node contains a {@link SqlInOperator}.
 *
 * @param node a RexNode tree
 */
private static boolean containsInOperator(
    SqlNode node) {
  try {
    SqlVisitor<Void> visitor =
        new SqlBasicVisitor<Void>() {
          public Void visit(SqlCall call) {
            if (call.getOperator() instanceof SqlInOperator) {
              throw new Util.FoundOne(call);
            }
            return super.visit(call);
          }
        };
    node.accept(visitor);
    return false;
  } catch (Util.FoundOne e) {
    Util.swallow(e, null);
    return true;
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
public static boolean contains(MutableRel ancestor,
    final MutableRel target) {
  if (ancestor.equals(target)) {
    // Short-cut common case.
    return true;
  }
  try {
    new MutableRelVisitor() {
      @Override public void visit(MutableRel node) {
        if (node.equals(target)) {
          throw Util.FoundOne.NULL;
        }
        super.visit(node);
      }
      // CHECKSTYLE: IGNORE 1
    }.go(ancestor);
    return false;
  } catch (Util.FoundOne e) {
    return true;
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Replaces all the input references by the position in the
 * input column set. If a reference index cannot be found in
 * the input set, then we return null.
 */
private static RexNode shuttleReferences(final RexBuilder rexBuilder,
    final RexNode node, final Mapping mapping) {
  try {
    RexShuttle visitor =
        new RexShuttle() {
          @Override public RexNode visitInputRef(RexInputRef inputRef) {
            int pos = mapping.getTargetOpt(inputRef.getIndex());
            if (pos != -1) {
              // Found it
              return rexBuilder.makeInputRef(inputRef.getType(), pos);
            }
            throw Util.FoundOne.NULL;
          }
        };
    return visitor.apply(node);
  } catch (Util.FoundOne ex) {
    Util.swallow(ex, null);
    return null;
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/** Finds a {@link RexInputRef} that is equivalent to a {@link CorRef},
 * and if found, throws a {@link org.apache.calcite.util.Util.FoundOne}. */
private void findCorrelationEquivalent(CorRef correlation, RexNode e)
    throws Util.FoundOne {
  switch (e.getKind()) {
  case EQUALS:
    final RexCall call = (RexCall) e;
    final List<RexNode> operands = call.getOperands();
    if (references(operands.get(0), correlation)) {
      throw new Util.FoundOne(operands.get(1));
    }
    if (references(operands.get(1), correlation)) {
      throw new Util.FoundOne(operands.get(0));
    }
    break;
  case AND:
    for (RexNode operand : ((RexCall) e).getOperands()) {
      findCorrelationEquivalent(correlation, operand);
    }
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/** Returns whether relational expression {@code target} occurs within a
 * relational expression {@code ancestor}. */
public static boolean contains(RelNode ancestor, final RelNode target) {
  if (ancestor == target) {
    // Short-cut common case.
    return true;
  }
  try {
    new RelVisitor() {
      public void visit(RelNode node, int ordinal, RelNode parent) {
        if (node == target) {
          throw Util.FoundOne.NULL;
        }
        super.visit(node, ordinal, parent);
      }
    // CHECKSTYLE: IGNORE 1
    }.go(ancestor);
    return false;
  } catch (Util.FoundOne e) {
    return true;
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
private static boolean containsGet(RexNode node) {
  try {
    node.accept(
        new RexVisitorImpl<Void>(true) {
          @Override public Void visitCall(RexCall call) {
            if (call.getOperator() == RexBuilder.GET_OPERATOR) {
              throw Util.FoundOne.NULL;
            }
            return super.visitCall(call);
          }
        });
    return false;
  } catch (Util.FoundOne e) {
    return true;
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Returns whether a given expression is deterministic.
 *
 * @param e Expression
 * @return true if tree result is deterministic, false otherwise
 */
public static boolean isDeterministic(RexNode e) {
  try {
    RexVisitor<Void> visitor =
        new RexVisitorImpl<Void>(true) {
          @Override public Void visitCall(RexCall call) {
            if (!call.getOperator().isDeterministic()) {
              throw Util.FoundOne.NULL;
            }
            return super.visitCall(call);
          }
        };
    e.accept(visitor);
    return true;
  } catch (Util.FoundOne ex) {
    Util.swallow(ex, null);
    return false;
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Returns whether a given node contains a RexCall with a specified operator
 *
 * @param operator Operator to look for
 * @param node     a RexNode tree
 */
public static RexCall findOperatorCall(
    final SqlOperator operator,
    RexNode node) {
  try {
    RexVisitor<Void> visitor =
        new RexVisitorImpl<Void>(true) {
          public Void visitCall(RexCall call) {
            if (call.getOperator().equals(operator)) {
              throw new Util.FoundOne(call);
            }
            return super.visitCall(call);
          }
        };
    node.accept(visitor);
    return null;
  } catch (Util.FoundOne e) {
    Util.swallow(e, null);
    return (RexCall) e.getNode();
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Returns whether a given tree contains any {link RexInputRef} nodes.
 *
 * @param node a RexNode tree
 */
public static boolean containsInputRef(
    RexNode node) {
  try {
    RexVisitor<Void> visitor =
        new RexVisitorImpl<Void>(true) {
          public Void visitInputRef(RexInputRef inputRef) {
            throw new Util.FoundOne(inputRef);
          }
        };
    node.accept(visitor);
    return false;
  } catch (Util.FoundOne e) {
    Util.swallow(e, null);
    return true;
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Returns whether a given tree contains any {link RexTableInputRef} nodes.
 *
 * @param node a RexNode tree
 * @return first such node found or null if it there is no such node
 */
public static RexTableInputRef containsTableInputRef(RexNode node) {
  try {
    RexVisitor<Void> visitor =
        new RexVisitorImpl<Void>(true) {
          public Void visitTableInputRef(RexTableInputRef inputRef) {
            throw new Util.FoundOne(inputRef);
          }
        };
    node.accept(visitor);
    return null;
  } catch (Util.FoundOne e) {
    Util.swallow(e, null);
    return (RexTableInputRef) e.getNode();
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
private RexCall findItemOrFlatten(
    final RexNode node,
    final List<RexNode> projExprs) {
  try {
    RexVisitor<Void> visitor =
        new RexVisitorImpl<Void>(true) {
      public Void visitCall(RexCall call) {
        if ("item".equals(call.getOperator().getName().toLowerCase()) ||
          "flatten".equals(call.getOperator().getName().toLowerCase())) {
          throw new Util.FoundOne(call); /* throw exception to interrupt tree walk (this is similar to
                                            other utility methods in RexUtil.java */
        }
        return super.visitCall(call);
      }

      public Void visitInputRef(RexInputRef inputRef) {
        final int index = inputRef.getIndex();
        RexNode n = projExprs.get(index);
        if (n instanceof RexCall) {
          RexCall r = (RexCall) n;
          if ("item".equals(r.getOperator().getName().toLowerCase()) ||
              "flatten".equals(r.getOperator().getName().toLowerCase())) {
            throw new Util.FoundOne(r);
          }
        }

        return super.visitInputRef(inputRef);
      }
    };
    node.accept(visitor);
    return null;
  } catch (Util.FoundOne e) {
    Util.swallow(e, null);
    return (RexCall) e.getNode();
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
private RexCall findItemOrFlatten(
    final RexNode node,
    final List<RexNode> projExprs) {
  try {
    RexVisitor<Void> visitor =
        new RexVisitorImpl<Void>(true) {
      @Override
      public Void visitCall(RexCall call) {
        if ("item".equals(call.getOperator().getName().toLowerCase()) ||
          "flatten".equals(call.getOperator().getName().toLowerCase())) {
          throw new Util.FoundOne(call); /* throw exception to interrupt tree walk (this is similar to
                                            other utility methods in RexUtil.java */
        }
        return super.visitCall(call);
      }

      @Override
      public Void visitInputRef(RexInputRef inputRef) {
        final int index = inputRef.getIndex();
        RexNode n = projExprs.get(index);
        if (n instanceof RexCall) {
          RexCall r = (RexCall) n;
          if ("item".equals(r.getOperator().getName().toLowerCase()) ||
              "flatten".equals(r.getOperator().getName().toLowerCase())) {
            throw new Util.FoundOne(r);
          }
        }

        return super.visitInputRef(inputRef);
      }
    };
    node.accept(visitor);
    return null;
  } catch (Util.FoundOne e) {
    Util.swallow(e, null);
    return (RexCall) e.getNode();
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
/**
 * Finds an aggregate.
 *
 * @param node Parse tree to search
 * @return First aggregate function in parse tree, or null if not found
 */
public SqlCall findAgg(SqlNode node) {
  try {
    node.accept(this);
    return null;
  } catch (Util.FoundOne e) {
    Util.swallow(e, null);
    return (SqlCall) e.getNode();
  }
}
 

import org.apache.calcite.util.Util; //导入方法依赖的package包/类
boolean containsAnd(SqlNode node) {
  try {
    node.accept(this);
    return false;
  } catch (Util.FoundOne e) {
    return true;
  }
}