org.aksw.jena_sparql_api.utils

Class FilterUtils

java.lang.Object

org.aksw.jena_sparql_api.utils.FilterUtils

public class FilterUtils
extends Object

Constructor Summary

Constructors

Constructor and Description
FilterUtils()

Method Summary

Methods

Modifier and Type	Method and Description
static void	addValueToSample(org.aksw.commons.collections.Sample<com.hp.hpl.jena.sparql.expr.NodeValue> sample, com.hp.hpl.jena.sparql.expr.NodeValue nodeValue, boolean isNegative)
static com.hp.hpl.jena.sparql.expr.ExprList	collectExprs(com.hp.hpl.jena.sparql.algebra.Op op, com.hp.hpl.jena.sparql.expr.ExprList result)
static Set<Set<com.hp.hpl.jena.sparql.expr.Expr>>	determineFilterDnf(com.hp.hpl.jena.sparql.core.Quad quad, Set<Set<com.hp.hpl.jena.sparql.expr.Expr>> dnf) Given a quad and a predicate expression in DNF, determine if any of the expressions only containing variables of the quad are a "notwendige bedingung" on the pattern.
static com.hp.hpl.jena.sparql.expr.Expr	determineFilterExpr(com.hp.hpl.jena.sparql.core.Quad quad, Set<Set<com.hp.hpl.jena.sparql.expr.Expr>> dnf)
static org.aksw.commons.util.Pair<com.hp.hpl.jena.sparql.core.Var,com.hp.hpl.jena.sparql.expr.NodeValue>	extractValueConstraint(com.hp.hpl.jena.sparql.expr.Expr expr)
static Map<com.hp.hpl.jena.sparql.core.Var,ValueSet<com.hp.hpl.jena.sparql.expr.NodeValue>>	extractValueConstraintsDnf(Set<Set<com.hp.hpl.jena.sparql.expr.Expr>> dnf) Searches for expression of the form ?var = const TODO We are not considering equals between variables.
static Map<com.hp.hpl.jena.sparql.core.Var,ValueSet<com.hp.hpl.jena.sparql.expr.NodeValue>>	extractValueConstraintsDnfClause(Set<com.hp.hpl.jena.sparql.expr.Expr> dnfClause)
static <T> Set<T>	intersection(Set<T> a, Set<T> b) Intersection where set 'a' may be null.
static boolean	isDnfClauseSubsumed(Set<com.hp.hpl.jena.sparql.expr.Expr> clauseA, Set<com.hp.hpl.jena.sparql.expr.Expr> clauseB)
static boolean	isDnfSubsumed(Set<Set<com.hp.hpl.jena.sparql.expr.Expr>> clausesA, Set<Set<com.hp.hpl.jena.sparql.expr.Expr>> clausesB) Return true if a is subsumed by b which means whenever a is true, b will be true You may need Expr x = originalExpr.copySubstitute(binding); to rename the variables and thus make the expressions equal.
boolean	isUnsatsfiable(com.hp.hpl.jena.sparql.expr.Expr expr, com.hp.hpl.jena.sparql.engine.binding.Binding partialBinding) A test to check if the given predicate expression would yield false with the given, potentially partial, binding.
static Set<Set<com.hp.hpl.jena.sparql.expr.Expr>>	toSets(List<com.hp.hpl.jena.sparql.expr.ExprList> clauses)
static ValueSet<com.hp.hpl.jena.sparql.expr.NodeValue>	toValueSet(org.aksw.commons.collections.Sample<com.hp.hpl.jena.sparql.expr.NodeValue> sample) Returns true if it was cleaned, or false if the clause was unsatisfiable
static <T> Set<T>	union(Set<T> a, Set<T> b)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

FilterUtils

public FilterUtils()

Method Detail

determineFilterExpr

public static com.hp.hpl.jena.sparql.expr.Expr determineFilterExpr(com.hp.hpl.jena.sparql.core.Quad quad,
                                                   Set<Set<com.hp.hpl.jena.sparql.expr.Expr>> dnf)

extractValueConstraint

public static org.aksw.commons.util.Pair<com.hp.hpl.jena.sparql.core.Var,com.hp.hpl.jena.sparql.expr.NodeValue> extractValueConstraint(com.hp.hpl.jena.sparql.expr.Expr expr)

toValueSet

public static ValueSet<com.hp.hpl.jena.sparql.expr.NodeValue> toValueSet(org.aksw.commons.collections.Sample<com.hp.hpl.jena.sparql.expr.NodeValue> sample)

