All Classes and Interfaces
Class
Description
Notes for model revision:
- Right now we assume that the parent is reached by traversing 'one' in reverse direction
This will break once we add the conjunctive constraint features to multinode.
A specific expression
Facade to toggle an individual constraint on and off.
API to access the constraints at the target node reached by a traversal.
Constraints within a group are disjunctive, whereas groups are conjunctive.
This implementation features support for traversals along facet paths
as well as setting constraints on the paths.
DataQueryImpl<T extends org.apache.jena.rdf.model.RDFNode>
Optional paths
Given the following graph patterns, are the some algebraic relations that hold between them?
(a) { OPTIONAL { X } }
(b) { OPTIONAL { X OPTIONAL Y } }
(c) { OPTIONAL { X Y } }
c: If for some binding of X there is no suitable binding of Y, the whole binding will be dropped
Maybe optional should be part of the traversal api?
fwd('foo').opt().fwd('bar')
Accumulator for elements.
Create individual elements for a facet paths.
FacetedDataQueryImpl<T extends org.apache.jena.rdf.model.RDFNode>
An extension of
DataQueryImpl that allows obtaining FacetedQuery instances for
node views.The entry point is
FacetedRelationQueryDeprecated.
Controls the result type for this query
and which attributes are in effect.
A mapping of FacetPaths to strings, typically hashes.
Mapping of facet paths to hashes.
Pattern of generated variable names: '_scope_pathname_origvar_' Underscores in scope and path are doubled for escaping.
Base interface for traversals along FacetSteps.
FactoryWithModel<T extends org.apache.jena.rdf.model.RDFNode>
Class to construct a graph pattern where nodes may be references to variables and paths
This is probably not needed, as we can just subclass Jena's Node with e.g.
Fluent API wrapper for a
FacetConstraintControlAn element with a mapping of FacetPaths to ElementAccs and their variables
A query with information about which variable corresponds to which path
A view over a single column of a RelationQuery.
A root node corresponds to a variable of a graph pattern.
Scan all nodes of a query for instances of NodePathletPath and
add resolve the contained path against a pathletContainer
NodeTransformer that detects nodes that are path references,
and resolves them to appropriate variables, thereby keeping
track of graph patterns that need to be injected into the
base query.
PathFactoryMultiNode<N extends TraversalNode<N,D,M>,D extends TraversalDirNode<N,M>,M extends TraversalMultiNode<N>>
PathMultiNode<N extends TraversalNode<N,D,M>,D extends TraversalDirNode<N,M>,M extends TraversalMultiNode<N>>
PathNode<N extends TraversalNode<N,D,M>,D extends TraversalDirNode<N,M>,M extends TraversalMultiNode<N>>
Stateful mapper that creates SPARQL BinaryRelation objects from paths,
thereby ensuring consistent variable naming
The mapper does not track changes - such as modifying a path's alias
TODO Here is the place for making use of a registry for mapping path elements to binary relations if desired ~ Claus Stadler, Jun 2, 2019
Corresponds to a graphql fragment.
Mapping of property nodes (should always be IRI nodes) to a defining Relation.
Class for resolving paths of RDF properties (via
FacetPath} to SPARQL elements.A query fragment is construct query with a designated variable.
A generalization of a NodeFragment:
A sparql fragment with a declared set of join variables.
Resolution on a template yields 2 resolvers (if the step leads to a target):
- Another one on the template level
- One on the data level
These two resolvers are wrapped as a single ResolverUnion
A data structure to hold which values were retrieved for which relation under which bindings.
This interface features support for traversals along facet steps
rooted in an object of type R.