All Classes and Interfaces
Class
Description
Represents an expression to obtain an array of all the labels
of the LPG node that is bound to a given query variable.
A base class for all variations of the bind join algorithm that use
some form of SPARQL requests.
A generic implementation of the bind join algorithm that uses executable
request operators for performing the requests to the federation member.
Abstract base class to implement index nested loops joins by using request
operators.
Abstract base class to implement index nested loops joins by issuing
requests directly and, then, using response processors.
Base class for implementations of request operators.
Base class for implementations of request operators with requests
that have to be broken into multiple requests to handle paging.
Base class for implementations of paging-based request operators
where pages are
TPFResponse objects.Top-level base class for all implementations of
ExecutableOperator.Base class for implementations of request operators with triple
pattern requests that are broken into TPF requests to handle paging.
Base class for implementations of request operators with
requests that return triples and that can be performed as
is.
Base class for physical operators that implement some form of a
binary join algorithm; i.e., these algorithms consume two sequences
of input solution mappings (produced by the two sub-plans under this
operator) and join these the solution mappings from these two sequences
locally (i.e., within in the engine rather than by interacting with any
federation member).
Base class for physical operators that implement
some form of a multi-way join algorithm.
Base class for physical operators that implement
some form of a multi-way left join algorithm.
Top-level base class for all implementations of
PhysicalOperator.Base class for physical operators that implement some form of a join
algorithm that consumes only one input and produces the other input
as part of the algorithm itself.
This interface represents basic graph patterns (BGPs).
A specialization of the
ExecutableOperator interface that
captures executable operators that consume a pair of two sequences
of solution mappings (which both are batched into several blocks of
solution mappings).Top-level base class for all implementations of
BinaryExecutableOp.An interface for any type of
LogicalOperator that has
an arity of two; i.e., it is defined of as a function over two
multisets of solution mappings.An interface for any type of
PhysicalOperator whose algorithm
consumes two sequences of solution mappings as input.An interface for any type of
PhysicalOperator
that directly implements a particular logical operator
that has an arity of two.A very simple
FederationAccessManager
that simply blocks for each request.This interface represents the subset of Cypher Expressions that can be evaluated
to a boolean value: true, false or null.
A generic interface for data structures that can be used as a cache for
objects of a specific type.
An implementation of
CacheEntryFactory for CacheEntryBase objects.Creates EntryType objects that wrap ObjectType objects.
Interface for classes that determine whether cache entries are
still valid.
A generic implementation of
CacheInvalidationPolicy that always
returns true.Interface for classes that implement a replacement policy for a cache.
This class implements a query optimizer[1] that builds left-deep query plans,
for which it uses a greedy approach to determine the join order based on cardinality estimation,
and then choose physical algorithm according to the estimated number of request to execute the join
Base class for heuristics that use cardinality estimates to decide on
a join order for the subplans of a multiway join or a binary join.
A help class that wraps a
LogicalPlan together with some
information about this plan that is relevant for the algorithm of
the main class (CardinalityBasedJoinOrderingBase and that
may be relevant for implementations of the abstract functions.This class is an implementation of
CardinalityBasedJoinOrderingBase
that uses cardinality requests.An entry used when caching cardinality requests.
An entry used when caching cardinality requests.
A key for caching cardinality requests, uniquely identified by a
DataRetrievalRequest and a FederationMember.This interface represents cardinality estimators that can estimate
the cardinality of the result that will be produced by query plans.
An exception that occurred during the process of estimating the
cardinality of the result that will be produced by a given plan.
This class implements an approach to cardinality estimation that is based
on the following two ideas: First, for leaf nodes in the given plans, which
are request operators, the implementation issues cardinality requests to
the respective federation members.
A subclass of
CardinalityResponseImpl representing a response where the cardinality is not available.Abstract base class for implementations of
CostFunctionForRootOp.Generic implementation of
CostFunctionForPlan that can be used
for any cost function that is defined as the sum of operator-specific
cost values for all operators in the plan.An implementation of
CostFunctionForPlan that can be used
for any cost function that considers parallelism of operators
PhysicalOpMultiwayUnion, PhysicalOpBinaryUnion
and PhysicalOpSymmetricHashJoin, in which operators, the maximum
cost values among subQueries is taken into account.A thread-safe persistent cache implementation for storing cardinality entries.
A (thread-safe) implementation of
IntermediateResultElementSink
that collects all solution mappings that are sent to it.This class captures exceptions that may occur while trying
to consume the output of a
PushBasedPlanThread.An exception that occurred during the process
of estimating the cost of a given plan.
Implementations of this interface represent functions that determine
some form of cost value for any given (physical) query plan.
Implementations of this interface represent functions that determine
some form of cost value for the root node of any given query plan.
This interface represents a generic Cypher Expression.
This class is made to provide generic visitor functionalities to traverse expression trees.
Represents a Cypher Query with a MATCH-WHERE-RETURN structure,
For example, the query:
MATCH (x)
MATCH (a)-[b]->(c)
WHERE a:CLASS AND b.property='value'
UNWIND KEYS(a) AS k
RETURN x AS n1, c AS n2, k AS key
can be represented with this interface.
Represents a query written in the Cypher query language.
Represents a UNION Cypher query.
Vocabulary definitions from engineconf.ttl
This interface captures the notion of an edge label mapping that is part of the notion of an LPG-to-RDF configuration,
and that such an edge Label mapping is an injective function from edge labels in LPGs to IRIs nodes as
can occur in RDF graphs.
Represents a directed path match statement.
This class provides useful functionality related to Jena's
representation of graph patterns as
Element objects.Maps from the global representation of entities to a local representation
that is specific to a particular data source (federation member).
To be used for BIND clauses.
Implementation of (a batching version of) the bind join algorithm
for cases in which the federation member accessed by the algorithm
supports the brTPF interface.
Implementation of (a batching version of) the bind join algorithm that
uses FILTERs to capture the potential join partners that are sent to the
federation member.
Implementation of (a batching version of) the bind join algorithm
that uses UNION clauses with FILTERs inside.
Implementation of (a batching version of) the bind join algorithm that uses
a VALUES clause to capture the potential join partners that are sent to the
federation member.
Implementation of (a batching version of) the bind join algorithm that starts by
using a VALUES clause exactly as done by
ExecOpBindJoinSPARQLwithVALUES.An exception that occurred during the execution of a specific operator.
A right outer join version of the hash join algorithm implemented in
ExecOpHashJoin.Attention, this is a purely local implementation of the nested loops
join algorithm---nothing fancy, no requests to federation members or
anything.
TODO: Provide a description of the algorithm implemented by this class.
Implementation of an operator to request a (complete) TPF from a brTPF server.
Implementation of an operator to request a (complete) TPF from a TPF server.
Implementation of the symmetric hash join algorithm.
An executable operator provides the implementation of the concrete
algorithm that a physical operator is associated with.
This interface captures statistics collected during
the execution of an
ExecutablePlan.An implementation of
ExecutablePlanStats
for IteratorBasedExecutablePlanImpl.An exception that may occur during the query execution process.
This implementation of
SourcePlanner assigns every triple
pattern of the given query to every federation member known in the
federation catalog.Implementations of this interface represent sets of variables that can
be expected in the solution mappings produced for query patterns and by
query operators.
Vocabulary definitions from feddesc.ttl
As a basis for classes that implement the
FederationAccessManager
interface, this abstract base class provides default implementations of
the methods for issuing cardinality requests.Abstract base class for implementations of the
FederationAccessManager
interface that use request processors (see RequestProcessor etc).A FederationAccessManager implementation that incorporates persistent disk
caching of cardinality requests.
A FederationAccessManager implementation that incorporates persistent disk
caching of SPARQL cardinality requests.
This is an iterator of solution mappings that consumes another iterator
and passes on only the solution mappings that are compatible to a given
solution mapping.
This is an iterator of solution mappings that consumes another iterator
and passes on only the solution mappings that have a given value for a
given variable.
This is an iterator of solution mappings that consumes another iterator
and passes on only the solution mappings that have given values for three
variables.
This is an iterator of solution mappings that consumes another iterator
and passes on only the solution mappings that have given values for two
variables.
Pushes filter conditions as much as possible towards the leaf nodes
of a given logical plan.
Represents an expression to obtain the first label of
a graph object that is bound to a given query variable.
Estimate selectivity of a subplan by considering
- 1. the number of new unbound variables
- 2. the position of new unbound variables (sub, pred, or obj)
- 3. number of joins contained in this subplan
- 4. types of joins contained in this subplan (star join, chain join, unusual join)
- 5. number of joins between this subplan with all selected plans
- 6. type of joins between this subplan with all selected plans
- star join, chain join, or unusual join
- join within the same federation member or across different federation members
This formula is an extended version of the formula that is implemented in
JoinAwareWeightedUnboundVariableCountA generic, thread-safe implementation of
Cache.This class is a generic implementation of
SPARQLGraphPattern
in which this graph pattern is given as an object of the class
Element of the Jena API.This class is a generic implementation of
SPARQLGraphPattern
in which this graph pattern is given as an object of the class
Op of the Jena API.Used to represent a URI configuration.
Represents an individual argument for a GraphQL query
Used to represent and contain information about a specific field
in the GraphQL "query" type
Represents whether a GraphQLEntrypoint (a field in the query type) returns
a single object, a list of filtered objects or a full list of all objects (of a certain type).
Used to represent information about a field in a GraphQL object type
Used to represent either a full or segmented GraphQL field path.
A builder class for creating field paths used for GraphQL queries.
Used to represent whether a field in a GraphQL object type returns
an object / list of objects OR a scalar value / list of scalar values.
GraphQLFieldPath segment used to represent the "id" field for objects in a GraphQL query
GraphQLFieldPath segment used to represent GraphQL object types in the query.
Represents a GraphQL query
An class for objects that wrap a
StarPattern and provide
functionality for creating the root field of a GraphQL query
based on the star pattern.GraphQLFieldPath segment used to represent GraphQL scalar values in the query.
Used to initialize a GraphQL schema from a GraphQL endpoint
Implement a greedy algorithm to determine the join order of sub-plans.
Builder class that can be used to create a fully-wired instance of
HeFQUINEngine.Reads an RDF description of a configuration for the HeFQUIN engine and
creates a
HeFQUINEngine object based on this configuration.A collection of functions to create the default versions
of the various components used by the HeFQUIN engine.
This class contains methods that identifying the root physical operator of a physical plan.
An exception for cases in which a query given to HeFQUIN turns out to
be somehow invalid.
Wraps a
PrintStream and adds functionality to print with
different levels of indentation.Servlet for handling SPARQL inspect queries via HTTP GET and POST requests.
This class wraps an
InterruptedException caught in a thread that
is waiting to consume the output of a PushBasedPlanThread.Provides iterators created by a given
IteratorFactory.Estimate selectivity of a subplan by considering
- the number of new unbound variables
- the position of new unbound variables (sub, pred, or obj)
- number of joins contained in this subplan
- types of joins contained in this subplan (star join, chain join, unusual join)
To get unbound variables, the set of bindings in selectedPlans needs to be considered.
This iterator enumerates the result of joining two collections of solution
mappings.
An abstract base class for implementations of
JoinPlanOptimizer.An implementation of the JSON2SolutionMappings approach
A
DataRetrievalInterface via which a JSON document can be retrieved.This class models graphs with labeled edges.
Enum for the possible edge directions
An edge of a labeled graph has an id, an edge label, a target node and a direction
Represents a path in a graph, starting from a given node and following a sequence of edges.
This interface represents elements in the subset of Cypher Expressions that can be evaluated to lists.
The top-level interface for all types of logical operators of HeFQUIN.
A multiway left join corresponds to a sequence of SPARQL OPTIONAL clauses.
Implementations of this interface provide the functionality
to print logical plans in some way.
Applies a
LogicalPlanVisitor to
a given LogicalPlan recursively
in a depth-first order.This class provides methods to convert logical operators into
physical operators by using the respective default type of
physical operator for each type of logical operator.
Represents the notion of an LPG-to-RDF configuration as defined in
Olaf Hartig: "Foundations to Query Labeled Property Graphs using SPARQL*."
Vocabulary definitions from lpg2rdfconf.ttl
This class represents a special type of
AliasedExpression.Represents path matching statements of Cypher queries
For example, MATCH (x), MATCH (x)-[e]->(y)
A command-line tool to materialize an RDF view of a labeled property graph
(LPG) retrieved from a Neo4j endpoint using Cypher queries.
Collects the emitted triples into a graph and writes this graph to the
given
OutputStream upon calling the MaterializeRDFViewOfLPG.MyCachingStreamRDF.finish() function.An implementation of
QueryResultSink
that simply materializes the query result.Merges subplans that consists of multiple requests to the same federation
member if such a merge is possible.
This class implements a cardinality estimation approach that relies on the cardinalities of subPlans.
Command-line argument module for specifying endpoint and authentication.
Command-line argument module for specifying query-related arguments.
Command-line argument module for specifying endpoint and authentication.
A specialization of the
ExecutableOperator interface that
captures executable operators that consume an arbitrary number of
sequences of solution mappings (where each such sequence is batched
into several blocks of solution mappings).Top-level base class for all implementations of
NaryExecutableOp.An interface for any type of
LogicalOperator that has an
arbitrary arity ; i.e., it is defined of as a function over an
arbitrary number of multisets of solution mappings.An interface for any type of
PhysicalOperator whose algorithm
consumes an arbitrary number of sequences of solution mappings as input.An interface for any type of
PhysicalOperator
that directly implements a particular logical operator
that has an arbitrary arity.This interface captures the notion of a nodeLabel mapping that is part of the notion of an LPG-to-RDF configuration,
and that such a nodeLabel mapping is an injective function from nodeLabels in LPGs to IRIs or RDF-literal nodes as
can occur in RDF graphs.
This interface captures the notion of a node mapping that is part of the notion of an LPG-to-RDF configuration,
and that such a node mapping is an injective function from nodes in LPGs to IRIs or blank nodes as
can occur in RDF graphs.
Represents a node match clause
For example, MATCH (x)
A specialization of the
ExecutableOperator interface that
captures executable operators that do not consume any input produced
by other operators; hence, these operators are the leaf nodes in a
tree representation of query execution plans.Top-level base class for all implementations of
NullaryExecutableOp.An interface for any type of
LogicalOperator that has
an arity of zero.An interface for any type of
PhysicalOperator whose algorithm
does not consume any input (but produces a sequence of solution mappings
as output).An interface for any type of
PhysicalOperator
that directly implements a particular logical operator
that has an arity of zero.This class provides useful functionality related to Jena's
Op interface and the classes that implement it.In contrast to Jena's
PatternVars class, this one collects
all the variables in a given Element; i.e., including the
ones inside MINUS and FILTERs.A generic interface for data structures that can be used as a persisted cache
for objects of a specific type.
A thread-safe cache implementation for storing cardinality responses.
A physical operator that implements a binary union.
A physical operator that implements (a batching version of) the bind
join algorithm for cases in which the federation member accessed by
the algorithm supports the brTPF interface.
A physical operator that implements (a batching version of) the bind
join algorithm using FILTERs to capture the potential join partners
that are sent to the federation member.
A physical operator that implements (a batching version of) the bind
join algorithm using UNION.
A physical operator that implements (a batching version of) the bind
join algorithm using a VALUES clause to capture the potential join
partners that are sent to the federation member.
A physical operator that implements (a batching version of) the bind
join algorithm.
This is the top-level interface for all types of physical operators of
HeFQUIN, where a physical operator is an element in a (physical) query
execution plan and is associated with a concrete algorithm that produces
a result (in HeFQUIN, this would be in the form of a sequence of solution
mappings) by consuming such results produced by the sub-plans under the
current operator.
An interface for any type of
PhysicalOperator
that directly implements a particular logical operator.A physical operator that filters the input solution mappings.
A physical operator that applies a given vocabulary mapping to all input
solution mappings, converting them from using global vocabulary terms to
using local vocabulary terms.
A physical operator that implements the hash join algorithm to perform an
inner join of two sequences of input solution mappings (produced by the two
sub-plans under this operator).
A physical operator that implements the hash join algorithm to perform
a right outer join of two sequences of input solution mappings (produced
by the two sub-plans under this operator).
A physical operator that implements a version of the index nested loops
join algorithm where the federation member is used as an index to request
join partners for the input solution mappings.
A physical operator that applies a given vocabulary mapping to all input
solution mappings, converting them from using local vocabulary terms to
using global vocabulary terms.
A physical operator that implements a multi-way union.
A physical operator that implements a local (!)
A physical operator that implements a left-outer join for multiple optional
parts; as a unary operator, the operator has a single input, which provides
the solutions of the non-optional part.
A physical operator that performs a request at a federation member
and, then, outputs the solution mappings obtained via this request.
A physical operator that implements the symmetric hash join algorithm
to perform an inner join of two sequences of input solution mappings
(produced by the two sub-plans under this operator).
An exception that occurred during query optimization.
Implementations of this interface provide the functionality
to print physical plans in some way.
Represents the set of property/value pairs that an LPG node or edge can have
This interface captures the notion of a property name mapping that is part of the notion of an LPG-to-RDF configuration,
where such a property name mapping is an injective function from names of properties in LPGs to IRIs nodes as
can occur in RDF graphs.
Contains the core part of implementing
PushBasedPlanThread.In cases in which there are unions with requests under joins (which may
happen only if we do not use
UnionPullUp, this heuristics turns
the requests into xxAdd operators with the previous join arguments as
subplans.An exception that occurred during query compilation.
Simple implementation of
QueryPlanner.An exception that occurred during query planning.
Simple implementation of
QueryProcessor.An exception that may occur when processing a query.
A record entry is a pair (ai, vi) where ai is a Cypher variable and vi is a Value.
A command-line tool that executes SPARQL queries using the HeFQUIN federation
engine without source selection.
Maps from the global schema (considered RDF vocabularies) to
a local schema of some data source(s) / federation member(s).
This implementation of
SourcePlanner does not actually perform
query decomposition and source selection but simply assumes queries with
SERVICE clauses where, for the moment, all of these SERVICE clauses are
of the form "SERVICE uri {...}"Utility class for servlet-based integration of the HeFQUIN query engine.
Helper class representing the nodes used to check for cyclic bindings between SGPs
This class implements a simple query optimizer that focuses only
on join ordering, for which it uses an enumeration algorithm to
optimize any subplan that consists of a group of joins.
A
DataRetrievalInterface via which a set of
solution mappings can be retrieved.This is a hash table based implementation of
that can be used for indexes that are meant to be used for cases in which
adding and probing into the index may not happen concurrently.
invalid reference
SolutionMappingsIndexThis is a hash table based implementation of
that can be used for indexes that are built on one query variable and that
are meant to be used for cases in which adding and probing into the index
may not happen concurrently.
invalid reference
SolutionMappingsIndexThis is a hash table based implementation of
that can be used for indexes that are built on two query variables and that
are meant to be used for cases in which adding and probing into the index
may not happen concurrently.
invalid reference
SolutionMappingsIndexImplementations of this interface can be used as an index for
SolutionMapping objects.Wraps another
SolutionMappingsIndex and, for every method that
returns an Iterable of solution mappings, this implementation
copies the Iterable returned by the wrapped index into a new
list and, then, returns that list.This is a special implementation of
that
can be used for cases in which ALL indexed solution mappings should be
returned as join partners.
invalid reference
SolutionMappingsIndexThis is an iterator over all solution mappings contained in a nested
collection (more precisely, in lists contained in a collection).
An exception that occurred when creating a source assignment for a given query.
Objects of this type capture the output of the SPARQL-to-Cypher
translation (as performed by a
SPARQLStar2CypherTranslator).Provides helper functions for creating the necessary data in a GraphQL query.
Translator for SPARQL to GraphQL
This interface represents any kind of SPARQL query pattern.
A SPARQL group pattern represents a collection of SPARQL graph patterns
for which the results are meant to be joined.
Servlet for handling SPARQL queries via HTTP GET and POST requests.
A SPARQL union pattern represents a collection of SPARQL graph patterns
for which the results are meant to be combined via union.
This class represents a subject-based star pattern, that is,
a set of triple patterns that all share the same subject.
An interface for statistics collected during some process or by a data
structure or component.
An implementation of
ExecutablePlanStats
for PushBasedExecutablePlanImpl.A utility class for converting and printing
Stats objects in JSON format.A record is a "row" of the results of the evaluation of a Cypher query.
Distance-based termination criterion:
Termination is triggered when the relative distance between the average cost of plans
in the current generation and in the previous generation has not exceeded
a specified distance threshold for a number of generations.
Distance-based termination criterion:
Termination is triggered when the relative distance between the average cost
in the current generation and in the previous generation has not exceeded
a specified distance threshold for a number of generations.
Distance-based termination criterion:
Termination is triggered when the relative distance between the cost of the best plan
in the current generation and in the previous generation has not exceeded
a specified distance threshold for a number of generations.
Diversity-based termination criterion:
Similar to
TerminateByDiversityDistMax, but only the top-k plans with lowest cost within each generation are considered.Diversity-based termination criterion:
Termination is triggered when the relative difference between the cost of the best plan
and the worst plan within each generation has not exceeded
a specified distance threshold for a number of generations.
Diversity-based termination criterion:
Termination is triggered when the relative standard deviation of the cost values
within the current generation is below a given threshold or the N-th generation is reached.
Termination is triggered when the lowest-cost plan per generation
has not exceeded a specified threshold for a number of generations.
termination criterion: number of generations
Base class for implementations of
TerminationCriterion.Internally, the functionality of this class is implemented based on
a
LogicalPlanVisitor, which makes sure that we get a compiler
error whenever we add a new type of logical operator but forget to
extend this class here to cover that new operator.Internally, the functionality of this class is implemented based on
a
PhysicalPlanVisitor, which makes sure that we get a compiler
error whenever we add a new type of logical operator but forget to
extend this class here to cover that new operator.Base class for
RequestProcessor implementations that retrieve TPFResponse.This interface represents triple patterns.
A
DataRetrievalInterface via which a set of
triples can be retrieved.This class provides useful functionality
related to Jena's
Triple class.A specialization of the
ExecutableOperator interface that
captures executable operators that consume a single input sequence
of solution mappings.Top-level base class for all implementations of
UnaryExecutableOp.Base class for all implementations of
UnaryExecutableOp that process
the input solution mappings in batches (bind joins are typical examples of
such operators).An interface for any type of
LogicalOperator that has
an arity of one; i.e., it is defined of as a function over one
multiset of solution mappings.An interface for any type of
PhysicalOperator whose algorithm
consumes a single sequence of solution mappings as input.An interface for any type of
PhysicalOperator
that directly implements a particular logical operator
that has an arity of one.This iterator enumerates the solution mappings from two other iterators,
essentially producing a union of the collections of solution mappings
that the other two iterators enumerate.
Pulls up all (multiway) union operators in the given plan as high up as
possible.
An exception for cases in which a query given to HeFQUIN uses some feature
that is not (yet) supported by HeFQUIN.
This interface represents an UNWIND clause of a Match Query.
Provides helper functions that focuses on conversions from URIs to GraphQL data
that is then used at a GraphQL endpoint.
Queries with a WHERE clause of a form such as the following one need to be
rewritten, which is what this class does.
Transforms all SERVICE clauses that have a service variable by replacing
this variable with the URI that a given solution mapping assigns to the
variable.
This exception is used internally by this class.
This exception is used internally by this class.
Collects all variables in a given
Element except for
variables that occur *only* as the variable of SERVICE clauses.Checks for each visited SERVICE clause that has a service variable
whether that variable is in a given list of permitted variables.
Temporary class.
Wraps another iterable over the same type and can
be used to apply a corresponding wrapping iterator.
Base class for implementations of
SolutionMappingsIndex
that wrap another SolutionMappingsIndex.