org.aksw.sparqlify.restriction

Class RestrictionManagerImpl

java.lang.Object

org.aksw.sparqlify.restriction.RestrictionManagerImpl

All Implemented Interfaces:

RestrictionManager

public class RestrictionManagerImpl
extends Object
implements RestrictionManager

This class combines two concepts: - Construction of expressions - Binding variables to values (thus constraining the set of possible values for variables) Furthermore, we can distinguish between bindings inferred from expressions, such as (?p = rdf:type) -> (?p -> rdf:type) and bindings stated by the user A monotone container for assigning constraints to expressions. A constraint that has been added cannot be removed anymore. WARNING: While working on an instance having the parent set, do not modify any of the parents in the chain. Otherwise results can be unexpected. Note adding constraints to variables is logically equivalent to extending the encapsulated filter expression with [...] AND (constraint). e.g. [?a = foo] AND (?a prefix bar) Therfore, if a constraint is inconsistent (FALSE), then the whole expression is inconsistent. Furthermore, it is possible to state expressions, such as ?a = concat('foo', bar). In this case, constraints for the variable will be derived from the expression. TODO Now that i realize: actually we first derive a description (startsWith), and depending on the context we derive a constraint. However, a description is always a constraint (for what it describes and vice versa) so there is no point in separating the concepts in the class hierarchy, but on the instance level (so when using these constraints). TODO Actually we can delay checking of filter expressions

Author:

Claus Stadler

Constructor Summary

Constructors

Constructor and Description
RestrictionManagerImpl()
RestrictionManagerImpl(NestedNormalForm cnf)
RestrictionManagerImpl(RestrictionManagerImpl parent)

Method Summary

Methods

Modifier and Type	Method and Description
void	check(Clause clause)
void	check(com.hp.hpl.jena.sparql.core.Var var)
void	checkClauses(Collection<Clause> clauses)
void	collectRestrictions(Map<com.hp.hpl.jena.sparql.core.Var,RestrictionImpl> result)
static RestrictionImpl	deriveRestriction(com.hp.hpl.jena.sparql.expr.E_StrConcat expr)
static RestrictionImpl	deriveRestriction(E_StrConcatPermissive expr)
static RestrictionImpl	deriveRestriction(com.hp.hpl.jena.sparql.expr.Expr expr)
static RestrictionImpl	deriveRestrictionConcat(com.hp.hpl.jena.sparql.expr.ExprFunction concat)
void	deriveRestrictions(Set<Clause> cnf)
Boolean	determineSatisfiability(com.hp.hpl.jena.sparql.expr.Expr expr) Test whether the given expression is satisfiable in regard to the given restrictions
static Boolean	determineSatisfiabilityEquals(RestrictionImpl a, RestrictionImpl b) Supported Constraints: Constant, StartsWith1
Map<com.hp.hpl.jena.sparql.core.Var,com.hp.hpl.jena.graph.Node>	getBindings()
Set<Clause>	getClausesForVar(com.hp.hpl.jena.sparql.core.Var var)
Set<Clause>	getClausesForVars(Collection<com.hp.hpl.jena.sparql.core.Var> vars) Returns all clauses having any of the given variables
NestedNormalForm	getCnf()
Set<Clause>	getEffectiveDnf(Collection<com.hp.hpl.jena.sparql.core.Var> vars)
void	getEffectiveDnf(int index, List<Clause> cnfs, Clause parentClause, Set<Clause> result) I use this method for getting constraints for finding view candidates
com.hp.hpl.jena.sparql.expr.ExprList	getExprs()
RestrictionImpl	getOrCreateLocalRestriction(com.hp.hpl.jena.sparql.core.Var a)
RestrictionImpl	getRestriction(com.hp.hpl.jena.sparql.expr.Expr expr) Return the restriction associated with as expression.
RestrictionImpl	getRestriction(com.hp.hpl.jena.sparql.core.Var a) Get the restriction associated with the given variable
Map<com.hp.hpl.jena.sparql.core.Var,RestrictionImpl>	getRestrictions()
Boolean	getSatisfiability()
Set<com.hp.hpl.jena.sparql.core.Var>	getVariables()
boolean	isUnsatisfiable()
void	stateCnf(NestedNormalForm newCnf)
void	stateExpr(com.hp.hpl.jena.sparql.expr.Expr expr) States a new expression, which is treated as conjuncted with previous expressions.
void	stateLiteral(com.hp.hpl.jena.sparql.core.Var a, com.hp.hpl.jena.sparql.expr.NodeValue b)
void	stateNode(com.hp.hpl.jena.sparql.core.Var a, com.hp.hpl.jena.graph.Node b)
void	stateNonEqual(com.hp.hpl.jena.sparql.core.Var a, com.hp.hpl.jena.sparql.core.Var b)
boolean	stateRestriction(RestrictionManagerImpl rm)
boolean	stateRestriction(com.hp.hpl.jena.sparql.core.Var var, RestrictionImpl restriction)
void	stateType(com.hp.hpl.jena.sparql.core.Var a, RdfTermType type)
void	stateUri(com.hp.hpl.jena.sparql.core.Var a, String uri)
void	stateUriPrefixes(com.hp.hpl.jena.sparql.core.Var a, PrefixSet prefixes)
String	toString()

Methods inherited from class java.lang.Object

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

Constructor Detail

RestrictionManagerImpl

public RestrictionManagerImpl()

RestrictionManagerImpl

public RestrictionManagerImpl(RestrictionManagerImpl parent)

RestrictionManagerImpl

public RestrictionManagerImpl(NestedNormalForm cnf)

Method Detail

getCnf

