All Classes and Interfaces
Class
Description
The following optimizations are currently implemented:
- f(argsA) = f(argsB) -> argA_0 = argB_0 && ...
A clause with restrictions derived for the variables
Dnf, Clauses, and Exprs should be treated as immutable!
A 'permissive' version of Jena's E_StrConcat, that does not
complain when mixing types (e.g.
A map where keys can be stated as equivalent.
Class for retrieval of an expression's arguments
Implementations of this class transform expressions as to eliminate
all RDF term expressions.
Evaluator for expressions.
TODO Clarify: Do I want disjunctive or conjunctive normal form?
(a and b) or (c and d) or
(a or b) and(c or d) ?
I guess the former is better, as (a and not a) can be easily detected
What happens if we allow conjunctions of disjunctive normal forms?
((a, b) or (c, d) AND ((x) or (y)))
becomes
(abx or aby or cdx or cdy) (so the cross product of the involved clauses)
Maybe i could do virtual clauses:
CrossJoinClause(Clauses ...)
Hm, but with CNF it is easier to add new expressions.
Datastructure for metadata about indexes (hierarchical and non-hierarchical).
A datastructure which allows putting data of a type C into it,
and enables querying candidates with type Q.
Convert an Op expression in SPARQL syntax, that is, the reverse of algebra generation
This class is used to take substitute an expressions for variables
in another expression.
IMPORTANT: If you are working with a child set, then do not modify the parent,
or things might go out of sync.
IMPORTANT: If you are working with a child set, then do not modify the parent,
or things might go out of sync.
Can replace nodes with expressions
Accessor for a NavigableMap<List<?>, Object>
We separate the accessor from the store, in order to avoid duplicating
(referenences to) the index metadata at each node of the index tree -
this way there is just one accessor with the metadata, which can
work on any corresponding store at some level in an hierarchical index.
TODO Switch to a trie data structure
Rewrite a query by rewriting its algebra
RDF term types
[SPARQL level]
A restrictedExpr is comprised of
- An SPARQL expression
- restrictions associated with its corresponding value after evaluation (under some interpretation)
Example:
Some expression can be declared to yield integers in the range [0..4]
or uris with certain prefixes.
This class represents restrictions to be used on variables.
Interface for associating restrictions with
(query) variables.
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 set of restrictions corresponding to the union of restrictions.
A disjunction of restrictions.
Restrictions for explicit values
Problem:
Create V1 { ?s label ?o2 .
Macro Expansion, e.g.
An SparqlView definition.
Deprecated.
Methods of this class are invoked for each rdf-function
after all its arguments have been pushed.
Iterator for iterating all of a list's subLists with a given offset (default 0)
and increasing size.
A table itself only provides metadata.
In its current state this class only hides the copying that should be
avoided by a view
Deprecated.
A variable binding maps query vars to sets of view variables.
A variable definition binds a set of SPARQL variables to a
set of corresponding defining expressions
A variable definition consists of a
- a restricted expression that defines the variable
- an optional set of restriction expressions that restricts the variables set of values //apply to the variable under this definition
The expression can either be:
- a constant NodeValue that directly associates the variable with a constant
- an expression of type E_RdfTermCtor,
- other expression types probably do not make sense here - at least I don't see use cases for them (yet).
Constraint for a variable.
View instances relate variables (usually those of of a
SPARQL query subject to rewriting) to the variables and
constants of a view.
A complete binding consists of a list of views and an overall binding
Can be seen as a conjunction of views
Compares views by their name.