All Classes and Interfaces
Class
Description
This class is an extension of Jena's
AlgebraGenerator that
correctly handles ElementService objects that are of type
ElementServiceWithParams.Represents an expression to obtain an array of all the labels
of the LPG node that is bound to a given query variable.
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.
A generic implementation of a batch-based bind-join algorithm that issues
the bind-join requests without blocking, handling the processing of their
responses in parallel (in the threads that the federation access manager
uses to perform the requests).
A base class for all variations of our parallelized, batch-based
bind-join algorithm that use some form of SPARQL requests.
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.A generic implementation of batch-based bind-join algorithm that performs
the bind-join requests sequentially, one after another, for which it uses
executable request operators.
A base class for all variations of our sequential, batch-based
bind-join algorithm that use some form of SPARQL requests.
Base class for implementations of request operators with
requests that return triples and that can be performed as
is.
This is an abstract base class for classes that implement concrete
specializations (sub-interfaces) of the
FederationMember
interface.This is an abstract base class for classes that implement concrete
specializations of the
MappingOperator interface.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.
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 is an abstract base class for classes that implement concrete
specializations (sub-interfaces) of the
QueryPlan interface.An extension of
PlanPrinter.PrintablePlan objects that makes it possible
to record the graph pattern of the root operator of the plan (if any)
as well as a full-string representation of that pattern.Base class for all implementations of
UnaryExecutableOp that
work more effectively if at least a minimum number of input solution
mappings are available to process.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.
Provides build-time metadata (name, version, url) and a constructed
User-Agent string.
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.
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.
Implementations of this class complete the cardinality estimation process
for a given query plan (or for multiple such plans) in which every nullary
subplan is already annotated with its cardinality estimate.
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 extends
ElementService to represent SERVICE clauses
that use PARAMS(...), which is a HeFQUIN-specific extension to SERVICE.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.
To be used for DISTINCT clauses.
An exception that occurred during the execution of a specific operator.
A right outer join version of the hash join algorithm implemented in
ExecOpHashJoin.May be used for brTPF servers as well (in fact,
BRTPFServer
is a specialization of TPFServer).Attention, this is a purely local implementation of the nested loops
join algorithm---nothing fancy, no requests to federation members or
anything.
Implementation of the parallel, batch-based bind-join algorithm that
uses a FILTERs to capture the potential join partners that are sent
to the federation member.
Implementation of the parallel, batch-based bind-join algorithm that
uses UNION clauses with FILTERs inside.
Implementation of the parallel, batch-based bind-join algorithm that
uses a VALUES clause to capture the potential join partners that are
sent to the federation member.
TODO: Provide a description of the algorithm implemented by this class.
Base class for implementations of request operators with triple
pattern requests that are broken into TPF requests to handle paging.
Implementation of the sequential, batch-based bind-join algorithm
for cases in which the federation member accessed by the algorithm
supports the brTPF interface.
Implementation of the sequential, batch-based bind-join algorithm
that uses FILTERs to capture the potential join partners that are
sent to the federation member.
Implementation of the sequential, batch-based bind-join algorithm
that uses UNION clauses with FILTERs inside.
Implementation of the sequential, batch-based bind-join algorithm that uses
a VALUES clause to capture the potential join partners that are sent to the
federation member.
Implementation of the sequential, batch-based bind-join algorithm
that starts by using a VALUES clause exactly as done by
ExecOpSequentialBindJoinSPARQLwithVALUES.Implementation of the sequential, batch-based bind-join algorithm that
uses UNION clauses with variable renaming (as proposed in the FedX
paper by Schwarte et al. 2011, where it is called "bound join").
Implementation of the symmetric hash join algorithm.
To be used for UNFOLD clauses.
An executable operator provides the implementation of the concrete
algorithm that a physical operator is associated with.
Implementations of this interface provide the functionality
to print executable plans in some way.
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.
The purpose of this class is to demonstrate how the HeFQUIN engine can be
used directly within the Java code of other Java projects.
Given an arbitrary number string literals, returns a string literal
whose lexical form is the concatenation of the given strings.
Given a string literal, returns a blank node that is unique per every
possible string literal.
Given a string literal and a datatype IRI, returns a literal whose
lexical form is the lexical form of the given string literal and
whose datatype IRI is the IRI given as second argument.
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 interface captures any kind of federation member.
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.
An object of this class can be used in two ways to process queries over
the federation for which the engine has been set up:
On the other hand, it can be used to process arbitrary queries
and have the result written directly to stdout or to any other
PrintStream, in a format that can be specified.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.Provides shared
HttpClient instances.Vocabulary definitions from https://www.w3.org/ns/hydra/core.jsonld
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.An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (with java-like unicode escape processing).
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
Superclass for all types of elements of JSON documents.
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 logical operator that returns a given solution mapping.
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.Implementations of this interface provide methods to
convert logical operators into physical operators.
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 operator simply returns the tuples given to its constructor.
This class is a version of
MappingOpExtract specifically for
data objects of SourceTypeJSON.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.This interface captures any type of wrapper that can be used to
request data from the federation member that it wraps and, then,
convert this data into RDF.
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 extends
OpService to represent SERVICE clauses that
use PARAMS(...), which is a HeFQUIN-specific extension to SERVICE.This class provides useful functionality related to Jena's
Op interface and the classes that implement it.This exception is thrown when parse errors are encountered.
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 batch-based bind-join algorithm for
SPARQL endpoints that can be used in different variations.
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.Implementations must expose a singleton instance via a public static
get() method on the implementation class.A physical operator that filters the input solution mappings.
A physical operator that returns a given solution mapping.
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 ..
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.
Class used to create physical operators (
PhysicalOperator) from
logical operators (LogicalOperator) by consulting a registry of
factories (PhysicalOpFactory).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 gpAdd operators with the previous join arguments as
subplans.An exception that occurred during query compilation.
This interface captures aspects that are common both to logical plans
and to physical plans.
Simple implementation of
QueryPlanner.An exception that occurred during query planning.
Every object of this class captures a collection of information about
a particular query plan.
This interface captures properties and functionality that is common both
to logical and to physical operators.
Represents a particular property of a query plan as determined and
used during query planning.
Base class functions should be used only after the query result has been consumed.
Simple implementation of
QueryProcessor.An exception that may occur when processing a query.
This interface captures any kind of federation member
that provides RDF-based data access.
A record entry is a pair (ai, vi) where ai is a Cypher variable and vi is a Value.
This interface captures any kind of request processor.
Captures an expected query parameter for REST endpoints.
Represents a request to a particular endpoint of a REST API.
This interface captures any type of wrapper that can be used to evaluate
SPARQL query patterns by means of query rewriting into a query language
supported by the wrapped federation member.
This class can be used to translated RML mappings into the mapping algebra.
Vocabulary definitions from https://kg-construct.github.io/rml-resources/ontology.ttl
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.
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.
Token literal values and constants.
Token Manager.
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
Stats objects into JSON format
and printing them.A record is a "row" of the results of the evaluation of a Cypher query.
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 physical operator but forget to
extend this class here to cover that new operator.Describes the input token stream.
Token Manager Error.
Base class for
RequestProcessor implementations that retrieve TPFResponse.This interface represents triple patterns.
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 do not
need to process the input solution mappings in batches (the filter operator
is a typical example).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.
Captures all kinds of federation members from which data cannot be
retrieved in some RDF-related form and, thus, for which some form
of local (HeFQUIN-side) wrapper is required.
This interface represents a REST endpoint for which HeFQUIN has a wrapper
via which it is possible evaluate SPARQL graph patterns over an RDF view
of the data obtained from this endpoint.
This interface captures any type of wrapper that allows HeFQUIN to interact
with some form of federation member that does not support RDF and SPARQL.
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.