import org.openrdf.query.algebra.Compare; //导入依赖的package包/类
@Test
public void testFilter() {
    final AggregationPipelineQueryNode base = new AggregationPipelineQueryNode(
            collection,
            new LinkedList<>(),
            Sets.newHashSet("x", "y"),
            Sets.newHashSet("x", "y", "opt"),
            HashBiMap.create());
    // Extend with a supported filter
    AggregationPipelineQueryNode node = base.clone();
    boolean success = node.filter(new Compare(new Var("x"), new Var("y"), Compare.CompareOp.EQ));
    Assert.assertTrue(success);
    Assert.assertEquals(Sets.newHashSet("x", "y", "opt"), node.getBindingNames());
    Assert.assertEquals(Sets.newHashSet("x", "y"), node.getAssuredBindingNames());
    Assert.assertEquals(3, node.getPipeline().size());
    // Extend with an unsupported filter
    node = base.clone();
    success = node.filter(new IsLiteral(new Var("opt")));
    Assert.assertFalse(success);
    Assert.assertEquals(Sets.newHashSet("x", "y", "opt"), node.getBindingNames());
    Assert.assertEquals(Sets.newHashSet("x", "y"), node.getAssuredBindingNames());
    Assert.assertEquals(0, node.getPipeline().size());
}
 

import org.openrdf.query.algebra.Compare; //导入依赖的package包/类
private void extractNegatedProperties(final ValueExpr condition,
        final Set<URI> negatedProperties) {
    if (condition instanceof And) {
        final And and = (And) condition;
        extractNegatedProperties(and.getLeftArg(), negatedProperties);
        extractNegatedProperties(and.getRightArg(), negatedProperties);

    } else if (condition instanceof Compare) {
        final Compare compare = (Compare) condition;
        Preconditions.checkArgument(compare.getOperator() == CompareOp.NE);
        if (compare.getLeftArg() instanceof ValueConstant) {
            Preconditions.checkArgument(compare.getRightArg() instanceof Var);
            negatedProperties.add((URI) ((ValueConstant) compare.getLeftArg()).getValue());
        } else if (compare.getRightArg() instanceof ValueConstant) {
            Preconditions.checkArgument(compare.getLeftArg() instanceof Var);
            negatedProperties
                    .add((URI) ((ValueConstant) compare.getRightArg()).getValue());
        } else {
            fail("Unsupported path expression. Check condition node: ", condition);
        }
    }
}
 

import org.openrdf.query.algebra.Compare; //导入依赖的package包/类
@Override
public void meet(Compare arg0) throws SparqlParserException
{
   arg0.getLeftArg().visit(this);
   ITerm termLeft = getTerm();
   arg0.getRightArg().visit(this);
   ITerm termRight = getTerm();
   
   CompareOp op = arg0.getOperator();
   switch (op) {
      case EQ: mTerm = sExpressionFactory.formEq(termLeft, termRight); break;
      case NE: mTerm = sExpressionFactory.formNeq(termLeft, termRight); break;
      case GT: mTerm = sExpressionFactory.formGt(termLeft, termRight); break;
      case GE: mTerm = sExpressionFactory.formGte(termLeft, termRight); break;
      case LT: mTerm = sExpressionFactory.formLt(termLeft, termRight); break;
      case LE: mTerm = sExpressionFactory.formLte(termLeft, termRight); break;
   }
}
 

import org.openrdf.query.algebra.Compare; //导入依赖的package包/类
@Override
public void meet(final Compare n) {
    final QueryModelNode p = n.getParentNode();
    final boolean par = p instanceof Not || p instanceof MathExpr;
    emitIf(par, "(").emit(n.getLeftArg()).emit(" ").emit(n.getOperator().getSymbol())
            .emit(" ").emit(n.getRightArg()).emitIf(par, ")");
}
 

import org.openrdf.query.algebra.Compare; //导入依赖的package包/类
@Override
public void meet(Compare node) throws RuntimeException {
	setSeen(node);
	super.meet(node);
}
 

