Java Op类代码示例

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
/** Execute without modification of the op - does <b>not</b> apply special graph name translations */
private static QueryIterator plainExecute(Op op, QueryIterator input, ExecutionContext execCxt)
{
    // -- Execute
    // Switch to a non-reordering executor
    // The Op may be a sequence due to TransformFilterPlacement
    // so we need to do a full execution step, not go straight to the SolverLib.

    ExecutionContext ec2 = new ExecutionContext(execCxt) ;
    ec2.setExecutor(plainFactory) ;

    // Solve without going through this executor again.
    // There would be issues of nested patterns but this is only a
    // (filter (bgp...)) or (filter (quadpattern ...)) or sequences of these.
    // so there are no nested patterns to reorder.
    return QC.execute(op, input, ec2) ;
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
private QueryIterator buildSyntax(QueryIterator input, Node nodeVar, String pattern, ExecutionContext execCxt)
{
    Var var2 = createNewVar() ; 
    // Triple patterns for   ?x rdfs:label ?hiddenVar
    ElementTriplesBlock elementBGP = new ElementTriplesBlock();
    Triple t = new Triple(nodeVar, RDFS.label.asNode(), var2) ;
    elementBGP.addTriple(t) ;
    
    // Regular expression for  regex(?hiddenVar, "pattern", "i") 
    Expr regex = new E_Regex(new ExprVar(var2.getName()), pattern, "i") ;
    
    ElementGroup elementGroup = new ElementGroup() ;
    elementGroup.addElement(elementBGP) ;
    elementGroup.addElement(new ElementFilter(regex)) ;
    // Compile it.
    // The better design is to build the Op structure programmatically,
    Op op = Algebra.compile(elementGroup) ;
    op = Algebra.optimize(op, execCxt.getContext()) ;
    return QC.execute(op, input, execCxt) ;
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
public static void main(String []args)
{
    String s = "SELECT DISTINCT ?s { ?s ?p ?o }";
    
    // Parse
    Query query = QueryFactory.create(s) ;
    System.out.println(query) ;
    
    // Generate algebra
    Op op = Algebra.compile(query) ;
    op = Algebra.optimize(op) ;
    System.out.println(op) ;
    
    // Execute it.
    QueryIterator qIter = Algebra.exec(op, ExQuerySelect1.createModel()) ;
    
    // Results
    for ( ; qIter.hasNext() ; )
    {
        Binding b = qIter.nextBinding() ;
        System.out.println(b) ;
    }
    qIter.close() ;
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
private static String parseQuery(String s) {
    String q = getQuery(s);

    try {
        Query query = QueryFactory.create(q);
        Op op = Algebra.compile(query);
        TripleCollector tc = new TripleCollector();
        OpWalker.walk(op, tc);
        Set<Triple> triples = tc.getTriples();
        return _toGViz(triples, query.getPrefixMapping());
    } catch (Exception e) {
        e.printStackTrace();
        return "";
    }
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
static List parseToOp(String q) {
        try {
            Query query = QueryFactory.create(q);
            Op op = Algebra.compile(query);
//            System.out.println(toComment(q));

            return Arrays.asList(q, op);
        } catch (Exception e) {
//            System.out.println(toComment(q));
            //e.printStackTrace();
            return null;
        }
    }
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
GraphTraversal<Vertex, ?> convertToGremlinTraversal(final Query query) {
    final Op op = Algebra.compile(query);
    OpWalker.walk(op, this);
    if (!query.isQueryResultStar()) {
        final List<String> vars = query.getResultVars();
        switch (vars.size()) {
            case 0:
                throw new IllegalStateException();
            case 1:
                if (query.isDistinct()) {
                    traversal = traversal.dedup(vars.get(0));
                }
                traversal = traversal.select(vars.get(0));
                break;
            case 2:
                if (query.isDistinct()) {
                    traversal = traversal.dedup(vars.get(0), vars.get(1));
                }
                traversal = traversal.select(vars.get(0), vars.get(1));
                break;
            default:
                final String[] all = new String[vars.size()];
                vars.toArray(all);
                if (query.isDistinct()) {
                    traversal = traversal.dedup(all);
                }
                final String[] others = Arrays.copyOfRange(all, 2, vars.size());
                traversal = traversal.select(vars.get(0), vars.get(1), others);
                break;
        }
    } else {
        if (query.isDistinct()) {
            traversal = traversal.dedup();
        }
    }
    return traversal;
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
public static void main(String...argv) {
    JenaSystem.init();
    Table table = new PFbyTable.Table() ;
    
    add(table, ":s1", ":o1") ;
    add(table, ":s1", ":o2") ;
    add(table, ":s2", ":o1") ;
    add(table, ":s2", ":o2") ;
    add(table, ":s2", ":o3") ;
    
    Dataset ds = DatasetFactory.create() ;
    
    PropertyFunctionFactory pff = (uri)->new PFbyTable() ;
    // rdf:rest is special to property functions!  
    String iri = "http://example/trans" ;
    PFbyTable.addTable(NodeFactory.createURI(iri), table);
    PropertyFunctionRegistry.get().put(iri, pff) ;
    
    String x = StrUtils.strjoinNL
        ("PREFIX : <http://example/>"
        ,"PREFIX rdf: <"+RDF.getURI()+">"
        ,"PREFIX rdfs: <"+RDFS.getURI()+">"
        //,"SELECT * { ?s ?p ?o . ?s rdfs:member :o1 . ?s rdf:rest :o1 }"
        //,"SELECT * { ?s rdfs:member :o1 }"
        ,"SELECT * { { ?s :trans :o1 } UNION { :s2 :trans ?o }  UNION { ?X :trans ?Y } }"
        ) ;
    Query query = QueryFactory.create(x) ;
    System.out.println(query); 
    
    Op op = Algebra.compile(query) ;
    Op op1 = Algebra.optimize(op) ;
    System.out.println(op1);
    SSE.write(op1); 
    
    QueryExecution qExec = QueryExecutionFactory.create(query, ds) ;
    QueryExecUtils.executeQuery(qExec);
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
@Override
public QueryIterator eval(Op op, DatasetGraph dsg, Binding initial, Context context)
{
    // Extension point: access possible to all the parameters for execution.
    // Be careful to deal with initial bindings.
    Transform transform = new MyTransform() ;
    op = Transformer.transform(transform, op) ;
    return super.eval(op, dsg, initial, context) ;
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
@Override
protected Op modifyOp(Op op)
{
    // Extension point: possible place to alter the algebra expression.
    // Alternative to eval(). 
    op = super.modifyOp(op) ;
    // op = Algebra.toQuadForm(op) ;
    return op ;
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
@Override
public boolean accept(Op op, DatasetGraph dataset, Context context) {
    return false;
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
@Override
public Plan create(Op op, DatasetGraph dataset, Binding inputBinding,
        Context context) {
    return null;
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
public LinkedDataFragmentEngine(Op op, DatasetGraph dataset, Binding input, Context context) {
    super(op, dataset, input, context);
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
@Override
public boolean accept(Op op, DatasetGraph dataset, Context context) {
    // Refuse to accept algebra expressions directly.
    return false;
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
@Override
public Plan create(Op op, DatasetGraph dataset, Binding inputBinding, Context context) {
    // Should not be called because accept/Op is false
    throw new ARQInternalErrorException("LDFQueryEngine: factory called directly with an algebra expression");
}
 

import org.apache.jena.sparql.algebra.Op; //导入依赖的package包/类
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) ;
}