Refine search
public static SparqlView create(String name, QuadPattern quadPattern, Element element) { Op tmp = Algebra.compile(element); Op op = Algebra.toQuadForm(tmp); SparqlView result = create(name, quadPattern, op); return result; }
static public QueryIterator exec(Op op, Dataset ds) { return exec(op, ds.asDatasetGraph()) ; }
private static void outputAlgebraOptQuads(ServletOutputStream outStream, final Query query, boolean lineNumbers) throws IOException { outStream.println("<p>Alebgra, with general quads optimizations:</p>") ; final Op op = Algebra.optimize(Algebra.toQuadForm(Algebra.compile(query))) ; outputQueryOp(outStream, query, op, lineNumbers) ; }
private static void outputAlgebraOpt(ServletOutputStream outStream, final Query query, boolean lineNumbers) throws IOException { outStream.println("<p>Alebgra, with general triple optimizations:</p>") ; final Op op = Algebra.optimize(Algebra.compile(query)) ; outputQueryOp(outStream, query, op, lineNumbers) ; }
/** query->algebra/quads->OpAsQuery->query */ private static Query[] roundTripQueryQuad(String query) { Query orig = QueryFactory.create(query, Syntax.syntaxSPARQL_11); Op toReconstruct = Algebra.compile(orig); toReconstruct = Algebra.toQuadForm(toReconstruct); Query got = OpAsQuery.asQuery(toReconstruct); Query[] r = { orig, got }; return r; }
private void checkRename(String queryString, String opExpectedString) { Op opExpected = SSE.parseOp(opExpectedString) ; queryString = "PREFIX : <http://example/>\n"+queryString ; Query query = QueryFactory.create(queryString) ; Op op = Algebra.compile(query) ; Op opRenamed = TransformScopeRename.transform(op) ; assertEquals(opExpected, opRenamed) ; }
private static void test(String patternString, boolean optimize, String... strExpected) { Query q = QueryFactory.create("SELECT * WHERE "+patternString) ; Op op = Algebra.compile(q) ; if ( optimize ) op = Algebra.optimize(op) ; op = Algebra.toQuadForm(op) ; Op op2 = SSE.parseOp(StrUtils.strjoinNL(strExpected)) ; assertEquals(op2, op) ; } }
protected Op createOp(Query query) { Op op = Algebra.compile(query) ; return op ; }
@Override protected Op modifyOp(Op op) { op = super.modifyOp(op) ; op = Algebra.toQuadForm(op) ; return op ; }
public static void checkOp(Query query, boolean optimizeAlgebra) { IndentedLineBuffer buff = new IndentedLineBuffer() ; Op op = Algebra.compile(query) ; if ( optimizeAlgebra ) op = Algebra.optimize(op) ; WriterSSE.out(buff, op, query) ; String str = buff.toString() ; try { Op op2 = SSE.parseOp(str) ; if ( op.hashCode() != op2.hashCode() ) { op.hashCode() ; op2.hashCode() ; dump(op, op2) ; throw new QueryCheckException("reparsed algebra expression hashCode does not equal algebra from query") ; } if ( ! op.equals(op2) ) { dump(op, op2) ; throw new QueryCheckException("reparsed algebra expression does not equal query algebra") ; } } catch (SSEParseException | BuildException ex) { System.err.println(str); throw ex ; } // Breakpoint }
protected Op op(String pattern, Mode mode) { Op op = SSE.parseOp(pattern) ; if ( mode == Mode.QUADS ) op = Algebra.toQuadForm(op) ; else if ( mode == Mode.QUADBLOCKS ) op = Algebra.toQuadBlockForm(op) ; return op ; } }
private static void check(Op opToOptimize, String opExpectedString) { Op opOptimize = Algebra.optimize(opToOptimize) ; Op opExpected = SSE.parseOp(opExpectedString) ; if ( false ) { // Hook for more detail during development. boolean b = Objects.equals(opExpected, opOptimize) ; if ( ! b ) { System.err.println("** Input:"); System.err.print(opToOptimize) ; System.err.println("** Expected:"); System.err.print(opExpected) ; System.err.println("** Actual:"); System.err.print(opOptimize) ; System.err.println("-------------------") ; } } assertEquals(opExpected, opOptimize) ; }
@Override protected Binding computeNext() { while(bindings.hasNext()) { List<Binding> cand = bindings.next(); Binding r = null; for(Binding b : cand) { if(r == null) { r = b; } else { boolean isCompatible = Algebra.compatible(r, b); if(isCompatible) { r = Algebra.merge(r, b); } else { continue; } } } return r; } return endOfData(); } }
/** Apply static transformations to a query to optimize it */ public static Op optimize(Op op) { return optimize(op, null) ; }
@Override public boolean containsCompatibleWithSharedDomain(Binding bindingLeft) { if ( commonVars.size() == 0 ) return false ; for ( Binding bindingRight: table ) { if ( hasCommonVars(bindingLeft, bindingRight) && Algebra.compatible(bindingLeft, bindingRight) ) return true ; } return false ; }
if ( Algebra.disjoint(bindingLeft, bindingRight) ) if ( ! Algebra.compatible(bindingLeft, bindingRight) )
public static void main(String[] args) { //String sA = "Select * { ?s ?p ?o . Filter((?s || ?p) && ?o) . }"; //String sA = "Select * { ?s ?p ?o . Filter((?s || ?p) && !(?o || ?g)) . }"; String sA = "Select * { ?s ?p ?o . Filter(?o != <http://Person>). Optional { { ?x ?y ?z . Filter(?x != <http://x> && ?x = ?y) . } Union { ?x a ?y . Filter(?x = <http://x>) . } } . }"; //String sA = "Select * { ?s ?p ?o . Filter(!(?s = ?p || ?p = ?o && ?s = ?o || ?o = ?s)) . }"; //String sA = "Select * { ?s ?p ?o . Filter(!(?s = ?p || ?j = <http://x>)) . }"; Query qA = QueryFactory.create(sA); Op opA = Algebra.compile(qA); opA = Algebra.toQuadForm(opA); System.out.println(opA); // How to deal with union? variables appearing in them //System.out.println(opA.getClass()); ExprList exprs = FilterUtils.collectExprs(opA, new ExprList()); ExprList proc = eval(exprs); System.out.println(proc); List<ExprList> clauses = dnfToClauses(proc); System.out.println("Mentioned vars:" + proc.getVarsMentioned()); System.out.println("Clauses: " + clauses); }
@Test public void testTable2() { // JENA-1468 : op to string and back. String qs = "SELECT * WHERE { ?x ?p ?z . VALUES ?y { } }" ; Query query = QueryFactory.create(qs); Op op = Algebra.compile(query); String x = op.toString(); Op op1 = SSE.parseOp(x); Query query2 = OpAsQuery.asQuery(op1); assertEquals(query, query2); }