org.aksw.sparqlify.restriction.experiment

Class RestrictionManager2

java.lang.Object

org.aksw.sparqlify.restriction.experiment.RestrictionManager2

public class RestrictionManager2
extends Object

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
RestrictionManager2()
RestrictionManager2(NestedNormalForm cnf)
RestrictionManager2(RestrictionManager2 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 RestrictionManager2	createUnion(Collection<RestrictionManager2> rms) How to create unions of CNFs? (a AND (b OR c)) OR (A AND (b OR c)) The good thing: It should be easy to figure out whether a clause already exists in the CNF Actually: Can we even separate the restrictions from the CNF? I guess so.
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)
static Boolean	determineSatisfiabilityEquals(RestrictionImpl a, RestrictionImpl b) Supported Constraints: Constant, StartsWith1
static Boolean	determineSatisfiabilityEquals(RestrictionSetImpl a, RestrictionSetImpl b)
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)
RestrictionSetImpl	getOrCreateLocalRestriction(com.hp.hpl.jena.sparql.core.Var a)
RestrictionSetImpl	getRestriction(com.hp.hpl.jena.sparql.expr.Expr expr)
RestrictionSetImpl	getRestriction(com.hp.hpl.jena.sparql.core.Var a)
Boolean	getSatisfiability()
Set<com.hp.hpl.jena.sparql.core.Var>	getVariables()
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	stateLexicalValuePrefixes(com.hp.hpl.jena.sparql.core.Var a, PrefixSet prefixes)
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(com.hp.hpl.jena.sparql.core.Var var, RestrictionImpl restriction)
boolean	stateRestriction(com.hp.hpl.jena.sparql.core.Var var, RestrictionSetImpl 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

RestrictionManager2

public RestrictionManager2()

RestrictionManager2

public RestrictionManager2(RestrictionManager2 parent)

RestrictionManager2

public RestrictionManager2(NestedNormalForm cnf)

Method Detail

getVariables

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

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)

stateRestriction

public boolean stateRestriction(com.hp.hpl.jena.sparql.core.Var var,
                       RestrictionSetImpl 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)

getRestriction

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

determineSatisfiabilityEquals

public static Boolean determineSatisfiabilityEquals(RestrictionImpl a,
                                    RestrictionImpl b)

Supported Constraints: Constant, StartsWith1

Parameters:

r -

c -

determineSatisfiabilityEquals

public static Boolean determineSatisfiabilityEquals(RestrictionSetImpl a,
                                    RestrictionSetImpl b)

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 RestrictionSetImpl getRestriction(com.hp.hpl.jena.sparql.core.Var a)

getOrCreateLocalRestriction

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

stateType

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

stateNode

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

stateUri

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

stateLiteral

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

stateLexicalValuePrefixes

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

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)

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

createUnion

public static RestrictionManager2 createUnion(Collection<RestrictionManager2> rms)

How to create unions of CNFs? (a AND (b OR c)) OR (A AND (b OR c)) The good thing: It should be easy to figure out whether a clause already exists in the CNF Actually: Can we even separate the restrictions from the CNF? I guess so. Actually, thats why I have the copy on write stuff anyway. Ok: First step: Create a union of the restrictions per variable

Parameters:

rms -

Returns: