Package com.hp.hpl.jena.sparql.core

Examples of com.hp.hpl.jena.sparql.core.BasicPattern

57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
        String pattern = args[0] ;
        String statsFile = args[1] ;
       
        Op op = SSE.readOp(pattern) ;

        BasicPattern bgp ;
        if ( op instanceof OpQuadPattern ) {
            bgp = ((OpQuadPattern)op).getBasicPattern() ;
        } else if ( op instanceof OpBGP ) {
            bgp = ((OpBGP)op).getPattern() ;
        }
        else {
            System.err.println("Not a quad or triple pattern") ;
            System.exit(2) ;
            bgp = null ;
        }
       
        ReorderTransformation reorder = chooseReorder(statsFile) ;
        //ReorderTransformation reorder = ReorderLib.fixed() ;
        BasicPattern bgp2 = reorder.reorder(bgp) ;
    
        System.out.println() ;
       
        print(bgp) ;
        System.out.println() ;
View Full Code Here
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
public class AlgebraExec
{
    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) ;
View Full Code Here
380
381
382
383
384
385
386
387
388
389
390
        {
            Graph g = execCxt.getActiveGraph() ;
           
            if ( g instanceof GraphTDB )
            {
                BasicPattern bgp = opBGP.getPattern() ;
                Explain.explain("Execute", bgp, execCxt.getContext()) ;
                // Triple-backed (but may be named as explicit default graph).
                //return SolverLib.execute((GraphTDB)g, bgp, input, filter, execCxt) ;
                GraphTDB gtdb = (GraphTDB)g ;
                Node gn = decideGraphNode(gtdb.getGraphName(), execCxt) ;
View Full Code Here
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
           
            if ( execCxt.getDataset() instanceof DatasetGraphTDB )
            {
                DatasetGraphTDB ds = (DatasetGraphTDB)execCxt.getDataset() ;
                Explain.explain("Execute", opQuadPattern.getPattern(), execCxt.getContext()) ;
                BasicPattern bgp = opQuadPattern.getBasicPattern() ;
                return SolverLib.execute(ds, gn, bgp, input, filter, execCxt) ;
            }
            // Maybe a TDB named graph inside a non-TDB dataset.
            Graph g = execCxt.getActiveGraph() ;
            if ( g instanceof GraphTDB )
            {
                // Triples graph from TDB (which is the default graph of the dataset),
                // used a named graph in a composite dataset.
                BasicPattern bgp = opQuadPattern.getBasicPattern() ;
                Explain.explain("Execute", bgp, execCxt.getContext()) ;
                // Don't pass in G -- gn may be different.
                return SolverLib.execute(((GraphTDB)g).getDSG(), gn, bgp, input, filter, execCxt) ;
            }
            Log.warn(this, "Non-DatasetGraphTDB passed to OpExecutorPlainTDB") ;
View Full Code Here
157
158
159
160
161
162
163
164
165
    //        DatasetGraph dg = execCxt.getDataset() ;
    //        if ( ! ( dg instanceof DatasetGraphTDB ) )
    //            throw new InternalErrorException("Not a TDB backed dataset in quad pattern execution") ;
       
        DatasetGraphTDB ds = (DatasetGraphTDB)execCxt.getDataset() ;
        BasicPattern bgp = quadPattern.getBasicPattern() ;
        Node gn = quadPattern.getGraphNode() ;
        return optimizeExecuteQuads(ds, input, gn, bgp, null, execCxt) ;
    }
View Full Code Here
285
286
287
288
289
290
291
292
293
294
295
            // substituted as part of evaluation.
           
            if ( ! peek.hasNext() )
                throw new ARQInternalErrorException("Peek iterator is already empty") ;
            BasicPattern pattern2 = Substitute.substitute(pattern, peek.peek() ) ;
            // Calculate the reordering based on the substituted pattern.
            ReorderProc proc = transform.reorderIndexes(pattern2) ;
            // Then reorder original patten
            pattern = proc.reorder(pattern) ;
        }
View Full Code Here
280
281
282
283
284
285
286
287
288
289
290
        Op op = insertAnyFilter$(exprs, patternVarsScope, null) ;
       
        for (Triple triple : pattern) {
            OpQuadPattern opQuad = getQuads(op) ;
            if ( opQuad == null ) {
                opQuad = new OpQuadPattern(graphNode, new BasicPattern()) ;
                op = OpSequence.create(op, opQuad) ;
            }

            opQuad.getBasicPattern().add(triple) ;
            // Update variables in scope.
View Full Code Here
57
58
59
60
61
62
63
64
65
66
67
  /**
   * Transforms BGPs with the reordering
   */
  @Override
  public Op transform(OpBGP opBGP) {
    BasicPattern pattern = opBGP.getPattern();
    if ( pattern.size() < 2 )
        return opBGP ;
    BasicPattern pattern2 = reorder.reorder(pattern);
    return new OpBGP(pattern2);
  }
View Full Code Here
69
70
71
72
73
74
75
76
77
78
79
  /**
   * Transforms Quad Patterns with the reordering
   */
  @Override
  public Op transform(OpQuadPattern opQuadPattern) {
    BasicPattern pattern = opQuadPattern.getBasicPattern();
        if ( pattern.size() < 2 )
            return opQuadPattern ;
    BasicPattern pattern2 = reorder.reorder(pattern);
    return new OpQuadPattern(opQuadPattern.getGraphNode(), pattern2);
  }
View Full Code Here
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
public class PathLib
{
    /** Convert any paths of exactly one predicate to a triple pattern */
    public static Op pathToTriples(PathBlock pattern)
    {
        BasicPattern bp = null ;
        Op op = null ;

        for ( TriplePath tp : pattern )
        {
            if ( tp.isTriple() )
            {
                if ( bp == null )
                    bp = new BasicPattern() ;
                bp.add(tp.asTriple()) ;
                continue ;
            }
            // Path form.
            op = flush(bp, op) ;
            bp = null ;
View Full Code Here
TOP

Related Classes of com.hp.hpl.jena.sparql.core.BasicPattern

  • arq.examples.AlgebraExec
  • arq.examples.propertyfunction.labelSearch
  • com.hp.hpl.jena.graph.Triple
  • com.hp.hpl.jena.sdb.graph.GraphSDB
  • com.hp.hpl.jena.sparql.algebra.AlgebraGenerator
  • com.hp.hpl.jena.sparql.algebra.op.OpBGP
  • com.hp.hpl.jena.sparql.algebra.op.OpQuad
  • com.hp.hpl.jena.sparql.algebra.op.OpQuadBlock
  • com.hp.hpl.jena.sparql.algebra.op.OpTriple
  • com.hp.hpl.jena.sparql.algebra.OpAsQuery$Converter
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.