Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   package it.unibz.krdb.obda.owlrefplatform.core.translator;
   
   /*
    * #%L
    * ontop-reformulation-core
    * %%
    * Copyright (C) 2009 - 2014 Free University of Bozen-Bolzano
    * %%
    * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   * 
   *      http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * #L%
   */
  
  
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.Vector;
  
Translate a SPARQL algebra expression into a Datalog program that has the same semantics. We use the built-int predicates Join and Left join. The rules in the program have always 1 or 2 operator atoms, plus (in)equality atoms (due to filters). This programs needs to be flattened by another procedure later.

Author(s):
mariano
 
 
 	
 	private OBDADataFactory ofac = OBDADataFactoryImpl.getInstance();
 
 
 
 	private Map<StringIntegeruriRef = null;
 	private boolean isSI = false;
 	
 		 = templateMatcher;
 	}
 	
 	public void setTemplateMatcher(UriTemplateMatcher templateMatcher) {
 		 = templateMatcher;
 	}
 	
 	
 
 	protected static org.slf4j.Logger log = LoggerFactory
 
 	public DatalogProgram translate(ParsedQuery pqList<Stringsignature) {
 		TupleExpr te = pq.getTupleExpr();
 
 		.debug("SPARQL algebra: \n{}"te);
 
 		// Render the variable names in the signature into Variable object
 		List<Variablevars = new LinkedList<Variable>();
 		for (String vs : signature) {
 			vars.add(.getVariable(vs));
 		}
 		int[] freshvarcount = { 1 };
 
 		translate(varsteresult, 1, freshvarcount);
 		return result;
 	}

Translate a given SPARQL query object to datalog program.

