Package com.hp.hpl.jena.sparql.algebra

Examples of com.hp.hpl.jena.sparql.algebra.Op

45
46
47
48
49
50
51
52
53
54
55
        Var var_x = Var.alloc("x") ;
        Var var_z = Var.alloc("z") ;
       
        // ---- Build expression
        bp.add(new Triple(var_x, Node.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
View Full Code Here
24
25
26
27
28
29
30
31
32
33
34
        // 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, Ex1.createModel()) ;
View Full Code Here
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
        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) ;
View Full Code Here
150
151
152
153
154
155
156
157
158
        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) ;
    }
View Full Code Here
44
45
46
47
48
49
50
51
52
53
    { }
   
    @Override
    public Op transform(OpFilter opFilter, Op subOp)
    {
        Op op = apply(opFilter.getExprs(), subOp) ;
        if ( op == null )
            return super.transform(opFilter, subOp) ;
        return op ;
    }
View Full Code Here
62
63
64
65
66
67
68
69
70
71
72
        List<Pair<Var, NodeValue>> equalities = p.getLeft() ;
        Collection<Var> varsMentioned = varsMentionedInEqualityFilters(equalities) ;
        ExprList remaining = p.getRight() ;
       
        // ---- Check if the subOp is the right shape to transform.
        Op op = subOp ;
       
        // Special case : deduce that the filter will always "eval unbound"
        // hence elimate all rows.  Return the empty table.
       
        if ( testSpecialCaseUnused(subOp, equalities, remaining))
View Full Code Here
221
222
223
224
225
226
227
228
229
230
231
            // If the varsLeft are disjoint from assigned vars,
            // we may be able to push assign down right
            // (this generalises the unit table case specialcase1)
            // Needs more investigation.
           
            Op opLeft = opleftjoin.getLeft() ;
            Set<Var> varsLeft = OpVars.patternVars(opLeft) ;
            if ( varsLeft.containsAll(varsEquality) )
                return true ;
            return false ;
        }       
View Full Code Here
285
286
287
288
289
290
291
292
293
294
295
        List<Op> ops2 = new ArrayList<Op>() ;
        Collection<Var> vars = varsMentionedInEqualityFilters(equalities) ;
       
        for ( Op op : ops )
        {
            Op op2 = op ;
            if ( safeToTransform(vars, op) )
            {
                for ( Pair<Var, NodeValue> p : equalities )
                        op2 = processFilterWorker(op, p.getLeft(), p.getRight()) ;
            }
View Full Code Here
298
299
300
301
302
303
304
305
306
307
308
        return ops2 ;
    }

    private static Op rebuild(Op2 subOp, List<Op> ops)
    {
        Op chain = OpTable.unit() ;
        for ( Op op : ops )
        {
            chain = subOp.copy(chain, op) ;
        }
        return chain ;
View Full Code Here
325
326
327
328
329
330
331
332
        return subst(op, var, constant) ;
    }
   
    private static Op subst(Op subOp , Var var, NodeValue nv)
    {
        Op op = Substitute.substitute(subOp, var, nv.asNode()) ;
        return OpAssign.assign(op, var, nv) ;
    }
View Full Code Here
TOP

Related Classes of com.hp.hpl.jena.sparql.algebra.Op

  • arq.examples.AlgebraEx
  • arq.examples.AlgebraExec
  • arq.examples.propertyfunction.labelSearch
  • arq.sse_query
  • com.hp.hpl.jena.sdb.compiler.QueryCompilerMain
  • com.hp.hpl.jena.sdb.compiler.QueryCompilerMain$LimitOffsetOptimizer
  • com.hp.hpl.jena.sdb.compiler.QueryIterOpSQL
  • com.hp.hpl.jena.sdb.compiler.SDBCompile
  • com.hp.hpl.jena.sdb.compiler.TransformSliceProject
  • com.hp.hpl.jena.sdb.engine.QueryEngineSDB
    • 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.