public static void addVar(Collection<Var> acc, Node n) { if ( n == null ) return; if ( n.isVariable() ) acc.add(Var.alloc(n)); }
final List<String> vars = query.getResultVars(); if (!query.isQueryResultStar() && !query.hasGroupBy()) { final String[] all = new String[vars.size()]; vars.toArray(all); String grpVar = ""; for (Var expr : lstExpr.getVars()) { grpVar = expr.getName();
public static String toString(Entry<Var, Expr> e) { Var v = e.getKey(); Expr x = e.getValue(); String result = x.isVariable() && x.asVar().equals(v) ? "" + v : "(" + x + " AS " + v + ")"; return result; }
public void addGroupBy(String varName) { varName = Var.canonical(varName) ; addGroupBy(Var.alloc(varName)) ; }
public static Iterator<Node> storeGraphNames(Store store) { List<Node> x = new ArrayList<Node>() ; String qs = "SELECT ?g { GRAPH ?g { }}" ; QueryExecution qExec = QueryExecutionFactory.create(qs, SDBFactory.connectDataset(store)) ; ResultSet rs = qExec.execSelect() ; Var var_g = Var.alloc("g") ; while(rs.hasNext()) { Node n = rs.nextBinding().get(var_g) ; x.add(n) ; } return x.iterator() ; }
private QueryIterator subjectIsIRI(Node subject, PropFuncArg argObject, Binding binding, ExecutionContext execCxt) String namespace = subject.getNameSpace() ; String localname = subject.getLocalName() ; if ( Var.isVar(namespaceNode) || Var.isVar(localnameNode) ) b = BindingFactory.create(binding) ; if ( Var.isVar(namespaceNode) ) b.add(Var.alloc(namespaceNode), NodeFactory.createURI(namespace)) ; if ( localnameNode.isVariable() && Objects.equals(namespaceNode, localnameNode) ) localnameNode = NodeFactory.createURI(namespace) ; if ( Var.isVar(localnameNode) ) b.add(Var.alloc(localnameNode), NodeFactory.createLiteral(localname)) ; else
case BNODE : return NodeFactory.createBlankNode(tokenImage) ; case IRI : return NodeFactory.createURI(tokenImage) ; case PREFIXED_NAME : if ( pmap == null ) return NodeFactory.createURI("urn:prefixed-name:"+tokenImage+":"+tokenImage2) ; String x = pmap.expand(tokenImage, tokenImage2) ; if ( x == null ) if ( ! n.isURI() ) throw new RiotException("Invalid token: "+this) ; RDFDatatype dt = TypeMapper.getInstance().getSafeTypeByName(n.getURI()) ; return NodeFactory.createLiteral(lexToken.getImage(), dt) ; return NodeFactory.createLiteral(tokenImage) ; case VAR: return Var.alloc(tokenImage) ; case KEYWORD: if ( tokenImage.equals(ImageANY) )
if ( subject.isURI() || subject.isBlank() ) return IterLib.noResults(execCxt) ; if ( Var.isVar(subject) && Var.isVar(object) ) throw new QueryExecException("str: Both subject and object are unbound variables") ; if ( Var.isVar(object) ) throw new QueryExecException("str: Object is an unbound variables") ; if ( object.isBlank() ) throw new QueryExecException("str: object is a blank node") ; Node strValue = NodeFactory.createLiteral(NodeFunctions.str(object)) ; if ( Var.isVar(subject) ) return IterLib.oneResult(binding, Var.alloc(subject), strValue, execCxt) ; else
if (!result.hasNext()) { if (constraint.getProjectVars().stream().noneMatch(var -> "check".equals(var.getVarName()))) { while (result.hasNext()) { Binding binding = result.nextBinding(); Node node = binding.get(SELECT_VALIDATION_VARIABLE); if (node != null) { if (node.isLiteral()) { String resultString = node.getLiteralValue().toString(); if (SELECT_VALIDATION_PASSED_VALUE.equals(resultString)) { return new ValidationResult(); String errorMessage = "SPARQL query produced this solution, which indicates a problem: " + binding.toString() + ", query: " + constraint.toString(Syntax.syntaxSPARQL_11); if (result.hasNext()) { throw new IllegalStateException("We should have returned a result earlier. Constraint: " + constraint.toString(Syntax.syntaxSPARQL_11));
public static Plan getPlan(HDTQueryEngine engine, Query query, DatasetGraph dataset, Binding input, Context context) { if(query.getAggregators().size()!=1) return null; Aggregator ag = query.getAggregators().get(0).getAggregator(); if(ag==null || !query.getHavingExprs().isEmpty() || !query.getGroupBy().isEmpty() || query.hasLimit() || query.hasOffset() || !( (ag instanceof AggCount) || (ag instanceof AggCountVar) || (ag instanceof AggCountDistinct) || (ag instanceof AggCountVarDistinct)) ) { return null; return null; Var countVar = expr.asVar(); if(countVar.equals(triple.getSubject())) { count = dictionary.getNsubjects(); } else if(countVar.equals(triple.getPredicate())) { count = dictionary.getNpredicates(); } else if(countVar.equals(triple.getObject())) { count = dictionary.getNobjects(); } else { return null; Var countVar = expr.asVar(); if( !(triple.getSubject().equals(countVar) || triple.getPredicate().equals(countVar) || Binding bindingResult = new BindingOne( varOutput, NodeFactory.createLiteral(Long.toString(count), XSDDatatype.XSDinteger) ); return new PlanOp(new HDTOptimizedOp(), engine, new QueryIterYieldN(1, bindingResult));
@Deprecated // Remove once countQuery works as espected public static long countQueryOld(Query query, QueryExecutionFactory qef) { Var outputVar = Var.alloc("_c_"); if(query.isConstructType()) { Element element = query.getQueryPattern(); query = new Query(); query.setQuerySelectType(); query.setQueryResultStar(true); query.setQueryPattern(element); } Query countQuery = QueryFactory.create("Select (Count(*) As ?_c_) { {" + query + "} }", Syntax.syntaxSPARQL_11); QueryExecution qe = qef.createQueryExecution(countQuery); ResultSet rs = qe.execSelect(); Binding binding = rs.nextBinding(); Node node = binding.get(outputVar); Number numeric = (Number)node.getLiteralValue(); long result = numeric.longValue(); return result; }
if (!object.getArg(0).isLiteral() || !object.getArg(1).isLiteral()) { return IterLib.noResults(execCxt); String s = object.getArg(0).getLiteralLexicalForm() ; String regex = object.getArg(1).getLiteralLexicalForm() ; if (Var.isVar(subject)) { final Var subjectVar = Var.alloc(subject); NodeFactory.createLiteral(item))); return new QueryIterPlainWrapper(it, execCxt);
@Override public QueryIterator execEvaluated(Binding binding, Node subject, Node predicate, Node object, ExecutionContext execCxt) { if ( Var.isVar(subject) ) throw new ExprEvalException("bnode: subject is an unbound variable") ; if ( ! subject.isBlank() ) return IterLib.noResults(execCxt) ; String str = subject.getBlankNodeLabel() ; Node obj = NodeFactory.createLiteral(str) ; if ( Var.isVar(object) ) return IterLib.oneResult(binding, Var.alloc(object), obj, execCxt) ; // Subject and object are concrete if ( object.sameValueAs(obj) ) return IterLib.result(binding, execCxt) ; return IterLib.noResults(execCxt) ; } }
private void testErr(String qsAgg, DatasetGraph ds, Syntax syntax) { Query query = buildGroupBy(qsAgg, syntax) ; try ( QueryExecution qExec = QueryExecutionFactory.create(query, DatasetFactory.wrap(ds)) ) { ResultSet rs = qExec.execSelect() ; assertTrue(rs.getResultVars().contains("X")) ; Binding b = rs.nextBinding() ; assertFalse(b.contains(Var.alloc("X"))) ; } }
if(e1.matches(RDF.type.asNode())){ return -2; } else if(e2.matches(RDF.type.asNode())){ return 2; } else { .filter(t -> !t.hasAnchor()) .map(GenericTree::getData) .filter(node -> !(node.isVariable() || node.isBlank())) .collect(Collectors.toList()); if(!concreteChildren.isEmpty()) { .filter(t -> t.hasAnchor() && (t.isLiteralValueNode() || t.isResourceNode())) .forEach(child -> { Var obj = Var.alloc("var" + nodes2Select.indexOf(child.getAnchorVar())); String objStr = FmtUtils.stringForNode(obj, context); String tpStr = (edge instanceof NodeInv) object = Var.alloc("var" + nodes2Select.indexOf(child.getAnchorVar())); } else if(nodes2Select.contains(object)) { object = Var.alloc("var" + nodes2Select.indexOf(object)); } else if(child.isVarNode()) { ExprNode filter = new E_Equals( new E_Datatype(new ExprVar(object)), NodeValue.makeNode(NodeFactory.createURI(child.getDatatype().getURI())));
private ResultSetRewindable convertToStrings(ResultSetRewindable resultsActual) { List<Binding> bindings = new ArrayList<>() ; while(resultsActual.hasNext()) { Binding b = resultsActual.nextBinding() ; BindingMap b2 = BindingFactory.create() ; for ( String vn : resultsActual.getResultVars() ) { Var v = Var.alloc(vn) ; Node n = b.get(v) ; String s ; if ( n == null ) s = "" ; else if ( n.isBlank() ) s = "_:"+n.getBlankNodeLabel() ; else s = NodeFunctions.str(n) ; b2.add(v, NodeFactory.createLiteral(s)) ; } bindings.add(b2) ; } ResultSet rs = new ResultSetStream(resultsActual.getResultVars(), null, new QueryIterPlainWrapper(bindings.iterator())) ; return ResultSetFactory.makeRewindable(rs) ; }
@Test public void test_RS_peeking_9() { // Check that peeking causes the correct row to be returned when we actually access the rows Node first = NodeFactory.createURI("tag:first"); Node second = NodeFactory.createURI("tag:second"); Var x = Var.alloc("x"); ResultSet inner = new ResultSetMem(make("x", first), make("x", second)); ResultSetPeekable rs = ResultSetFactory.makePeekable(inner); assertTrue(rs.hasNext()); // Peek and check row is as expected Binding peeked = rs.peekBinding(); assertNotNull(peeked); assertTrue(first.equals(peeked.get(x))); // Check first row is as expected Binding next = rs.nextBinding(); assertNotNull(next); assertTrue(first.equals(next.get(x))); // Repeat for second row peeked = rs.peekBinding(); assertNotNull(peeked); assertTrue(second.equals(peeked.get(x))); next = rs.nextBinding(); assertNotNull(next); assertTrue(second.equals(next.get(x))); }
public static Query createQueryCount(Var countVar, Element e, Long limit) { if(limit != null) { e = limitElement(e, limit); } Var tmpVar = Var.alloc(countVar.getName() + "_tmp_"); Query result = new Query(); result.setQuerySelectType(); result.getProject().add(countVar, new ExprAggregator(tmpVar, new AggCount())); result.setQueryPattern(e); return result; }