Parameters:
query The Query object.
Returns:
Datalog program that represents the construction of the SPARQL query.
 
 //	public DatalogProgram translate(Query arqQuery, List<String> signature) {
 //
 //		Op op = Algebra.compile(arqQuery);
 //
 //		log.debug("SPARQL algebra: \n{}", op);
 //
 //		DatalogProgram result = ofac.getDatalogProgram();
 //
 //		// Render the variable names in the signature into Variable object
 //		List<Variable> vars = new LinkedList<Variable>();
 //		for (String vs : signature) {
 //			vars.add(ofac.getVariable(vs));
 //		}
 //
 //		int[] freshvarcount = { 1 };
 //
 //		//translate(vars, op, result, 1, freshvarcount);
 //		return result;
 //	}
 
 	private void translate(List<VariablevarsTupleExpr te,
 			DatalogProgram prlong iint[] varcount) {
 		if (te instanceof Slice) {
 
 			// Add LIMIT and OFFSET modifiers, if any
 			Slice slice = (Slicete;
 			translate(varssliceprivarcount);
 
 		} else if (te instanceof Distinct) {
 
 			// Add DISTINCT modifier, if any
 			Distinct distinct = (Distinctte;
 			translate(varsdistinctprivarcount);
 
 		} else if (te instanceof Projection) {
 
 			// Add PROJECTION modifier, if any
 			Projection project = (Projectionte;
 			translate(varsprojectprivarcount);
 
 		} else if (te instanceof Order) {
 
 			// Add ORDER BY modifier, if any
 			Order order = (Orderte;
 			translate(varsorderprivarcount);
 
 		} else if (te instanceof Filter) {
 			Filter filter = (Filterte;
 			translate(varsfilterprivarcount);
 
 		} else if (te instanceof StatementPattern) {
 
 			translate(varsstmpprivarcount);
 
 		} else if (te instanceof Join) {
 			Join join = (Jointe;
 			translate(varsjoinprivarcount);
 
 		} else if (te instanceof Union) {
 			Union union = (Unionte;
 			translate(varsunionprivarcount);
 
 		} else if (te instanceof LeftJoin) {
 			LeftJoin join = (LeftJointe;
 			translate(varsjoinprivarcount);
 		
 		} else if (te instanceof Reduced) {
 			translate(vars, ((Reducedte).getArg(), privarcount);
 		
 		} else if (te instanceof Extension) { 
 			Extension extend = (Extensionte;
 			translate(varsextendprivarcount);
 			
 		} else {
 			try {
 				throw new QueryEvaluationException("Operation not supported: "
 						+ te.toString());
 			} catch (QueryEvaluationException e) {
 				// TODO Auto-generated catch block
 			}
 		}
 	}
 
 	private void translate(List<VariablevarsExtension extend,
 			DatalogProgram prlong iint[] varcount) {
 		TupleExpr subte = extend.getArg();
 		List<ExtensionElemelements = extend.getElements();
 		Set<Variableatom2VarsSet = null;
 		for (ExtensionElem elelements) {
 			Variable var = null;
 			
 			String name = el.getName();
 			ValueExpr vexp = el.getExpr();
 			var = .getVariable(name);
 			
 			Term term = getBooleanTerm(vexp);
 
 			Set<Variableatom1VarsSet = getVariables(subte);
 			List<Termatom1VarsList = new LinkedList<Term>();
 			atom1VarsList.addAll(atom1VarsSet);
 			atom1VarsList.add(var);
 			Collections.sort(atom1VarsList);
 			int indexOfvar = atom1VarsList.indexOf(var);
 			atom1VarsList.set(indexOfvar,term);
 			Predicate leftAtomPred = .getPredicate("ans" + (i),
 					atom1VarsList.size());
 			Function head = .getFunction(leftAtomPredatom1VarsList);
 		
 			atom2VarsSet = getVariables(subte);
 			List<Termatom2VarsList = new LinkedList<Term>();
 			atom2VarsList.addAll(atom2VarsSet);
 			Collections.sort(atom2VarsList);
 			Predicate rightAtomPred = .getPredicate("ans" + ((2 * i)),
 					atom2VarsList.size());
 			Function rightAtom = .getFunction(rightAtomPredatom2VarsList);
 
 			CQIE newrule = .getCQIE(headrightAtom);
 			pr.appendRule(newrule);
 		}
 		/*
 		 * Translating the rest
 		 */
 	
 		{
 			List<Variablevars1 = new LinkedList<Variable>();
 			for (Term var1 : atom2VarsSet)
 				vars1.add((Variablevar1);
 			translate(vars1subtepr, 2 * ivarcount);
 		}
 	}		    
 //		    VarExprList extendExpr = extend.getVarExprList();
 //		    Map<Var, Expr> varmap = extendExpr.getExprs();
 //		    Variable var = null;
 //		    Expr exp = null;
 //		    
 //		    for (Var v: varmap.keySet()){
 //		      String name = v.getVarName();
 //		      var = ofac.getVariable(name);
 //		      exp = varmap.get(v);
 //		    }
 //		    
 //		    Term term = getTermFromExpression(exp);
 //		    
 //		    Set<Variable> atom1VarsSet = getVariables(subop);
 //		    List<Term> atom1VarsList = new LinkedList<Term>();
 //		    atom1VarsList.addAll(atom1VarsSet);
 //		    atom1VarsList.add(var);
 //		    Collections.sort(atom1VarsList, comparator);
 //		    int indexOfvar = atom1VarsList.indexOf(var);
 //		    atom1VarsList.set(indexOfvar,term);
 //		    Predicate leftAtomPred = ofac.getPredicate("ans" + (i),
 //		        atom1VarsList.size());
 //		    Function head = ofac.getFunction(leftAtomPred, atom1VarsList);
 //		
 //		    
 //		    Set<Variable> atom2VarsSet = getVariables(subop);
 //		    List<Term> atom2VarsList = new LinkedList<Term>();
 //		    atom2VarsList.addAll(atom2VarsSet);
 //		    Collections.sort(atom2VarsList, comparator);
 //		    Predicate rightAtomPred = ofac.getPredicate("ans" + ((2 * i)),
 //		        atom2VarsList.size());
 //		    Function rightAtom = ofac.getFunction(rightAtomPred, atom2VarsList);
 //		    
 //		    
 //		    
 //		    CQIE newrule = ofac.getCQIE(head, rightAtom);
 //		    pr.appendRule(newrule);
 //		    
 //		    /*
 //		     * Translating the rest
 //		     */
 //		    {
 //		      List<Variable> vars1 = new LinkedList<Variable>();
 //		      for (Term var1 : atom2VarsSet)
 //		        vars1.add((Variable) var1);
 //		      translate(vars1, subop, pr, 2 * i, varcount);
 //		    }
 
 	
 	private void translate(List<VariablevarsUnion union,
 			DatalogProgram prlong iint[] varcount) {
 		TupleExpr left = union.getLeftArg();
 		TupleExpr right = union.getRightArg();
 
 		/* Preparing the two atoms */
 
 		Set<Variableatom1VarsSet = getVariables(left);
 		List<Termatom1VarsList = new LinkedList<Term>();
 		atom1VarsList.addAll(atom1VarsSet);
 		Collections.sort(atom1VarsList);
 		Predicate leftAtomPred = .getPredicate("ans" + (2 * i),
 				atom1VarsList.size());
 		Function leftAtom = .getFunction(leftAtomPredatom1VarsList);
 
 		Set<Variableatom2VarsSet = getVariables(right);
 		List<Termatom2VarsList = new LinkedList<Term>();
 		atom2VarsList.addAll(atom2VarsSet);
 		Collections.sort(atom2VarsList);
 		Predicate rightAtomPred = .getPredicate("ans" + ((2 * i) + 1),
 				atom2VarsList.size());
 		Function rightAtom = .getFunction(rightAtomPredatom2VarsList);
 
 		/* Preparing the head of the Union rules (2 rules) */
 		// Collections.sort(vars, comparator);
 		List<TermheadVars = new LinkedList<Term>();
 		for (Variable var : vars) {
 			headVars.add(var);
 		}
 		Predicate answerPred = .getPredicate("ans" + ivars.size());
 		Function head = .getFunction(answerPredheadVars);
 
 		/*
 		 * Adding the UNION to the program, i.e., two rules Note, we need to
 		 * make null any head variables that do not appear in the body of the
 		 * uniones, e.g,
 		 * 
 		 * q(x,y,z) <- Union(R(x,y), R(x,z))
 		 * 
 		 * results in
 		 * 
 		 * q(x,y,null) :- ... R(x,y) ... q(x,null,z) :- ... R(x,z) ...
 		 */
 
 		// finding out null
 		Set<VariablenullVars = new HashSet<Variable>();
 		nullVars.addAll(vars);
 		nullVars.removeAll(atom1VarsSet); // the remaining variables do not
 											// appear in the body assigning
 											// null;
 		Map<VariableTermnullifier = new HashMap<VariableTerm>();
 		for (Variable var : nullVars) {
 			nullifier.put(var.);
 		}
 		// making the rule
 		CQIE newrule1 = .getCQIE(headleftAtom);
 		pr.appendRule(Unifier.applyUnifier(newrule1nullifier));
 
 		// finding out null
 		nullVars = new HashSet<Variable>();
 		nullVars.addAll(vars);
 		nullVars.removeAll(atom2VarsSet); // the remaining variables do not
 											// appear in the body assigning
 											// null;
 		nullifier = new HashMap<VariableTerm>();
 		for (Variable var : nullVars) {
 			nullifier.put(var.);
 		}
 		// making the rule
 		CQIE newrule2 = .getCQIE(headrightAtom);
 		pr.appendRule(Unifier.applyUnifier(newrule2nullifier));
 
 		/*
 		 * Translating the rest
 		 */
 		{
 			List<Variablevars1 = new LinkedList<Variable>();
 			for (Term var : atom1VarsList)
 				vars1.add((Variablevar);
 			translate(vars1leftpr, 2 * ivarcount);
 		}
 		{
 			List<Variablevars2 = new LinkedList<Variable>();
 			for (Term var : atom2VarsList)
 				vars2.add((Variablevar);
 			translate(vars2rightpr, 2 * i + 1, varcount);
 		}
 
 	}
 
 	private void translate(List<VariablevarsJoin joinDatalogProgram pr,
 			long iint[] varcount) {
 		TupleExpr left = join.getLeftArg();
 		TupleExpr right = join.getRightArg();
 
 		/* Preparing the two atoms */
 
 		Set<Variableatom1VarsSet = getVariables(left);
 		List<Termatom1VarsList = new LinkedList<Term>();
 		atom1VarsList.addAll(atom1VarsSet);
 		Collections.sort(atom1VarsList);
 		Predicate leftAtomPred = .getPredicate("ans" + (2 * i),
 				atom1VarsList.size());
 		Function leftAtom = .getFunction(leftAtomPredatom1VarsList);
 
 		Set<Variableatom2VarsSet = getVariables(right);
 		List<Termatom2VarsList = new LinkedList<Term>();
 		atom2VarsList.addAll(atom2VarsSet);
 		Collections.sort(atom2VarsList);
 		Predicate rightAtomPred = .getPredicate("ans" + ((2 * i) + 1),
 				atom2VarsList.size());
 		Function rightAtom = .getFunction(rightAtomPredatom2VarsList);
 		/* The join, this is no longer necessary, we will try to avoid explicit joins
 		as much as poosible, just use comma */
 //		Predicate joinp = OBDAVocabulary.SPARQL_JOIN;
 //		Function joinAtom = ofac.getFunction(joinp, leftAtom, rightAtom);
 
 		/* Preparing the head of the Join rule */
 		// Collections.sort(vars, comparator);
 		List<TermheadVars = new LinkedList<Term>();
 		for (Variable var : vars) {
 			headVars.add(var);
 		}
 		Predicate answerPred = .getPredicate("ans" + ivars.size());
 		Function head = .getFunction(answerPredheadVars);
 
 		/*
 		 * Adding the join to the program
 		 */
 
 		CQIE newrule = .getCQIE(headleftAtomrightAtom);
 		pr.appendRule(newrule);
 
 		/*
 		 * Translating the rest
 		 */
 		{
 			List<Variablevars1 = new LinkedList<Variable>();
 			for (Term var : atom1VarsList)
 				vars1.add((Variablevar);
 			translate(vars1leftpr, 2 * ivarcount);
 		}
 		{
 			List<Variablevars2 = new LinkedList<Variable>();
 			for (Term var : atom2VarsList)
 				vars2.add((Variablevar);
 			translate(vars2rightpr, 2 * i + 1, varcount);
 		}
 	}
 
 	private void translate(List<VariablevarsLeftJoin join,
 			DatalogProgram prlong iint[] varcount) {
 		TupleExpr left = join.getLeftArg();
 		TupleExpr right = join.getRightArg();
 		ValueExpr filter = join.getCondition();
 
 		/* Preparing the two atoms */
 
 		Set<Variableatom1VarsSet = getVariables(left);
 		List<Termatom1VarsList = new LinkedList<Term>();
 		atom1VarsList.addAll(atom1VarsSet);
 		Collections.sort(atom1VarsList);
 		Predicate leftAtomPred = .getPredicate("ans" + (2 * i),
 				atom1VarsList.size());
 		Function leftAtom = .getFunction(leftAtomPredatom1VarsList);
 
 		Set<Variableatom2VarsSet = getVariables(right);
 		List<Termatom2VarsList = new LinkedList<Term>();
 		atom2VarsList.addAll(atom2VarsSet);
 		Collections.sort(atom2VarsList);
 		Predicate rightAtomPred = .getPredicate("ans" + ((2 * i) + 1),
 				atom2VarsList.size());
 		Function rightAtom = .getFunction(rightAtomPredatom2VarsList);
 
 		/* The join */
 
 		Function joinAtom = .getFunction(joinpleftAtomrightAtom);
 
 		/* adding the conditions of the filter for the LeftJoin */
 		if (filter != null) {
 		
 			List<TermjoinTerms = joinAtom.getTerms();
 			joinTerms.add(((FunctiongetBooleanTerm(filter)));
 //			for (Expr expr : filter.getList()) {
 //				joinTerms.add(((Function) getBooleanTerm(expr)));
 //			}
 			
 		}
 
 		/* Preparing the head of the LeftJoin rule */
 		// Collections.sort(vars, comparator);
 		List<TermheadVars = new LinkedList<Term>();
 		for (Variable var : vars) {
 			headVars.add(var);
 		}
 		Predicate answerPred = .getPredicate("ans" + ivars.size());
 		Function head = .getFunction(answerPredheadVars);
 
 		/*
 		 * Adding the join to the program
 		 */
 
 		List<Functionatoms = new LinkedList<Function>();
 		atoms.add(joinAtom);
 
 		CQIE newrule = .getCQIE(headatoms);
 		pr.appendRule(newrule);
 
 		/*
 		 * Translating the rest
 		 */
 		{
 			List<Variablevars1 = new LinkedList<Variable>();
 			for (Term var : atom1VarsList)
 				vars1.add((Variablevar);
 			translate(vars1leftpr, 2 * ivarcount);
 		}
 		{
 			List<Variablevars2 = new LinkedList<Variable>();
 			for (Term var : atom2VarsList)
 				vars2.add((Variablevar);
 			translate(vars2rightpr, 2 * i + 1, varcount);
 		}
 	}
 
 	private void translate(List<VariablevarsProjection project,
 			DatalogProgram prlong iint[] varcount) {
 
 		TupleExpr te = project.getArg();
 		Set<VariablenestedVars = getVariables(te);
 
 		List<TermprojectedVariables = new LinkedList<Term>();
 		for (ProjectionElem var : project.getProjectionElemList().getElements()) {
 			projectedVariables.add(.getVariable(var.getSourceName()));
 		}
 
 		Predicate predicate = .getPredicate("ans" + i,
 				projectedVariables.size());
 		Function head = .getFunction(predicateprojectedVariables);
 
 		Predicate pbody = .getPredicate("ans" + (i + 1), nestedVars.size());
 		;
 
 		Set<VariablebodyatomVarsSet = getVariables(te);
 		List<TermbodyatomVarsList = new LinkedList<Term>();
 		bodyatomVarsList.addAll(bodyatomVarsSet);
 		Collections.sort(bodyatomVarsList);
 
 		Function bodyAtom = .getFunction(pbodybodyatomVarsList);
 		CQIE cq = .getCQIE(headbodyAtom);
 		pr.appendRule(cq);
 
 		/* Continue the nested tree */
 
 		vars = new LinkedList<Variable>();
 		for (Term var : bodyatomVarsList) {
 			vars.add((Variablevar);
 		}
 		translate(varstepri + 1, varcount);
 	}
 
 	private void translate(List<VariablevarsSlice slice,
 			DatalogProgram prlong iint[] varcount) {
 		TupleExpr te;
 		te = slice.getArg(); // narrow down the query
 		translate(varsteprivarcount);
 	}
 
 	private void translate(List<VariablevarsDistinct distinct,
 			DatalogProgram prlong iint[] varcount) {
 		TupleExpr te;
 		te = distinct.getArg(); // narrow down the query
 		translate(varsteprivarcount);
 	}
 
 	private void translate(List<VariablevarsOrder order,
 			DatalogProgram prlong iint[] varcount) {
 		TupleExpr te;
 		for (OrderElem c : order.getElements()) {
 			
 			ValueExpr expression = c.getExpr();
 			if (!(expression instanceof Var)) {
 				throw new IllegalArgumentException("Error translating ORDER BY. The current implementation can only sort by variables, this query has a more complex expression. Offending expression: '"+expression+"'");
 			}
 			Var v = (Varexpression;
 			int direction = 0;
 			if (c.isAscending()) direction = 1;
 			pr.getQueryModifiers().addOrderCondition(vardirection);
 		}
 		te = order.getArg(); // narrow down the query
 		translate(varsteprivarcount);
 	}
 
 	public void translate(List<VariablevarFilter filterDatalogProgram pr,
 			long iint varcount[]) {
 		ValueExpr condition = filter.getCondition();
 		List<FunctionfilterAtoms = new LinkedList<Function>();
 		Set<VariablefilteredVariables = new LinkedHashSet<Variable>();
 
 			Function a = null;
 			if (condition instanceof Var) {
 			} else {
 				a = (FunctiongetBooleanTerm(condition);
 			}
 			if (a != null) {
 						a.getTerms());
 				filterAtoms.add(filterAtom);
 				filteredVariables.addAll(filterAtom.getReferencedVariables());
 			}
 
 		Predicate predicate = .getPredicate("ans" + (i), var.size());
 		List<Termvars = new LinkedList<Term>();
 		vars.addAll(var);
 		Function head = .getFunction(predicatevars);
 
 		Predicate pbody;
 		Function bodyAtom;
 
 		List<TerminnerProjection = new LinkedList<Term>();
 		innerProjection.addAll(filteredVariables);
 		Collections.sort(innerProjection);

This is necessary because some filters might apply to variables that have not been projected yet, for example:

(filter (= ?x 99)
<t> (bgp (triple <http://example/x> <http://example/p> ?x)))

in this cases we must project at least the filtered variables from the nested expressions, otherwise we endup with free variables.

 
 
 		// TODO here we might be missing the case where there is a filter
 		// on a variable that has not been projected out of the inner
 		// expressions
 		if (vars.size() == 0 && filteredVariables.size() > 0) {
 			pbody = .getPredicate("ans" + (i * 2), innerProjection.size());
 			bodyAtom = .getFunction(pbodyinnerProjection);
 		} else {
 			pbody = .getPredicate("ans" + (i * 2), vars.size());
 			bodyAtom = .getFunction(pbodyvars);
 		}
 
 		LinkedList<Functionbody = new LinkedList<Function>();
 		body.add(bodyAtom);
 		body.addAll(filterAtoms);
 
 		CQIE cq = .getCQIE(headbody);
 		pr.appendRule(cq);
 
 		TupleExpr sub = filter.getArg();
 
 		if (vars.size() == 0 && filteredVariables.size() > 0) {
 			List<Variablenewvars = new LinkedList<Variable>();
 			for (Term l : innerProjection)
 				newvars.add((Variablel);
 			translate(newvarssubpr, (i * 2), varcount);
 		} else
 			translate(varsubpr, (i * 2), varcount);
 
 	}

This translates a single triple. In most cases it will generate one single atom, however, if URI's are present, it will generate also equality atoms.

Parameters:
triple
Returns:
 
 	public void translate(List<VariablevarsStatementPattern triple,
 			DatalogProgram prlong iint[] varcount) {
 		
 		Var obj = triple.getObjectVar();
 		Var pred = triple.getPredicateVar();
 		Var subj = triple.getSubjectVar();
 		
 		Value o = obj.getValue();
 		Value p = pred.getValue();
 		Value s = subj.getValue();
 		
 		if (!(p instanceof URIImpl || (p == null))) {
 			// if predicate is a variable or literal
 			throw new RuntimeException("Unsupported query syntax");
 		}
 
 		LinkedList<Functionresult = new LinkedList<Function>();
 
 		// Instantiate the subject and object URI
 		String subjectUri = null;
 		String objectUri = null;
 		String propertyUri = null;
 
 		// Instantiate the subject and object data type
 		COL_TYPE subjectType = null;
 		COL_TYPE objectType = null;
 
 		// / Instantiate the atom components: predicate and terms.
 		Predicate predicate = null;
 		Vector<Termterms = new Vector<Term>();
 
 		if (p instanceof URIImpl && p.toString().equals(..stringValue())) {
 			// Subject node
 			
 			terms.add(getOntopTerm(subjs));
 			
 
 			// Object node
 			if (o == null) {
 
 
 				Function rdfTypeConstant = .getFunction(
 				terms.add(rdfTypeConstant);
 				terms.add(.getVariable(obj.getName()));
 
 			} else if (o instanceof LiteralImpl) {
 				throw new RuntimeException("Unsupported query syntax");
 			} else if (o instanceof URIImpl) {
 				URIImpl object = (URIImplo;
 				objectUri = object.stringValue();
 			}
 
 			// Construct the predicate
 			String predicateUri = objectUri;
 			if (predicateUri == null) {
 				// NO OP, already assigned
 			} else if (predicateUri.equals(
 			} else if (predicateUri.equals(
 				predicate = .;
 			} else if (predicateUri.equals(
 			} else if (predicateUri.equals(
 				predicate = .;
 			} else if (predicateUri.equals(
 				predicate = .;
 			} else if (predicateUri.equals(
 				predicate = .;
 			} else if (predicateUri.equals(
 				predicate = .;
 			} else if (predicateUri.equals(
 				predicate = .;
 			} else if (predicateUri.equals(
 				predicate = .;
 			} else {
 
 				predicate = .getPredicate(predicateUri, 1,
 						new COL_TYPE[] { subjectType });
 
 			}
 
 		} else {
 			/*
 			 * The predicate is NOT rdf:type
 			 */
 
 			
 			terms.add(getOntopTerm(subjs));
 
 			terms.add(getOntopTerm(obj,o,));
 			
 			// Construct the predicate
 
 			if (p instanceof URIImpl) {
 				String predicateUri = p.stringValue();
 				predicate = .getPredicate(predicateUri, 2, new COL_TYPE[] {
 						subjectTypeobjectType });
 			} else if (p == null) {
 				terms.add(1, .getVariable(pred.getName()));
 			}
 		}
 		// Construct the atom
 		Function atom = .getFunction(predicateterms);
 		result.addFirst(atom);
 
 		// Collections.sort(vars, comparator);
 		List<Termnewvars = new LinkedList<Term>();
 		for (Variable var : vars) {
 			newvars.add(var);
 		}
 
 		Predicate answerPred = .getPredicate("ans" + ivars.size());
 		Function head = .getFunction(answerPrednewvars);
 
 		CQIE newrule = .getCQIE(headresult);
 		pr.appendRule(newrule);
 	}
 	
 	private Term getOntopTerm(Var subjValue sboolean isSI) {
 		Term result = null;
 		if (s == null) {
 			result = .getVariable(subj.getName());
 		} else if (s instanceof LiteralImpl) {
 			LiteralImpl object = (LiteralImpls;
 			COL_TYPE objectType = getDataType(object);
 			ValueConstant constant = getConstant(object);
 
 			// v1.7: We extend the syntax such that the data type of a
 			// constant
 			// is defined using a functional symbol.
 			Function dataTypeFunction = null;
 			if (objectType == .) {
 				// If the object has type LITERAL, check any language
 				// tag!
 				String lang = object.getLanguage();
 				if (lang != nulllang = lang.toLowerCase();
 				Predicate functionSymbol = 
 				Constant languageConstant = null;
 				if (lang != null && !lang.equals("")) {
 					languageConstant = .getConstantLiteral(lang,
 					dataTypeFunction = .getFunction(
 							functionSymbolconstantlanguageConstant);
 					result = dataTypeFunction;
 				} else {
 					dataTypeFunction = .getFunction(
 							functionSymbolconstant);
 					result = dataTypeFunction;
 				}
 			} else {
 				// For other supported data-types
 				Predicate functionSymbol = getDataTypePredicate(objectType);
 				dataTypeFunction = .getFunction(functionSymbol,
 						constant);
 				resultdataTypeFunction;
 			}
 		} else if (s instanceof URIImpl) {
 			URIImpl subject = (URIImpls;
 			COL_TYPE subjectType = .;
 			
 			String subject_URI = subject.stringValue();
 			subject_URI = decodeURIEscapeCodes(subject_URI);
 			
 
 			if (isSI) {
 				int id = indexOfRef(s.stringValue());
 				result = functionURI;
 			} else {
 				Function functionURI = .generateURIFunction(subject_URI);
 				result = functionURI;
 			}
 		}
 		
 		return result;
 	}

Given a string representing a URI, this method will return a new String in which all percent encoded characters (e.g., %20) will be restored to their original characters (e.g., ' '). This is necessary to transform some URIs into the original dtabase values.

Parameters:
uriStr
Returns:
 
 	private String decodeURIEscapeCodes(String encodedURI) {
 		int length = encodedURI.length();
 		StringBuilder strBuilder = new StringBuilder(length+20);
 		
 		char[] codeBuffer = new char[2];
 		
 		for (int ci = 0; ci < lengthci++) {
 			char c = encodedURI.charAt(ci);
 
 			if (c != '%') {
 				// base case, the character is a normal character, just
 				// append
 				strBuilder.append(c);
 				continue;
 			}
 
 			/*
 			 * found a escape, processing the code and replacing it by
 			 * the original value that should be found on the DB. This
 			 * should not be used all the time, only when working in
 			 * virtual mode... we need to fix this with a FLAG.
 			 */
 
 			// First we get the 2 chars next to %
 			codeBuffer[0] = encodedURI.charAt(ci + 1);
 			codeBuffer[1] = encodedURI.charAt(ci + 2);
 
 			// now we check if they match any of our escape wodes, if
 			// they do the char to be inserted is put in codeBuffer
 			// otherwise
 			String code = String.copyValueOf(codeBuffer);
 			if (code.equals("%20")) {
 				strBuilder.append(' ');
 			} else if (code.equals("%21")) {
 				strBuilder.append('!');
 			} else if (code.equals("%40")) {
 				strBuilder.append('@');
 			} else if (code.equals("%23")) {
 				strBuilder.append('#');
 			} else if (code.equals("%24")) {
 				strBuilder.append('$');
 			} else if (code.equals("%26")) {
 				strBuilder.append('&');
 			} else if (code.equals("%42")) {
 				strBuilder.append('*');
 			} else if (code.equals("%28")) {
 				strBuilder.append('(');
 			} else if (code.equals("%29")) {
 				strBuilder.append(')');
 			} else if (code.equals("%5B")) {
 				strBuilder.append('[');
 			} else if (code.equals("%5C")) {
 				strBuilder.append(']');
 			} else if (code.equals("%2C")) {
 				strBuilder.append(',');
 			} else if (code.equals("%3B")) {
 				strBuilder.append(';');
 			} else if (code.equals("%3A")) {
 				strBuilder.append(':');
 			} else if (code.equals("%3F")) {
 				strBuilder.append('?');
 			} else if (code.equals("%3D")) {
 				strBuilder.append('=');
 			} else if (code.equals("%2B")) {
 				strBuilder.append('+');
 			} else if (code.equals("%22")) {
 				strBuilder.append('\'');
 			} else if (code.equals("%2F")) {
 				strBuilder.append('/');
 			} else {
 				// This was not an escape code, so we just append the
 				// characters and continue;
 				strBuilder.append(codeBuffer);
 			}
 			ci += 2;
 
 		}
 		return strBuilder.toString();
 
 	}
 
	private int indexOfRef(String uri) {
		Integer index =  this..get(uri);
		if (index != null)
			return index;
		return -2;
	private class TermComparator implements Comparator<Term> {
		public int compare(Term arg0Term arg1) {
			return arg0.toString().compareTo(arg1.toString());
		Set<Variablevars = new HashSet<Variable>();
		for (org.openrdf.query.algebra.Var variable : list) {
			if (!variable.hasValue()) { // if it has value, then its a constant
				String name = variable.getName();
				Variable var = .getVariable(name);
				vars.add(var);
		return vars;
		Set<Variablevars = new HashSet<Variable>();
		for (ExtensionElem el : elements) {
				String name = el.getName();
				Variable var = .getVariable(name);
				vars.add(var);
		return vars;
		Set<Variableresult = new LinkedHashSet<Variable>();
		if (te instanceof StatementPattern) {
else if (te instanceof BinaryTupleOperator) {
else if (te instanceof UnaryTupleOperator) {
				if (te instanceof Extension) {
else {
			throw new RuntimeException("Operator not supported: " + te);
		return result;
	private Variable getFreshVariable(int[] count) {
		count[0] += 1;
		return .