org.apache.jena.sparql.algebra.op.OpFilter Java Examples

/**
 * Visiting filters in SPARQL algebra.
 */
@Override
public void visit(final OpFilter opFilter) {
    Traversal traversal;
    for (Expr expr : opFilter.getExprs().getList()) {
        if (expr != null) {
            traversal = __.where(WhereTraversalBuilder.transform(expr));
            traversalList.add(traversal);
        }
    }
}
 

@Override
public void visit(final OpFilter opFilter) {
    opFilter.getExprs().getList().stream().
            map(WhereTraversalBuilder::transform).
            reduce(traversal, GraphTraversal::where);
}
 

@Override
public void visit(OpFilter opFilter) {
	for(Expr e : opFilter.getExprs()) {
		processExpr(e);
	}
}
 

@Override
public void visit(OpFilter arg0) {
	visit(arg0.getSubOp(), (TranslatorContext context1, Formula f) -> {
		context.setCurrentQuery(f);

		Formula filter = Formula.TRUE;
		for(Expr e : arg0.getExprs()) {
			ExpressionContext val = handleExpression(e);
			
			if (val == null && IGNORE_UNSUPPORTED_FUNCTIONS == UnsupportedFilters.IGNORE) {
				continue;
			} else if (val == null && IGNORE_UNSUPPORTED_FUNCTIONS == UnsupportedFilters.FAIL) {
				filter = Formula.FALSE;
				break;
			}

			filter = filter.and(val.guard()).and(ebv(val));
		}
		
		Formula pass = f.and(filter);
		Continuation cc = context.getCurrentContinuation();
		if (context.explicitChoices()) {	
			TranslatorContext splitSave = context1;
			
			SplitContext leftContext = new SplitContext(splitSave);
			context = leftContext;
			context.setCurrentQuery(pass);
			cc.next(context, pass);	
			
			SplitContext rightContext = new SplitContext(splitSave);
			context = rightContext;
			Formula fail = f.and(filter.not());
			context.setCurrentQuery(fail);
			cc.next(context, fail);	
			
		} else {
			context.setCurrentQuery(pass);
			cc.next(context, pass);	
		}
	});
}
 

@Override
public void visit(OpFilter opFilter) {
	for(Expr e : opFilter.getExprs()) {
		processExpr(e);
	}
}
 

public static void main (String[] argv)
{
    String BASE = "http://example/" ; 
    BasicPattern bp = new BasicPattern() ;
    Var var_x = Var.alloc("x") ;
    Var var_z = Var.alloc("z") ;
    
    // ---- Build expression
    bp.add(new Triple(var_x, NodeFactory.createURI(BASE+"p"), var_z)) ;
    Op op = new OpBGP(bp) ;
    //Expr expr = ExprUtils.parse("?z < 2 ") ;
    Expr expr = new E_LessThan(new ExprVar(var_z), NodeValue.makeNodeInteger(2)) ;
    op = OpFilter.filter(expr, op) ;

    // ---- Example setup
    Model m = makeModel() ;
    m.write(System.out, "TTL") ;
    System.out.println("--------------") ;
    System.out.print(op) ;
    System.out.println("--------------") ;

    // ---- Execute expression
    QueryIterator qIter = Algebra.exec(op, m.getGraph()) ;
    
    // -------- Either read the query iterator directly ...
    if ( false )
    {
        for ( ; qIter.hasNext() ; )
        {
            Binding b = qIter.nextBinding() ;
            Node n = b.get(var_x) ;
            System.out.println(NodeFmtLib.displayStr(n)) ;
            System.out.println(b) ; 
        }
        qIter.close() ;
    }
    else
    {
        // -------- Or make ResultSet from it (but not both - reading an
        //          iterator consumes the current solution)
        List<String> varNames = new ArrayList<String>() ;
        varNames.add("x") ;
        varNames.add("z") ;
        ResultSet rs = new ResultSetStream(varNames, m, qIter);
        ResultSetFormatter.out(rs) ;
        qIter.close() ;
    }
    System.exit(0) ;
}
 

@Override
public QueryIterator exec(QueryIterator input, PropFuncArg argSubject, Node predicate, PropFuncArg argObject, ExecutionContext execCxt)
{
    // No real need to check the pattern arguments because
    // the replacement triple pattern and regex will cope
    // but we illustrate testing here.

    Node nodeVar = argSubject.getArg() ;
    String pattern = NodeUtils.stringLiteral(argObject.getArg()) ;
    if ( pattern == null )
    {
        Log.warn(this, "Pattern must be a plain literal or xsd:string: "+argObject.getArg()) ;
        return QueryIterNullIterator.create(execCxt) ;
    }

    if ( false )
        // Old (ARQ 1) way - not recommended.
        return buildSyntax(input, nodeVar, pattern, execCxt) ;
    
    // Better 
    // Build a SPARQL algebra expression
    Var var2 = createNewVar() ;                     // Hidden variable
    
    BasicPattern bp = new BasicPattern() ;
    Triple t = new Triple(nodeVar, RDFS.label.asNode(), var2) ;
    bp.add(t) ;
    OpBGP op = new OpBGP(bp) ;
    
    Expr regex = new E_Regex(new ExprVar(var2.getName()), pattern, "i") ;
    Op filter = OpFilter.filter(regex, op) ;

    // ---- Evaluation
    if ( true )
    {
        // Use the reference query engine
        // Create a table for the input stream (so it uses working memory at this point, 
        // which is why this is not the preferred way).  
        // Then join to expression for this stage.
        Table table = TableFactory.create(input) ;
        Op op2 = OpJoin.create(OpTable.create(table), filter) ;
        return Algebra.exec(op2, execCxt.getDataset()) ;
    }        
    
    // Use the default, optimizing query engine.
    return QC.execute(filter, input, execCxt) ;
}