Java Code Examples for org.apache.jena.sparql.algebra.Algebra#compile()

public RuleforJena(Query constructQuery, int id) {
	this.id = id;
	antecedent = Algebra.compile(constructQuery);
	// KAVITHA: the consequent should be a single triple
	List<Triple> list = constructQuery.getConstructTemplate().getBGP()
			.getList();
	consequent = new OpTriple(list.get(0));

	if (SPARQLRewriterForJena.GENERATE_TRACE == true) {

		Op bind = null;
		VarExprList expr = new VarExprList();
		expr.add(
				Var.alloc("RULEID"),
				new NodeValueNode(NodeFactory.createLiteral(String
						.valueOf(id))));
		bind = OpExtend.extend(antecedent, expr);
		antecedent = bind;
	}

}
 

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) ;
}
 

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() ;
}
 

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;
}
 

public static Op compile(String queryString) throws MalformedURLException, IOException {
	return Algebra.compile(parse(queryString));
}
 

public static Op compile(Query query) throws MalformedURLException, IOException {
	return Algebra.compile(query);
}
 

/***
 * Takes a SELECT query and unroll it into a more complex SPARQL query under
 * rules
 * 
 * @param query
 */
public Query unfold(Query query) {

	ResolutionVisitor visitor = new ResolutionVisitor(rules);
	Op body = Algebra.compile(query);

	OpVariableVistor<String> collector = new OpVariableVistor<String>(body,
			true) {
		@Override
		protected String processVar(Node v) {
			return v.getName();
		}
	};
	OpWalker.walk(body, collector);

	Set<String> bindingNames = new HashSet<String>(collector.getResult());

	visitor.setBindingNames(bindingNames);

	Op newQuery = body;
	newQuery = Transformer.transform(visitor, body);

	
	VarExprList expr = new VarExprList();	
//	E_StrConcat trace = getRuleTracingConcat(newQuery);
	E_StrConcat trace = null;
	
	if (trace!=null) {
		expr.add(Var.alloc("trace"),trace);		
		newQuery = OpExtend.extend(newQuery, expr);
		newQuery = OpJoin.create(newQuery, OpTable.unit());
		
		if (SPARQLRewriterForJena.GENERATE_TRACE_SUMMARY) {
			
			VarExprList groupVars = new VarExprList();
			groupVars.add(Var.alloc("trace"));
			AggCount count = new AggCount();
			ExprAggregator aggregators = new ExprAggregator(Var.alloc("trace.sum"), count);
			List<ExprAggregator> list = new LinkedList<ExprAggregator>();
			list.add(aggregators);
			
			Op groupBy = new OpGroup(newQuery, groupVars, list);
			
			VarExprList expr2 = new VarExprList();	
			expr2.add(Var.alloc("sum"), new ExprVar("trace.sum"));			
			groupBy = OpExtend.extend(groupBy, expr2);
			List<Var> vars = new LinkedList<Var>();
			vars.add(Var.alloc("sum"));
			vars.add(Var.alloc("trace"));
			OpProject project = new OpProject(groupBy, vars);
			newQuery = project;
			
			
		}

	}
	
	
	
	
	
	Query q = OpAsQuery.asQuery(newQuery);
	q.setDistinct(true);	// KAVITHA: Not setting distinct on the consequent leaves duplicates
	return q;

}