org.aksw.sparqlify.restriction.experiment

Class RestrictionManagerBeforeChangingToMap

java.lang.Object

org.aksw.sparqlify.restriction.experiment.RestrictionManagerBeforeChangingToMap

All Implemented Interfaces:

RestrictionManager

public class RestrictionManagerBeforeChangingToMap
extends Object
implements RestrictionManager

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
RestrictionManagerBeforeChangingToMap()
RestrictionManagerBeforeChangingToMap(NestedNormalForm cnf)
RestrictionManagerBeforeChangingToMap(RestrictionManagerBeforeChangingToMap parent)

Method Summary

Methods

Modifier and Type	Method and Description
void	check(Clause clause)
void	check(Collection<com.hp.hpl.jena.sparql.core.Var> vars)
void	check(com.hp.hpl.jena.sparql.core.Var var)
void	checkClauses(Collection<Clause> clauses)
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
Set<Clause>	getClausesForVars(Collection<com.hp.hpl.jena.sparql.core.Var> vars)
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
Collection<com.hp.hpl.jena.sparql.core.Var>	getEquivalences(com.hp.hpl.jena.sparql.core.Var a)
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
Boolean	getSatisfiability()
boolean	isEqual(com.hp.hpl.jena.sparql.core.Var a, com.hp.hpl.jena.sparql.core.Var b)
boolean	isUnsatisfiable()
void	stateCnf(NestedNormalForm newCnf)
void	stateEqual(com.hp.hpl.jena.sparql.core.Var a, com.hp.hpl.jena.sparql.core.Var b)
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(RestrictionManagerBeforeChangingToMap 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

RestrictionManagerBeforeChangingToMap

public RestrictionManagerBeforeChangingToMap()

RestrictionManagerBeforeChangingToMap

public RestrictionManagerBeforeChangingToMap(RestrictionManagerBeforeChangingToMap parent)

RestrictionManagerBeforeChangingToMap

public RestrictionManagerBeforeChangingToMap(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)

check

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

getClausesForVars

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

check

public void check(Collection<com.hp.hpl.jena.sparql.core.Var> vars)

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

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 -

isEqual

public boolean isEqual(com.hp.hpl.jena.sparql.core.Var a,
              com.hp.hpl.jena.sparql.core.Var b)

getEquivalences

public Collection<com.hp.hpl.jena.sparql.core.Var> getEquivalences(com.hp.hpl.jena.sparql.core.Var a)

stateEqual

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

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

stateRestriction

public boolean stateRestriction(RestrictionManagerBeforeChangingToMap rm)

getEffectiveDnf

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

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()