public NestedNormalForm getCnf()

getSatisfiability

public Boolean getSatisfiability()

deriveRestriction

public static RestrictionImpl deriveRestriction(com.hp.hpl.jena.sparql.expr.Expr expr)

deriveRestriction

public static RestrictionImpl deriveRestriction(com.hp.hpl.jena.sparql.expr.E_StrConcat expr)

deriveRestriction

public static RestrictionImpl deriveRestriction(E_StrConcatPermissive expr)

deriveRestrictionConcat

public static RestrictionImpl deriveRestrictionConcat(com.hp.hpl.jena.sparql.expr.ExprFunction concat)

deriveRestrictions

public void deriveRestrictions(Set<Clause> cnf)

stateRestriction

public boolean stateRestriction(com.hp.hpl.jena.sparql.core.Var var,
                       RestrictionImpl restriction)

getClausesForVar

public Set<Clause> getClausesForVar(com.hp.hpl.jena.sparql.core.Var var)

getClausesForVars

public Set<Clause> getClausesForVars(Collection<com.hp.hpl.jena.sparql.core.Var> vars)

Returns all clauses having any of the given variables

Parameters:

vars -

Returns:

check

public void check(com.hp.hpl.jena.sparql.core.Var var)

checkClauses

public void checkClauses(Collection<Clause> clauses)

check

public void check(Clause clause)

determineSatisfiability

public Boolean determineSatisfiability(com.hp.hpl.jena.sparql.expr.Expr expr)

Description copied from interface: RestrictionManager

Test whether the given expression is satisfiable in regard to the given restrictions

Specified by:

determineSatisfiability in interface RestrictionManager

Parameters:

expr - The expression to test for satisfiability

Returns:

The assessment of the satisfiability

collectRestrictions

public void collectRestrictions(Map<com.hp.hpl.jena.sparql.core.Var,RestrictionImpl> result)

getRestrictions

public Map<com.hp.hpl.jena.sparql.core.Var,RestrictionImpl> getRestrictions()

getRestriction

public RestrictionImpl getRestriction(com.hp.hpl.jena.sparql.expr.Expr expr)

Description copied from interface: RestrictionManager

Return the restriction associated with as expression. If the expression is a variable, getRestriction(Var) is invoked. restriction[concat("a", "b")] = prefixset({"ab"})

Specified by:

getRestriction in interface RestrictionManager

Returns:

determineSatisfiabilityEquals

public static Boolean determineSatisfiabilityEquals(RestrictionImpl a,
                                    RestrictionImpl b)

Supported Constraints: Constant, StartsWith1

Parameters:

r -

c -

getRestriction

public RestrictionImpl getRestriction(com.hp.hpl.jena.sparql.core.Var a)

Description copied from interface: RestrictionManager

Get the restriction associated with the given variable

Specified by:

getRestriction in interface RestrictionManager

Returns:

getOrCreateLocalRestriction

public RestrictionImpl getOrCreateLocalRestriction(com.hp.hpl.jena.sparql.core.Var a)

Specified by:

getOrCreateLocalRestriction in interface RestrictionManager

stateType

public void stateType(com.hp.hpl.jena.sparql.core.Var a,
             RdfTermType type)

Specified by:

stateType in interface RestrictionManager

stateNode

public void stateNode(com.hp.hpl.jena.sparql.core.Var a,
             com.hp.hpl.jena.graph.Node b)

Specified by:

stateNode in interface RestrictionManager

stateUri

public void stateUri(com.hp.hpl.jena.sparql.core.Var a,
            String uri)

Specified by:

stateUri in interface RestrictionManager

stateLiteral

public void stateLiteral(com.hp.hpl.jena.sparql.core.Var a,
                com.hp.hpl.jena.sparql.expr.NodeValue b)

Specified by:

stateLiteral in interface RestrictionManager

stateExpr

public void stateExpr(com.hp.hpl.jena.sparql.expr.Expr expr)

States a new expression, which is treated as conjuncted with previous expressions. This means that the restrictions are monotone in regard to adding new expressions. Given (?a = b) && (?a = x || ?a = y) Note: We are only interested in 'global' restrictions, we are not dealing with alternate varible assignments here (e.g. ?a = x OR ?a = y)

Parameters:

expr -

stateCnf

public void stateCnf(NestedNormalForm newCnf)

stateNonEqual

public void stateNonEqual(com.hp.hpl.jena.sparql.core.Var a,
                 com.hp.hpl.jena.sparql.core.Var b)

Specified by:

stateNonEqual in interface RestrictionManager

getBindings

public Map<com.hp.hpl.jena.sparql.core.Var,com.hp.hpl.jena.graph.Node> getBindings()

getVariables

public Set<com.hp.hpl.jena.sparql.core.Var> getVariables()

stateRestriction

public boolean stateRestriction(RestrictionManagerImpl rm)

getEffectiveDnf

public Set<Clause> getEffectiveDnf(Collection<com.hp.hpl.jena.sparql.core.Var> vars)

getExprs

public com.hp.hpl.jena.sparql.expr.ExprList getExprs()

getEffectiveDnf

public void getEffectiveDnf(int index,
                   List<Clause> cnfs,
                   Clause parentClause,
                   Set<Clause> result)

I use this method for getting constraints for finding view candidates

Parameters:

dnfs -

index -

dnfIndex -

blacklist -

depth -

parentClause -

result -

toString

public String toString()

Overrides:

toString in class Object

stateUriPrefixes

public void stateUriPrefixes(com.hp.hpl.jena.sparql.core.Var a,
                    PrefixSet prefixes)

isUnsatisfiable

public boolean isUnsatisfiable()