All Classes and Interfaces
Class
Description
An aggregation operator that does not store interim results beyond the final aggregated value.
Common abstract class for implementers of
IQueryMetaContextThis class is intended to be extended by implementors.
Common implementation methods for immutable and volatile tuples.
The degree of accuracy of a cardinality estimate
Advanced interface to a Refinery Interpreter incremental evaluation engine.
The PSystem representation of an aggregation.
The aggregator type annotation describes the type constraints for the selected aggregator.
This aggregator calculates the average of the values of a selected aggregate parameter of a called pattern.
Base class for all flat tuple implementations.
An input key that is identified by a single wrapped object and the class of the wrapper.
Common functionality of left inheritance tuple implementations.
Base implementation of ViatraQueryMatcher.
Base implementation of IPatternMatch.
Default implementation of PQuery.
Base implementation of
IQueryGroup.Base implementation of IQuerySpecification.
For a binary base pattern over an enumerable universe type, computes the reflexive transitive closure (base)*
For a binary base pattern, computes the irreflexive transitive closure (base)+
Augments an aggregator operator with type bindings for the type of values being aggregated and the aggregate result.
Factory class used as an accessor to Collections implementations.
Interface abstracting over a collections technology that provides custom collection implementations.
The type of
IMemoryQuery evaluation hints applicable to any engine
A compact timeline may cosist of an arbitrary amount of moments.
Common reasons for removing constraint through rewriters
An aggregator to count the number of matches a pattern has.
Any constraint that can only be checked on certain SubPlans (e.g.
The description of a delta that specifies how a
Timeline changes.Indicates whether a propagated update event signals the insertion or deletion of an element
Incrementally computes the sum of java.lang.Double values
Eclipse Collections-based multiset for tuples.
Helper that presents a primitive collection as a Set view
A singleton immutable empty memory.
Internal interface for a Scope to reveal model contents to the engine.
A constraint for which all satisfying tuples of variable values can be enumerated at any point during run-time.
Incrementally computes the minimum or maximum of java.lang.Comparable values, using the default comparison
Default Tuple implementation, with statically unknown arity.
Flat tuple with statically known arity of 0.
Flat tuple with statically known arity of 1.
Flat tuple with statically known arity of 2.
Flat tuple with statically known arity of 3.
Flat tuple with statically known arity of 4.
Helper utility class for functional dependency analysis.
Generic signature object implementation.
This is a generic pattern matcher for any Refinery Interpreter pattern, with "interpretative" query execution.
Generic implementation of
IQueryGroup, covering an arbitrarily chosen set of patterns.This is a generic query specification for Refinery Interpreter pattern matchers, for "interpretative" query
execution.
Describes an aggregation operator keyword, potentially with type polymorphism.
Represents the index maintained on the model.
A cache is a simple key-value pair that stores calculated values for specific key objects
Function object that specifies how hints (including backend preferences) shall propagate through pattern calls.
Helper interface to exclude constraints from PBody copy processes
Specialized for identity mask; tuples are stored as a simple set/multiset memory.
This is a role indication interface, implementations may provide a reason about
why a modification is made during PQuery normalization.
The context of the engine is instantiated by the scope,
and provides information and services regarding the model the towards the engine.
An expression evaluator is used to execute arbitrary Java code during pattern matching.
Interface used by the PQueryFlattener to decide which positive pattern calls to flatten
Flattens only if all operand predicates vote for flattening.
This interface contains callbacks for various internal errors from the
.
invalid reference
base indexAn input key identifies an input (extensional) relation, such as the instance set of a given node or edge type, or the direct containment relation.
Listener interface for lightweight observation of changes in edges leaving from given source instance elements.
Implementations of this interface can be used to decide whether a matcher created by an arbitrary backend can
potentially be used as a substitute for another matcher.
An interface for low-level notifications about match appearance and disappearance.
A memory containing a positive or negative number of equal() copies for some values.
A read-only view on a memory containing a positive or negative number of equal() copies for some values.
A tuple that allows modifying the underlying value.
A multi-map that associates sets / multisets / delta sets of values to each key.
How significant was the change? *
Specialized multimap implementation that saves memory
by storing singleton value objects (multiplicity 1) instead of multiset buckets
whenever there is only one value associated with a key.
A multi-lookup whose buckets are multisets.
A multi-lookup whose buckets are sets.
A
PConstraint that implements this interface refers to a list of PQueries.An
IMemory that always contains values with a nonnegative multiplicity.A single column aggregator is used to incrementally compute the aggregate of a multiset of values according to an aggregator operator.
These are the different services which can be provided by an
IQueryRuntimeContext implementation.Adds extra methods to the PQuery interface to initialize its contents.
Data object representing the implication of an input key, in use cases including edge supertypes, edge opposites, node type constraints, etc.
Incrementally computes the sum of java.lang.Integer values
Listener interface for change notifications from the Refinery Base index.
A Viatra Query (incremental) evaluation engine, attached to a model such as an EMF resource.
A Refinery Interpreter engine back-end (implementation)
Listener interface to get notifications when a new managed engine is initialized.
Listener interface for getting notification on changes in an
InterpreterEngine.This class is intended to provide options to a created
InterpreterEngine instance.A general Refinery Interpreter-related problem during the operation of the Refinery Interpreter
engine, or the loading, manipulation and evaluation of queries.
Centralized logger of the Refinery Interpreter runtime.
Interface for a Refinery Interpreter matcher associated with a graph pattern.
Listener interface for model changes affecting different levels of the Refinery Interpreter architecture.
Possible notification levels for changes
A common base class for all exceptions thrown by various Refinery Interpreter APIs.
An implicit common parameter is the "effort" PatternDescription.
Generic interface for a single match of a pattern.
Implementations of this interface aid the query engine with the ordering of poset elements.
A provider interface useful in various registry instances.
This interface provides methods to trace the
PTraceables of a transformed PQuery produced by
a PDisjunctionRewriter.Internal interface for a Refienry Interpreter query specification.
This interface is a collector which holds every API that is provided by the engine to control
the operation of the backends.
A Query Backend Factory identifies a query evaluator implementation, and can create an evaluator instance (an
IQueryBackend) tied to a specific Refinery Interpreter engine upon request.A provider interface for
IQueryBackendFactory instances.Provides query evaluation hints consisting of the Engine default hints and
the hints provided by the pattern itself.
Provides information on already cached queries to query evaluator backends at runtime.
Generic interface for group of query specifications.
Provides metamodel information (relationship of input keys) to query evaluator backends at runtime and at query planning time.
An algorithm that builds a query plan based on a PSystem representation of a body of constraints.
A
PConstraint that implements this interface refers to a PQuery.An internal interface of the query backend that provides results of a given query.
This interface exposes API to request
IQueryResultProvider for PQuery instances.Provides instance model information (relations corresponding to input keys) to query evaluator backends at runtime.
Listens for changes in the runtime context.
API interface for a Refinery Interpreter query specification.
Implementations of this interface take an arbitrary number of input relations with their contents and compute the
tuples of a single output relation.
This is the internal API of
IPTraceableTraceProvider expected to be used by
copier and rewriter implementations.An
IMemory that always contains values with a 0 or +1 multiplicity.Represents both mutable and immutable tuples
Common superinterface of enumerable and deferred type constraints.
Static internal utility class for implementations of
ITypeConstraints.Internal interface for the query backend to singal an update to a query result.
Helper interface to get values from a tuple of variables.
Helper interface to ease the naming of the new variables during flattening
Instance tuples are of form (x), where object x is an instance of the given Java class or its subclasses.
Tuple that inherits another tuple on the left.
Incrementally computes the sum of java.lang.Long values
Wraps a Mapinvalid input: '<'T, Integer> (mapping elements to non-zero multiplicities) into an
IMemoryView.Multimap-based implementation to contain and query traces
Internal marker type, must only be instantiated inside implementors of IMultiLookupImpl
A masked
Resumable implementation, which maintains lazy folding per tuple signature.A tuple that transparently provides a masked (transformed) view of another tuple.
Indexes a collection of tuples by their signature (i.e.
A default implementation of
IMatchUpdateListener that contains two match processors, one for appearance, one
for disappearance.This aggregator calculates the maximum value of a selected aggregate parameter of a called pattern.
A partial and read-only Map implementation, mapping elements to multiplicities backed by an
IMemoryView.This aggregator calculates the minimum value of a selected aggregate parameter of a called pattern.
This implementation does not store any traces and scales to NOP for every traceability feature.
Specialized for nullary mask; tuples are stored as a simple set/multiset memory.
A container describing query annotations
Represents a constraint application on a single parent SubPlan.
An annotation parameter referencing a query parameter by name.
A set of constraints representing a pattern body
This class can create a new PBody for a PQuery.
A disjunction rewriter for creating a normalized form of specification, unifying variables and running basic sanity
checks.
A disjunction is a set of bodies representing separate conditions.
An abstract base class for creating alternative representations for PDisjunctions.
A rewriter that stores the previously computed results of a rewriter or a rewriter chain.
Represents a base relation defined by the instance set of an enumerable PConstraint; there are no parent SubPlans.
Represents a natural join of two parent SubPlans.
Abstract superclass for representing a high-level query evaluation operation.
A descriptor for declared PQuery parameters.
Values of this enum describe a constraint to the calling of patterns regarding its parameters.
Represents an error that was detected while the
PQuery object was built from a source.Represents a projection of a single parent SubPlan onto a limited set of variables.
Utility class for using PQueries in functional/streaming collection operations effectively
Internal representation of a query / graph pattern (using a constraint system formalism),
to be interpreted by a query evaluator (
IQueryBackend).This rewriter class holds the query flattening logic
Represents header information (metainfo) about a query.
This class was motivated by the similar Preconditions class from Guava to provide simple precondition checking
functionality.
No constraints, and no parent SubPlan, just a (possibly empty) set of a priori known (input) variables.
Marker interface for PSystem elements that can be traced.
Object responsible for computing and caching static query analysis results.
Provides Refinery Interpreter with additional hints on how a query should be evaluated.
Each instance of this class corresponds to a given hint option.
Represent an exception that occurred while initializing the specification of a query.
Internal class for wrapping a query result providing backend.
Defines a scope for a Refinery Interpreter engine, which determines the set of model elements that query evaluation
operates on.
A constraint which prescribes the evaluation of custom Java logic that takes an arbitrary number of input relations
and produces one output relation.
Uniform way of requesting result providers for pattern calls within queries.
A resumable lazily folds its state towards higher timestamps.
An exception to wrap various issues during PDisjunction rewriting.
This class was motivated by the similar Sets class from Guava to provide simple set manipulation
functionality.
A piece of data associated with a direction.
A provider implementation that always returns the same object instance.
An immutable memory view that consists of a single non-null element with multiplicity 1.
A timeline which solely consists of one timestamp value, representing a single insertion.
Helpers dealing with optionally present statistics information
A plan representing a subset of (or possibly all the) constraints evaluated.
Single entry point for creating subplans.
This aggregator calculates the sum of the values of a selected aggregate parameter of a called pattern.
A timeline describes the life cycle of a piece of data (typically a tuple in a relation) as a sequence of moments.
Utility class for creating
Timelines.Default timely implementation that covers all cases.
Timely specialization for identity mask.
A timely memory implementation that incrementally maintains the
Timelines of tuples.Timely specialization for nullary mask.
Timely specialization for unary mask.
Immutable tuple.
Specifies select indices of a tuple.
Common static factory utilities for tuples.
Represents an enumerable type constraint that asserts that values substituted for the given tuple of variables
form a tuple that belongs to an enumerable extensional relation identified by an
IInputKey.Represents a non-enumerable type constraint that asserts that values substituted for the given tuple of variables
form a tuple that belongs to a (typically non-enumerable) extensional relation identified by an
IInputKey.A judgement that means that the given tuple of variables will represent a tuple of values that is a member of the extensional relation identified by the given input key.
Specialized for unary mask; tuples are indexed by a single column as opposed to a projection (signature) tuple.
Union-find data structure implementation.
A unmasked
Resumable implementation, which maintains lazy folding without caring about tuple signatures.A kind of deferred constraint that can only be checked when a set of deferring variables are all present in a plan.
This class provides a volatile tuple view with a given mask of a given tuple instance.
A masked tuple implementation that allows modifying the backing tuple.
Mutable tuple without explicit modification commands.