import org.openrdf.query.algebra.Compare; //导入依赖的package包/类
@Override
public void meet(Compare node) throws RuntimeException {
	check(node);
	super.meet(node);
}
 

import org.openrdf.query.algebra.Compare; //导入依赖的package包/类
/**
 * Add a SPARQL filter to the pipeline, if possible. A filter eliminates
 * results that don't satisfy a given condition. Not all conditional
 * expressions are supported. If unsupported expressions are used in the
 * filter, the pipeline will remain unchanged and this method will return
 * false. Currently only supports binary {@link Compare} conditions among
 * variables and/or literals.
 * @param condition The filter condition
 * @return True if the filter was successfully converted into a pipeline
 *  step, false otherwise.
 */
public boolean filter(ValueExpr condition) {
    if (condition instanceof Compare) {
        Compare compare = (Compare) condition;
        Compare.CompareOp operator = compare.getOperator();
        Object leftArg = valueFieldExpr(compare.getLeftArg());
        Object rightArg = valueFieldExpr(compare.getRightArg());
        if (leftArg == null || rightArg == null) {
            // unsupported value expression, can't convert filter
            return false;
        }
        final String opFunc;
        switch (operator) {
        case EQ:
            opFunc = "$eq";
            break;
        case NE:
            opFunc = "$ne";
            break;
        case LT:
            opFunc = "$lt";
            break;
        case LE:
            opFunc = "$le";
            break;
        case GT:
            opFunc = "$gt";
            break;
        case GE:
            opFunc = "$ge";
            break;
        default:
            // unrecognized comparison operator, can't convert filter
            return false;
        }
        Document compareDoc = new Document(opFunc, Arrays.asList(leftArg, rightArg));
        pipeline.add(Aggregates.project(Projections.fields(
                Projections.computed("FILTER", compareDoc),
                Projections.include(VALUES, HASHES, TYPES, LEVEL, TIMESTAMP))));
        pipeline.add(Aggregates.match(new Document("FILTER", true)));
        pipeline.add(Aggregates.project(Projections.fields(
                Projections.include(VALUES, HASHES, TYPES, LEVEL, TIMESTAMP))));
        return true;
    }
    return false;
}
 

import org.openrdf.query.algebra.Compare; //导入依赖的package包/类
@Override
public void meet(Compare arg0) throws Exception {
	ValueExpr left = arg0.getLeftArg();

	if (!(left instanceof Var))
		return;

	Var var = (Var) left;

	if (!var.equals(inXSDDateTimeVar))
		return;

	CompareOp op = arg0.getOperator();
	ValueExpr right = arg0.getRightArg();

	if (!(right instanceof ValueConstant)) {
		if (log.isLoggable(Level.SEVERE))
			log.severe("Expected value constant for time filter [right = "
					+ right + "]");

		return;
	}

	ValueConstant constant = (ValueConstant) right;
	Value value = constant.getValue();

	if (!(value instanceof Literal)) {
		if (log.isLoggable(Level.SEVERE))
			log.severe("Expected literal value [value = " + value + "]");

		return;
	}
	
	Literal literal = (Literal)value;

	if (!literal.getDatatype().equals(XMLSchema.DATETIME)) {
		if (log.isLoggable(Level.SEVERE))
			log.severe("Expected XSD date time literal datatype [literal = " + literal + "]");

		return;
	}
	
	if (op.equals(CompareOp.GE)) {
		timeFrom = dtf.parseDateTime(literal.getLabel());
	} else if (op.equals(CompareOp.LT)) {
		timeTo = dtf.parseDateTime(literal.getLabel());
	} else {
		if (log.isLoggable(Level.SEVERE))
			log.severe("Expected either >= or < operator in time filter");
	}
}
 

import org.openrdf.query.algebra.Compare; //导入依赖的package包/类
@Override
public void meet(Compare node) throws RuntimeException {
	node.getLeftArg().visit(this);
	buffer.append(" ").append(node.getOperator().getSymbol()).append(" ");
	node.getRightArg().visit(this);
}