Returns true if it was cleaned, or false if the clause was unsatisfiable

Parameters:

sample -

Returns:

extractValueConstraintsDnf

public static Map<com.hp.hpl.jena.sparql.core.Var,ValueSet<com.hp.hpl.jena.sparql.expr.NodeValue>> extractValueConstraintsDnf(Set<Set<com.hp.hpl.jena.sparql.expr.Expr>> dnf)

Searches for expression of the form ?var = const TODO We are not considering equals between variables. A space efficient way to achieve this is by creating a new expression, where the substitution ?x ?y has been applied. ?x = const . ?y = const . ?x = ?y .

Parameters:

clause -

Returns:

addValueToSample

public static void addValueToSample(org.aksw.commons.collections.Sample<com.hp.hpl.jena.sparql.expr.NodeValue> sample,
                    com.hp.hpl.jena.sparql.expr.NodeValue nodeValue,
                    boolean isNegative)

intersection

public static <T> Set<T> intersection(Set<T> a,
                      Set<T> b)

Intersection where set 'a' may be null. In that case the result is 'b' Useful for cases where initally a set is unconstrained (contains all elements)

Type Parameters:

T -

Parameters:

a -

b -

Returns:

union

public static <T> Set<T> union(Set<T> a,
               Set<T> b)

extractValueConstraintsDnfClause

public static Map<com.hp.hpl.jena.sparql.core.Var,ValueSet<com.hp.hpl.jena.sparql.expr.NodeValue>> extractValueConstraintsDnfClause(Set<com.hp.hpl.jena.sparql.expr.Expr> dnfClause)

determineFilterDnf

public static Set<Set<com.hp.hpl.jena.sparql.expr.Expr>> determineFilterDnf(com.hp.hpl.jena.sparql.core.Quad quad,
                                                            Set<Set<com.hp.hpl.jena.sparql.expr.Expr>> dnf)

Given a quad and a predicate expression in DNF, determine if any of the expressions only containing variables of the quad are a "notwendige bedingung" on the pattern. What i mean is: If the extracted predicate fails for a binding of the variables on the triple, it will also fail for the whole expression. Technically we do the following: In the first phase we check which variables of the quad appear in all clauses. In the second phase we extract only those expressions containing the remaining variables from the first phase. TODO Currently we treat null as an always 'true' dnf

Parameters:

quad -

dnf -

Returns:

isUnsatsfiable

public boolean isUnsatsfiable(com.hp.hpl.jena.sparql.expr.Expr expr,
                     com.hp.hpl.jena.sparql.engine.binding.Binding partialBinding)

A test to check if the given predicate expression would yield false with the given, potentially partial, binding. Expressions making use of unbound variables will be considered satisfiable. Note this method is intended to be used as a hint in optizations. The assumption is that no code breaks if always false is retured.

Parameters:

expr -

partialBinding -

Returns:

toSets

public static Set<Set<com.hp.hpl.jena.sparql.expr.Expr>> toSets(List<com.hp.hpl.jena.sparql.expr.ExprList> clauses)

collectExprs

public static com.hp.hpl.jena.sparql.expr.ExprList collectExprs(com.hp.hpl.jena.sparql.algebra.Op op,
                                                com.hp.hpl.jena.sparql.expr.ExprList result)

isDnfSubsumed

public static boolean isDnfSubsumed(Set<Set<com.hp.hpl.jena.sparql.expr.Expr>> clausesA,
                    Set<Set<com.hp.hpl.jena.sparql.expr.Expr>> clausesB)

Return true if a is subsumed by b which means whenever a is true, b will be true You may need Expr x = originalExpr.copySubstitute(binding); to rename the variables and thus make the expressions equal. Note: This method only gives an hint when a subsumption is found. If it returns false it does not neccessarily mean that there is none. (b(x) -> true) implied (a(x) -> true) or(and(a, b), and(b, c) The current implementation only checks if the constraints of a more restrictive than those of b: A is subsumed by B if for each clause in A there exists a clause in B that contains A. This method so far deos NOT do fancy stuff such as finding out that ?x InRange (2, 4) is subsumed by ?y InRange (1, 5)

Parameters:

a -

b -

Returns:

isDnfClauseSubsumed

public static boolean isDnfClauseSubsumed(Set<com.hp.hpl.jena.sparql.expr.Expr> clauseA,
                          Set<com.hp.hpl.jena.sparql.expr.Expr> clauseB)