Java ExprVar类代码示例

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
public void visit(ExprVar var)
{
	logger.debug("visit ExprVar " + var);
	
	if (!convertable) {
		expression.push(Expression.FALSE); // prevent stack empty exceptions when conversion
		return;                            // fails in the middle of a multi-arg operator conversion
	}
	
	String varName = var.getVarName();
	
	// if expression contains a blank node, no conversion to sql can be done
	if (Var.isBlankNodeVarName(varName)) {
		conversionFailed("blank nodes not supported", var);
		return;
	}
	
	List<Expression> expressions = toExpression(var);
	if (expressions.size() == 1) {
		expression.push(expressions.get(0));
	} else {
		// no single sql-column for sparql-var does exist break up conversion
		// (the case for Pattern ValueMakers)
		conversionFailed("multi column pattern valuemakers not supported", var);
	}
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
public void testLang()
{
	List<Triple> pattern = new ArrayList<Triple>();
	pattern.add(Triple.create(Node.createVariable("s"), RDFS.label.asNode(), Node.createVariable("o")));
	NodeRelation[] rels = translate(pattern, "optimizer/filtertests.n3");
	
	NodeRelation label_fr_be  = search("table1", "label_fr_be", rels);
	NodeRelation label_en     = search("table1", "label_en", rels);
	NodeRelation label_noLang = search("table1", "label", rels);
	
	Expr filterFR    = new E_Equals(new E_Lang(new ExprVar("o")), NodeValue.makeString("fr"));
	Expr filterEN_TAG_EN = new E_Equals(new E_Lang(new ExprVar("o")), NodeValue.makeNode("en", "en", (String) null));
	Expr filterFR_BE = new E_Equals(new E_Lang(new ExprVar("o")), NodeValue.makeString("fr-BE"));
	Expr filter      = new E_Equals(new E_Lang(new ExprVar("o")), NodeValue.makeString(""));
	
	assertEquals("LANG(label_fr_be) = \"fr\" should be FALSE",   Expression.FALSE, TransformExprToSQLApplyer.convert(filterFR, label_fr_be));
	assertEquals("LANG(label_en) = \"fr\" should be FALSE",      Expression.FALSE, TransformExprToSQLApplyer.convert(filterFR, label_en));
	assertEquals("LANG(label_fr_be) = \"fr_be\" should be TRUE", Expression.TRUE,  TransformExprToSQLApplyer.convert(filterFR_BE, label_fr_be));
	assertEquals("LANG(label_en) = \"en\"@en should be FALSE",   Expression.FALSE, TransformExprToSQLApplyer.convert(filterEN_TAG_EN, label_en));
	assertEquals("LANG(label_noLang) = \"\" should be TRUE",     Expression.TRUE,  TransformExprToSQLApplyer.convert(filter, label_noLang));
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
public void testDataType()
{
	List<Triple> pattern = new ArrayList<Triple>();
	pattern.add(Triple.create(Node.createVariable("s"), Node.createURI("http://example.org/value"), Node.createVariable("o")));
	NodeRelation[] rels = translate(pattern, "optimizer/filtertests.n3");
	
	NodeRelation intvalue = search("table2", "intvalue", rels);
	NodeRelation value = search("table2", "value", rels);
	
	pattern.clear();
	pattern.add(Triple.create(Node.createVariable("s"), RDFS.label.asNode(), Node.createVariable("o")));
	rels = translate(pattern, "optimizer/filtertests.n3");
	
	NodeRelation langliteral = search("table1", "label_en", rels);
	
	Expr filterint    = new E_Equals(new E_Datatype(new ExprVar("o")), NodeValueNode.makeNode(Node.createURI(XSDDatatype.XSDint.getURI())));
	Expr filterstring = new E_Equals(new E_Datatype(new ExprVar("o")), NodeValueNode.makeNode(Node.createURI(XSDDatatype.XSDstring.getURI())));
	
	assertEquals("DATATYPE(intliteral) = xsd:int should be TRUE",       Expression.TRUE, TransformExprToSQLApplyer.convert(filterint, intvalue));
	assertEquals("DATATYPE(simpleliteral) = xsd:string should be TRUE", Expression.TRUE, TransformExprToSQLApplyer.convert(filterstring, value));
	assertEquals("DATATYPE(langliteral) = xsd:string should be TRUE",   Expression.TRUE, TransformExprToSQLApplyer.convert(filterstring, langliteral));
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
public void testDisjunction()
{
	List<Triple> pattern = new ArrayList<Triple>();
	pattern.add(Triple.create(Node.createVariable("s"), Node.createURI("http://example.org/value"), Node.createVariable("o")));
	NodeRelation[] rels = translate(pattern, "optimizer/filtertests.n3");
	
	NodeRelation intvalue = search("table2", "intvalue", rels);

	Expr disjunction = new E_LogicalOr(new E_Equals(new ExprVar("o"),  NodeValue.makeNode("1", XSDDatatype.XSDint)), new E_Equals(new ExprVar("o"), NodeValue.makeNode("2", XSDDatatype.XSDint)));
	
	Expression result = TransformExprToSQLApplyer.convert(disjunction, intvalue);
	TypedNodeMaker nm = (TypedNodeMaker) intvalue.nodeMaker(Var.alloc("o"));
	Expression e1 = nm.valueMaker().valueExpression("1");
	Expression e2 = nm.valueMaker().valueExpression("2");
	Expression expected = e1.or(e2);
	
	assertEquals("?o = \"1\"^^xsd:int || ?o = \"2\"^^xsd:int", expected, result);
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
@Override
public Var evaluate(NodeSelector nodeSelector, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) {
    TestingSelector testingSelector = (TestingSelector) nodeSelector;
    FunctionTest functionTest = (FunctionTest) testingSelector.getTest();

    if(functionTest.getArgSelectors().get(0) instanceof PropertySelector) {
        PropertySelector arg = (PropertySelector) functionTest.getArgSelectors().get(0);
        PropertySelector delegate = (PropertySelector) testingSelector.getDelegate();

        Var target = Var.alloc(VarIDGenerator.createID());
        elementGroup.addTriplePattern(new Triple(var.asNode(), NodeFactory.createURI(delegate.getProperty().toString()), target));

        Var selector = Var.alloc(VarIDGenerator.createID());
        elementGroup.addTriplePattern(new Triple(target.asNode(), NodeFactory.createURI(arg.getProperty().toString()), selector.asNode()));

        elementGroup.addElementFilter(new ElementFilter(new E_IsLiteral(new ExprVar(selector))));

        return selector;
    } else {
        throw new IllegalStateException("Argument of function isLiteral has to be a PropertySelector");
    }
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
public static E_StrConcatPermissive parseTemplate(String str) {
    ExprList args = new ExprList();

    while (!str.isEmpty()) {
        if (str.contains("{") && str.contains("}")) {
            int openIdx = str.indexOf('{');
            int closeIdx = str.indexOf('}');
            int strLen = str.length();

            if (openIdx > 0) {
                args.add(NodeValue.makeString(str.substring(0, openIdx)));
            }

            String varName = str.substring(openIdx+1, closeIdx);
            args.add(new ExprVar(Var.alloc(varName)));

            str = str.substring(closeIdx+1, strLen);

        } else {
            args.add(NodeValue.makeString(str));
            str = "";
        }
    }

    return new E_StrConcatPermissive(args);
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
final public Expr VarOrFunction() throws ParseException {
                       Var v ; ExprList a = null ;
  v = Var();
  Expr ev = new ExprVar(v) ;
  switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
  case LPAREN:
  case NIL:
    a = ExpressionList();
    break;
  default:
    jj_la1[164] = jj_gen;
    ;
  }
  if ( a == null ) {if (true) return ev ;}
  {if (true) return new E_FunctionDynamic(ev, a) ;}
  throw new Error("Missing return statement in function");
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
@Override
public Expr evaluate(NodeTest nodeTest, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) {
    IsATest isATest = (IsATest) nodeTest;
    Var tmpVar = Var.alloc(Var.alloc(VarIDGenerator.createID()));
    elementGroup.addTriplePattern(new Triple(var.asNode(), RDF.type.asNode(), tmpVar.asNode()));
    return new E_Equals(new ExprVar(tmpVar.asNode()), new NodeValueNode(NodeFactory.createURI(isATest.getPathExpression(new SesameValueBackend()).replace("<", "").replace(">", "").replaceFirst("is-a ", ""))));
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
@Override
public Expr evaluate(NodeTest nodeTest, ElementGroup elementGroup, Var var, LDPathEvaluatorConfiguration evaluatorConfiguration) {
    PathEqualityTest pathEqualityTest = (PathEqualityTest) nodeTest;
    Var tmpVar =  LDPathEvaluator.evaluate(pathEqualityTest.getPath(), elementGroup, var, evaluatorConfiguration);
    if(pathEqualityTest.getNode() instanceof org.openrdf.model.impl.LiteralImpl) {
        return new E_Equals(new ExprVar(tmpVar.asNode()), new NodeValueNode(NodeFactory.createLiteral(((LiteralImpl) pathEqualityTest.getNode()).getLabel().toString())));
    } else {
        return new E_Equals(new ExprVar(tmpVar.asNode()), new NodeValueNode(NodeFactory.createURI(pathEqualityTest.getNode().toString())));
    }
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
public Set<ViewQuad<ViewDefinition>> getViewCandidates(Triple triple) {
	Var g = Var.alloc("g");
	Var s = Var.alloc("s");
	Var p = Var.alloc("p");
	Var o = Var.alloc("o");

	Node gv = Quad.defaultGraphNodeGenerated;
	Node sv = triple.getSubject();
	Node pv = triple.getPredicate();
	Node ov = triple.getObject();
	
	Quad tmpQuad = new Quad(g, s, p, o);
	
	RestrictionManagerImpl r = new RestrictionManagerImpl();
	
	Set<Clause> clauses = new HashSet<Clause>();
	clauses.add(new Clause(new E_Equals(new ExprVar(g), NodeValue.makeNode(gv))));
	clauses.add(new Clause(new E_Equals(new ExprVar(s), NodeValue.makeNode(sv))));
	clauses.add(new Clause(new E_Equals(new ExprVar(p), NodeValue.makeNode(pv))));
	clauses.add(new Clause(new E_Equals(new ExprVar(o), NodeValue.makeNode(ov))));

	NestedNormalForm nnf = new NestedNormalForm(clauses);
	
	r.stateCnf(nnf);
	
	Set<ViewQuad<ViewDefinition>> result = candidateSelector.findCandidates(tmpQuad, r);
	
	return result;
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
@Override
public Op transform(OpFilter opFilter, Op subOp) {

	ExprList substitutedExprList = new ExprList();
	
	for (Expr expr: opFilter.getExprs().getList()){
		Map<String, Expr> substitutions = new HashMap<String, Expr>();
		//for each expression see if it contains variables that are not mentioned within this clause
		for (Var var: expr.getVarsMentioned()){
			QueryVar mentionedQueryVar=this.mentionedVars.get(var);
			if (mentionedQueryVar==null) {
				//No mentioned variables so filter not relevant
				return subOp;
			}else
			{
				//Mentioned so add the new name to the substitutions set.
				Var substitutedVar = Var.alloc(mentionedQueryVar.getLinkedName(this.queryClause.getDataset()));
				substitutions.put(var.getName(), new ExprVar(substitutedVar));
			}
		}
		//Only get here if all vars mentioned in expression are within clause
	
		ExprTransformSubstitute exprTransformSubstitute = new ExprTransformSubstitute(	substitutions );
		Expr substitutedExpression = (Expr) ExprTransformer.transform(exprTransformSubstitute, expr);
		substitutedExprList.add(substitutedExpression);
	}
	return OpFilter.filter(substitutedExprList, subOp);
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
private ElementFilter createFilter(SparqlNodes label, SparqlNodes scheme) {
  return use(new SparqlUriExpression(new ExprVar(QUERIED_CONCEPT)).create(concept))//
      .and(
          createMultipleOptionsExpression(new SparqlLanguageExpression(label), getLanguages()),
          !getLanguages().isEmpty())
      .and(
          createMultipleOptionsExpression(new SparqlUriExpression(scheme), getSchemas()),
          !getSchemas().isEmpty())
      .toElementFilter();
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
@Override
public void visit(ExprVar nv) {
	log(nv);
	this.shadowed=nv;
	if(LOGGER.isDebugEnabled()) {
		LOGGER.debug(String.format("Shadowing detected: %s shadows %s",var,nv));
	}
}
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
@Override
   public void visit(ExprVar nv) {
nv.visit(visitor);
   }
 

import com.hp.hpl.jena.sparql.expr.ExprVar; //导入依赖的package包/类
private static Op subst(Op subOp , ExprVar var1, ExprVar var2) {
    // Replace var2 with var1
    Op op = Substitute.substitute(subOp, var2.asVar(), var1.asVar());
    // Insert LET(var2:=var1)
    return OpAssign.assign(op, var2.asVar(), var1);
}