public static void addConstantConstraint(Map<Var, NodeValue> map, Var var, NodeValue nodeValue) { if(map.containsKey(var)) { NodeValue oldValue = map.get(var); if(oldValue != null && !oldValue.equals(nodeValue)) { map.put(var, null); } } else { map.put(var, nodeValue); } }
@Override public boolean equals(Object obj) { if ( this == obj ) return true; if ( obj == null ) return false; if ( getClass() != obj.getClass() ) return false; NV other = (NV)obj; if ( nv == null ) { if ( other.nv != null ) return false; } else if ( !nv.equals(other.nv) ) return false; return true; } }
public String _serialize(NodeValue nodeValue) { if(nodeValue.equals(NodeValue.nvNothing)) { return "NULL "; } // TODO Handle this correctly String result = nodeValue.asUnquotedString(); return result; }
public static Set<Set<Expr>> toSetCnf(Expr expr) { Set<Set<Expr>> result; if(NodeValue.TRUE.equals(expr)) { result = new HashSet<>(); // Return a new set, as callers may want to extend the set//Collections.emptySet(); } else { List<ExprList> clauses = toClauses(expr); result = FilterUtils.toSets(clauses); } return result; }
/** * Whether a triple matches any of the ingoing or outgoing filter expression of this node * @param triple * @param functionEnv * @return */ // public boolean contains(Triple triple, FunctionEnv functionEnv) { // Set<Expr> exprs = Sets.union(outgoing.keySet(), ingoing.keySet()); // // boolean result = contains(exprs, triple, functionEnv); // return result; // } public static boolean contains(Collection<Expr> exprs, Triple triple, FunctionEnv functionEnv) { Binding binding = TripleUtils.tripleToBinding(triple); boolean result = false; for(Expr expr : exprs) { NodeValue nodeValue = expr.eval(binding, functionEnv); if(nodeValue.equals(NodeValue.TRUE)) { result = true; break; } } return result; }
public ExprList compactConjuction(ExprList exprs) { ExprList result = new ExprList(); for(Expr expr : exprs) { if(expr.isConstant()) { NodeValue nv = expr.getConstant(); if(NodeValue.FALSE.equals(nv)) { // FIXME Optimize away the creation of a new list result = new ExprList(); result.add(NodeValue.FALSE); return result; } else if(NodeValue.TRUE.equals(nv)) { continue; } result.add(expr); } } return result; }
/** * Expand any filter according to any prior extend * * @param exprHolder * @return */ public DistinctExtendFilter2 applyFilter(Expr contribExpr) { // Validation: Make sure all mentioned variables are projected Set<Var> mentionedVars = contribExpr.getVarsMentioned(); Set<Var> availableVars = isDistinct ? postDistinctVarDefs == null ? null : postDistinctVarDefs.keySet() : preDistinctVarDefs == null ? null : preDistinctVarDefs.keySet() ; Set<Var> errVars = Sets.difference(mentionedVars, availableVars); if(!errVars.isEmpty()) { throw new RuntimeException("Reference to unavailable vars: " + errVars + ", available: " + availableVars); } Expr expandedExpr = expandExpr(contribExpr); Expr currentExpr = filter.getExpr(); Expr expr = NodeValue.TRUE.equals(currentExpr) ? expandedExpr : new E_LogicalAnd(currentExpr, expandedExpr); // perform a logical AND with the given filters ExprHolder eh = ExprHolder.from(expr); this.filter = eh; return this; }
/** * Expand any filter according to any prior extend * * @param exprHolder * @return */ public DistinctExtendFilter2 applyFilter(Expr contribExpr) { // Validation: Make sure all mentioned variables are projected Set<Var> mentionedVars = contribExpr.getVarsMentioned(); Set<Var> availableVars = isDistinct ? postDistinctVarDefs == null ? null : postDistinctVarDefs.keySet() : preDistinctVarDefs == null ? null : preDistinctVarDefs.keySet() ; Set<Var> errVars = Sets.difference(mentionedVars, availableVars); if(!errVars.isEmpty()) { throw new RuntimeException("Reference to unavailable vars: " + errVars + ", available: " + availableVars); } Expr expandedExpr = expandExpr(contribExpr); Expr currentExpr = filter.getExpr(); Expr expr = NodeValue.TRUE.equals(currentExpr) ? expandedExpr : new E_LogicalAnd(currentExpr, expandedExpr); // perform a logical AND with the given filters ExprHolder eh = ExprHolder.from(expr); this.filter = eh; return this; }
@Override public void visit(NodeValue nv) { if ( ! target.isConstant() ) throw new NoExprMatch("Not a NodeValue") ; if ( ! nv.equals(target.getConstant()) ) throw new NoExprMatch("Different value: "+nv+" & "+target.getConstant()) ; }
public static void collectOr(Expr expr, List<ExprList> list) { if(expr instanceof E_LogicalOr) { E_LogicalOr e = (E_LogicalOr)expr; collectOr(e.getArg1(), list); collectOr(e.getArg2(), list); } else if(expr instanceof E_LogicalAnd) { //List<Expr> ors = new ArrayList<Expr>(); ExprList ors = new ExprList(); collectAnd(expr, ors); list.add(ors); } else { ExprList tmp = new ExprList(); // Turn true into empty clause if(!NodeValue.TRUE.equals(expr)) { tmp.add(expr); } list.add(tmp); } }
@Override public NodeValue eval(NodeValue v) if ( lastSeen != null && lastSeen.equals(v) ) return lastCalc ;
@Test public void testNotEquals2() { NodeValue nv1 = NodeValue.makeNodeInteger(1); NodeValue nv2 = NodeValue.makeNodeString("1"); assertFalse("NodeValue.equals()", nv1.equals(nv2)); }
@Test public void testNotEquals1() { NodeValue nv1 = NodeValue.makeInteger(1); NodeValue nv2 = NodeValue.makeInteger(2); assertFalse("NodeValue.equals()", nv1.equals(nv2)); }
@Test public void testLangMatches2() { NodeValue nv = NodeValue.makeString("en") ; NodeValue pat = NodeValue.makeString("fr") ; NodeValue r = NodeFunctions.langMatches(nv, pat) ; assertEquals(NodeValue.FALSE, r) ; assertFalse(NodeValue.TRUE.equals(r)) ; }
@Test public void testNotEquals3() { // Literals and URIs are different. NodeValue nv1 = NodeValue.makeNode(org.apache.jena.graph.NodeFactory.createURI("http://example")); NodeValue nv2 = NodeValue.makeNode(org.apache.jena.graph.NodeFactory.createLiteral("http://example")); assertFalse("NodeValue.equals()", nv1.equals(nv2)); } }
@Test public void testLangMatches1() { NodeValue nv = NodeValue.makeString("en") ; NodeValue pat = NodeValue.makeString("en") ; NodeValue r = NodeFunctions.langMatches(nv, pat) ; assertEquals(NodeValue.TRUE, r) ; assertFalse(NodeValue.FALSE.equals(r)) ; }
@Test public void testLang4() { Node n1 = org.apache.jena.graph.NodeFactory.createLiteral("xyz", "en"); NodeValue nv1 = NodeValue.makeNode(n1); Node n2 = org.apache.jena.graph.NodeFactory.createLiteral("xyz", "EN"); NodeValue nv2 = NodeValue.makeNode(n2); assertFalse(NodeValue.notSameAs(nv1, nv2)); assertFalse(nv1.equals(nv2)); }
@Test public void testLang2() { Node n1 = org.apache.jena.graph.NodeFactory.createLiteral("xyz", "en"); NodeValue nv1 = NodeValue.makeNode(n1); Node n2 = org.apache.jena.graph.NodeFactory.createLiteral("xyz", "EN"); NodeValue nv2 = NodeValue.makeNode(n2); assertTrue(NodeValue.sameAs(nv1, nv2)); assertFalse(nv1.equals(nv2)); }