All Classes and Interfaces
Class
Description
AbandonSort is the exception thrown from
AbortableComparator to abandon a sort.Abstract implementation of DataBag.
Hash join algorithm
This code materializes one input into the probe table
then hash joins the other input from the stream side.
Abstract base class for registries with exact and prefix lookup.
Aggregate - statistical standard deviation - population (i.e.
Aggregate - statistical standard deviation - sample (i.e.
Aggregate - statistical variance - population (i.e.
Aggregate - statistical variance - sample (i.e.
An Accumulator is the processor for each section of a group, so
there is one Accumulator for each group key.
Accumulator that passes down every value of an expression
Factory to create accumulators.
Adapter that provides
FileManager for RIOT by translating the operations.Adapter from Jena core LocationMapper to RIOT LocationMapper
Adapter providing RIOT interface
WriterGraphRIOT over an old-style
Jena RDFWriterI.Syntax element and framework execution for custom aggregates.
The null aggregate (which can't be written in SPARQL)
calculates nothing but does help remember the group key.
Registry of custom aggregates
There is only a single global registry of aggregates - it affects parsing
and parsing happens before Context or Execution makes sense.
An Aggregator is the processor for the whole result stream.
Aggregate that does everything except the per-group aggregation that is needed for each operation
Utilities to produce SPARQL algebra
Class used to compile SPARQL queries into SPARQL algebra.
Helper class for converting an algebra expression into a quad form
Alt membership
Apply a fixed set of inference rules to a 3-tuple.
An Args is an ExprList with a flag for DISTINCT.
ARQ - miscellaneous settings
Internal constants - configuration is in class ARQ
Load ARQ functions ().
Token literal values and constants.
Token Manager.
Assignment: does not change the value of an existing binding.
A collection of convenience operations for HTTP level operations
for RDF related tasks which are performed asynchronously.
Async parsing - parses a list of files or URLs on a separate thread.
Details of a "WWW-Authenticate" header.
Registry of (username, password) for a remote location (endpoint URI and optional realm.
URI, and optional realm, as a value-equality pair.
An authentication environment.
Parser for authentication header strings for both challenge and credentials.
Authorization scheme
Struct for the authentication information.
Bag membership
Factory for constructing different types of
DataBag instances.Core datastructures needed for RDFS for one vocabulary.
A class whose purpose is to give a name to a collection of triples.
Batch a stream into triples and/or quads.
Interface encapsulating a mapping from a name to a value.
Special purpose binding for nothing.
Special purpose binding for just one name/value slot.
Special purpose binding for two name/value slots.
Converted from Bindings to SPARQL result set encoded in Protobuf
Converted from Bindings to SPARQL result set encoded in Thrift
A binding implementation that supports 3 binding pairs.
A binding implementation that supports 4 binding pairs.
Machinery encapsulating a mapping from a name to a value.
Build Bindings.
Language for reading in a stream of bindings.
Operations on Bindings
Writer for the RDF Tuples language
Project a binding, given a specific collection of visible variables
Common framework for projection;
the projection policy is provided by
abstract method
BindingProjectBase.accept(Var)Project only named variables (i.e.
Special purpose binding for the root of all bindings.
Relationship between a node (subject) and it's bNode label (object/string)
Interface to allocators for blank nodes.
Allocate blank nodes according a counter.
A variant of
BlankNodeAllocatorHash where a fixed seed is used so
repeated runs produce identical allocationsAllocate blank nodes by creating a randomly generated blank node.
Allocate bnode labels using a per-run seed and the label presented.
Allocate blank nodes according to the label given.
Get the bnode label - a non-bnode cause a type failure
Relationship between a node (subject) and it's bNode label (object/string)
BufferingDatasetGraph - stores operations as adds/deletes of "triples"
(default graph) and "quads" (named graphs)
A graph that buffers changes (including prefixes changes) until
BufferingGraph.flush() or
BufferingGraph.flushDirect() is called.A
PrefixMap that buffers changes until BufferingPrefixMap.flush() is called.A
PrefixMapping that buffers changes until BufferingPrefixMapping.flush() is called.Build a prefixmapping, tagged (prefixmap pairs) or (prefixmapping pairs)
each pair being a PrefixName, but must end : and an IRI.
Convert literals to canonical form.
Code for all casting between XSD datatypes.
Interface for custom service execution extensions that handle
the iterator over the input bindings themselves
Turns a ServiceExecutor into a chaining one.
Functions for checking nodes, triples and quads.
Helper for loading class instances
Access to a
NodeValue which is a collection (NodeValueSortKey).Base class for StreamRDF implementations which store received
<T>
objects in a Collection.Collector stream for quads.
StreamRDF implementations which stores received triples and quads
in a
Collection.Collector stream for triples.
Inference setup for RDFS over some space of 3-tuples of type
<T>.Constants relating to RDFS inference.
container - super class of bag/alt/seq - rdfs:member
A restricted view of MediaType: type, subtype and charset.
Function that returns the value of a context setting.
A class for setting and keeping named values.
Context builder component.
Utils to work with
Context.Encode for a www-forms.
Wrapper for Commons CSV parser.
Class to help implementations of RDFS inference.
A collection of Tuples.
Query is over a Dataset, a collection of named graphs
and a default graph (also called the unnamed graph).
Use only with
Datasets that support transactions.Makes
Datasets in various ways.DatasetGraph: The graph representation of an RDF Dataset.
DatasetGraph framework : readonly dataset need only provide find(g,s,p,o), getGraph() and getDefaultGraph()
although it may wish to override other operations and do better.
DatasetGraph framework.
BufferingDatasetGraph interface
Base class for implementations of a DatasetGraph as a set of graphs.
Interface for making graphs when a dataset needs to add a new graph.
A read-only
DatasetGraph that applies a filter testing all triples and quads
returned by accessing the data.A
DatasetGraph backed by an QuadTable.Implementation of a
DatasetGraph as an extensible set of graphs.Implementation of a DatasetGraph as an extensible set of graphs where graphs are held by reference.
A
DatasetGraph class for support of DatasetGraphs that do nothing.DatasetGraph of a single graph as default graph.
A DatasetGraph base class for pure quad-centric storage.
Read-only view of a DatasetGraph.
An always empty
DatasetGraph that accepts changes but ignores them.A DatasetGraph base class for triples+quads storage.
Marker interface that indicates a DatasetGraphWrapper
is one that defines a different view on the base dataset data.
An always empty
DatasetGraph.An implementation of a Dataset.
An assembler that creates datasets that do nothing, either a sink or a always empty one.
An assembler that creates a dataset around a single graph.
Internal Dataset factory + graph equivalents.
date(expression) => XSD dateTime
Attempt to convert an expression to an XSD dateTime.
XSD date/time 7-component model.
This data bag will gather items in memory until a size threshold is passed, at which point it will write
out all of the items to disk using the supplied serializer.
DescribeHandler that calculates the bNode closure.
A DescribeHandler provides the description of a resource.
Factory for describe handlers
Registry of DescribeHandlers.
This data bag will gather distinct items in memory until a size threshold is passed, at which point it will write
out all of the items to disk using the supplied serializer.
This class is like
DistinctDataBag except that you are informed if the
item you just added was known to be distinct.Vocabulary definitions from doap.ttl
Client for dataset operations over HTTP.
Value of e
Do any of FN_Adjust(date/time)ToTimezone
ARQ extension to SPARQL which provides for dynamic function invocation
SPARQL coalesce special form.
IF(expr, expr, expr)
SPARQL filter function
IRI(expr), one argument, SPARQL standard form.
IRI(base, expr).
Indirect to the chosen regular expression implementation
SPARQL CONCATs
Create a literal from lexical form and datatype URI
Create a literal from lexical form and language tag
This class is an alternative name for E_IRI.
This class is an alternative name for E_IRI2.
Vocabulary definitions from EARL.rdf
Auto-generated by schemagen
Element - abstract class for all pattern elements
Element1 - elements that have a single subElement.
ElementDataset - an association of an RDF Dataset
(graph level version) with a query pattern.
The syntax element for "Exists" in a pattern.
A constraint (Filter) in a query expression.
A number of graph query elements.
LATERAL
An optional element in a query.
Evaluate a query element based on source information in a named collection.
The syntax element for "Not Exists" in a pattern.
An optional element in a query.
A SPARQL BasicGraphPattern (SPARQL 1.1)
A SERVICE pattern - access a remote SPARQL service.
Transformation function on an Element
Clean a SPARQL and ARQ syntax.
Create a copy if the Element(s) below has changed.
A bottom-up application of a transformation of SPARQL syntax Elements.
Transformation function on an Element that does nothing.
An
ElementTransform which replaces occurrences of a variable with a Node value.The syntax element for a SPARQL BasicGraphPattern (SPARQL 1.0)
A ElementVisitor that does nothing.
An element visitor that walks the graph pattern tree for one query level.
An item of a StreamRDF, including exceptions.
Payload types of
EltStreamRDF elementsInterface for tests when two nodes are considered "equal".
An Error handler captures the policy for dealing with warnings, errors and
fatal errors.
An error handler that counts errors and warnings.
Function that evaluates an expression.
Class to provide type-safe eval() dispatch using the visitor support of Op
Example function - checks for even integers.
Interface for receiving events
The event system - the single, global event manager control the registration and delivery of events.
Execution builder for remote queries.
Function that prints the system time to stderr at the point of execution.
Execution logging for query processing on a per query basis.
Information level for query execution.
Group aggregation functions calculated a value during grouping and placed in the
output binding.
Visitor class to run over expressions and initialise them
Exception for a dynamic evaluation exception.
Exception for a dynamic evaluation exception due to wrong type.
The root of all expression exceptions
A function in the expression hierarchy.
An expression that is constant (does not depend on evaluating a sub expression).
A function that has a single argument
A function of two arguments
A function of three arguments
A function which takes N arguments (N may be variable e.g.
A "function" that executes over a pattern
Marker, used in place of a null.
A copying transform that applies an ElementTransform syntax pattern of
E_Exist and E_NoExists
A copying transform that applies an Op Transform to the algebra operator of E_Exist and E_NoExists
An expression transform that simplifies expressions by constant folding
wherever possible
An expression transformer that will expand user defined function expressions
so they do not explicitly rely on other user defined functions.
Special version of ExprTransform for applying a node transform on syntax
(Elements) only
An expression transformer that substitutes another expression in place of variables
RDF-star triple term in an expression (AKA quoted triple).
Exception for a dynamic evaluation exception caused by a type mismatch.
Exception for an undefined expression (including unbound variable)
Exception for an undefined function.
Misc support for Expr
An expression that is a variable in an expression.
An expr visitor that applies a OpVisitor to the algebra operator of E_Exist and E_NoExists
Convert all visit calls on the expressions in a call to a generic visit operation for expression functions
Convert all visit calls on the expressions in a call to a generic visit operation for expression functions
Adds some caching of created nodes - the caching is tuned to RIOT parser usage
Multipart HTTP PUT/POST.
Minimal interface to find by pattern
Output expressions in SPARQL syntax
Presentation forms of various kinds of objects.
abs(expression)
XPath and XQuery Functions and Operators 3.1
Boolean Equivalent Value
ceiling(expression)
XPath and XQuery Functions and Operators 3.1
fn:dateTime(xsd:date, xsd:time) -> xsd:dateTime
XPath and XQuery Functions and Operators 3.1
floor(expression)
fn:format-number : 2 or 3 arguments.
Function for XPath fn:matches
Boolean Equivalent Value
round(expression)
fn:substring-after
fn:substring-before
Function that concatenates arguments as strings.
string contains - fn:contains
fn:ends-with
string length - F&O operation
lowercase
fn:normalizeSpace
fn:replace
fn:starts-with
substring(string, start[, length]) - F&O style
uppercase
fn:implicit-timezone
Vocabulary definitions from FOAF.rdf
A
PMap of Nodes: Node->Node->Node->PersistentSet<Node>A
PMap of Nodes: Node->Node->PersistentSet<Node>A
PMap of Nodes: Node->PersistentSet<Node>Interface to function extensions of the expression evaluator.
Implementation root for custom function evaluation.
Support for functions of zero arguments.
Support for functions with one argument.
Support for functions with two arguments.
Support for functions of three arguments.
Support for functions with four arguments.
Support for functions with five arguments.
Environment passed to functions
Environment passed to functions -- see also
ExecutionContextInterface for function factories.
A library of functions for working with
Graph.Support for testing.
A
GNode pair of (graph, node in graph) with an abstracted "findable"
operation so it work for graphs and collections of triples.Ways to make graphs and models
RDFS graph over a base graph.
Some operations on graphs
RDFS graph over a base graph.
A graph that performs adds and deletes by silently ignoring them.
This class provides the Jena Graph interface to a remote SPARQL endpoint.
In-memory, thread-safe, transactional graph.
Immutable graph that is the view of a union of graphs in a dataset.
Graph utilities.
Implement a Graph as a view of the DatasetGraph.
Graph wrapper
Invariant empty graph.
Client for the
SPARQL 1.1 Graph Store Protocol.
Indexes bindings so that they can be search for quickly when a binding to all the
variables is provided.
A six-way
QuadTable using all of the available forms in QuadTableForm.Handle HTTP content type
JVM wide settings.
Class of HTTP Exceptions
Operations related to SPARQL HTTP requests - Query, Update and Graph Store protocols.
This is a collection of convenience operations for HTTP requests, mostly in
support of RDF handling and common, basic use cases for HTTP.
Constants related to SPARQL over HTTP
A collection of convenience operations for HTTP level operations
for RDF related tasks.
A
HttpRequestModifer allows the application to HTTP query parameters and
HTTP headers that will be used to create an HttpRequest.
HttpStatusCode enum class, for status codes based on various HTTP RFCs.
Creates
IndexTables for use by
QueryIterMinus.Interface for indexes that are used for identifying matching
Bindings when
QueryIterMinus is trying to determine
which Bindings need to be removed.Find in one graph of a dataset.
Find in one graph.
A
StreamRDF that applies RDFS to its inputs.ARQ initialization.
Jena start-up lifecycle initialization.
RIOT initialization.
An
Assembler that creates in-memory Datasets.Isomorphism utilities, based on in-order lists.
Interface for choosing the pairs of node that can be map[ped for isomorphism.
Simple isomorphism testing for collections of tuples of nodes.
Record the mapping of a node.
Simple isomorphism testing for on unordered collections.
Test whether a
NodeValue is an triple term.Lift and reverse.
Plain iterator version to add "abort" functionality.
Parsers that support the iterator pattern for receiving the results of parsing.
An iterator that reads sparql result set domain elements from a
underlying gson JsonReader.
Testing/development convenience.
Pull version of processing
StreamRDF for StreamRowRDFIterator over a Thrift-encoded RDF stream.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (with java-like unicode escape processing).
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (with java-like unicode escape processing).
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (with java-like unicode escape processing).
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (with java-like unicode escape processing).
Code for using the general facilities of the location mapper/ filemanager subsystem
and set up for Jena usage.
Conversion to/from Titanium JSON-LD objects
API to various join algorithms
JoinKey for hash joins
The builder can emit a key every time build() is caller
and it can be continued to be used.
A class that is the front door to the JSON subsystem
Token literal values and constants.
Token Manager.
Access json datastructures
Builder pattern for JSON.
Build a JSON structure
Json (extended) parser
Extensions:
Use of ', """ and ''' for strings
Bare words for strings in maps (JSON objects)
Hex numbers
Objects with duplicate keys are a warning (keeps last)
JSON parser
Parser debugging
ARQ supports an extension query type:
A low level streaming JSON writer - assumes correct sequence of calls (e.g.
Allocation of Nodes (blank nodes usually) based on the graph and scope.
Map from _:* form to bNodes or variables.
A "language" (syntax).
Builder for RDF languages (Syntaxes).
Common operations for RIOT token stream parsing - not the implementation LangRIOT.
JSON-LD 1.1
ReaderRIOT.N-Quads.
N-Triples.
N-Quads, N-triples parser framework, with both push and pull interfaces.
Base for JavaCC parser of RDF languages.
Support function for language parsing.
RDF-JSON.
Interface for tokenizer-based parsers
Language tags: support for parsing and canonicalization of case.
TriG.
Turtle.
The main engine for all things Turtle-ish (Turtle, TriG).
Constants related to support for the Leviathan Function Library which is a library of extension functions
originally implemented by the dotNetRDF Project.
A slow "index" that looks for data by searching linearly through a set.
Base class for list related operations
List operation - object can't be a list.
List membership with index : property function to access list using index Usage:
?list :listIndex (?index ?member)
List length : property function to get the length of a list.
List membership : property function implementation of list:member.
localname(expression)
Alternative locations for URIs.
Interface to things that open TypedStreams from a place
LocatorClassLoader provides access to Java resources.
Location files in the filing system.
Support for resources using the "ftp:" scheme
Support for resources using the "http:" and "https" schemes
Locator for the resource called "-" mapped to
System.in.Location files in a zip file
Mappers
Bridge between Node and X; 3-tuples and Triple/Quad
Assist with naming symbols by URI.
Maps A's to B's, based on a scope S
Allocate a B, given some A.
Match by S/P/O where
X is the RDF term representation (Node, NodeId) and
T is the tuple (triple, quad, tuple) representation.Match triples, quads, with wildcard rules (null or
Node.ANY are wildcards).Match a 3-tuple, which might have wildcards, applying a fixed set of inference rules.
The vocabulary, with transitive closure of subClass and subProperty, as a
Match.max(expression, expression)
A media range is a media type used in content negotiation.
A structure to represent a
media
type.
min(expression, expression)
Client for the
SPARQL 1.1 Graph Store Protocol
working at the Model/Resource API level.
Output abstraction for the
ProgressMonitor.Dataset assembler supporting shared resources by
ja:name.A graph with an associated name.
namespace(expression)
Node compare operations - these compare operations are not value sensitive.
Some node constants
Various convenience helper methods for converting to and from nodes
Presentation utilities for Nodes, Triples, Quads and more.
Processor for output of RDF terms.
Provide implementations of the operations of
NodeFormatter in terms
of core operations for each node type.Node formatter for Turtle using single line strings
Node formatter for pretty-printed Turtle.
Implementation of node-centric functions.
Map nodes to nodes.
Map nodes to string (usually, blank nodes to labels).
Map nodes to blank node representations.
Convert nodes to nodes - Vars may need to be translated into Vars.
A
NodeTransform substituting variables for Nodes.Node utilities.
XSD Duration
A NodeValue that is a lang tagged literal (rdf:langString).
A NodeValue that isn't anything else - unrecognized literals, URIs and blank nodes.
The code parts of arithmetic operations on
NodeValues.A
NodeValue that supports collation value for a string.Function that accesses the current time (the time the query started).
Function that accesses the current time and returns in the timezone of the query engine.
Null writer for datasets - can be used for RDF graphs via the adapter in from RiotWriterLib
General representation of an
NodeValue for JavaScript and other scripting
languages used to write SPARQL custom functions.Super class for operators that do not combine other operators
Super class for operators that operate on a single sub-operation (i.e.
Super class for operators that combine two sub-operators
Convert an Op expression in SPARQL syntax, that is, the reverse of algebra
generation.
Conditional execution - works with streamed execution and is known to safe to
evaluate that way (no issues from nested optionals).
N-way disjunction.
Turn an Op expression into an execution of QueryIterators.
Marker for extension points
Execution will be per-engine specific
This is the operation in standard SPARQL 1.1 OpAssign is specifically in
support of LET.
Manage extension algebra operations
Do-nothing class that means that tags/labels/comments can be left in the algebra tree.
Functions relating to
Ops.Mark solution modifiers
General procedure in algebra evaluation (a stored procedure facility)
Syntax (ARQ extension):
CALL <iri>(?x, ?y+3).Property functions (or any OpBGP replacement)
Execution will be per-engine specific
Algebra operation for a single quad.
A list of quads.
The main Op used in converting SPARQL algebra to quad form.
A "sequence" is a join-like operation where it is known that
the output of one step can be fed into the input of the next
(that is, no scoping issues arise).
Optimization of algebra expressions.
The minimal optimizer.
The standard optimization sequence.
Top N from a stream of items - for small N, better than ORDER BY + LIMIT N
Algebra operation for a single triple.
Get vars for a pattern
A visitor helper that maps all visits to a few general ones
A visitor helper that maps all visits to a few general ones.
A visitor helper that maps all visits to a few general ones.
Apply a visitor to the whole structure of Ops, recursively.
A table of
TupleType tuples that uses an internal order recorded via TupleMap.Deliver s, p, o
Interface for all formatters of result sets.
Path element of the form {,N} {N,} {N,M} but not {N}
A path element that, on evaluation, switches to multi-cardinality semantics.
One or more - unique results
One or more - all results
A Parameterized SPARQL String is a SPARQL query/update into which values may
be injected.
A collection of parameters for HTTP protocol use.
This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
This exception is thrown when parse errors are encountered.
Splitter for parser handlers.
Tracing parser handler - logs what the core parse sees
Handle forms like (base ...) and (prefix...)
where the syntax modifies the enclosed sub term.
Resolve syntactic forms like (base ...) and (prefix...) where the syntax modifies
the enclosed sub term.
Wrapper parser handler with pass-through for all operations.
ParserProfile is specific to parsing, providing the operations needed by a parser to
create IRIs/Nodes/Triples/Quads at the point in the parsing process when the line and
column are available to put in error messages.ParserProfileStd uses a FactoryRDF to create items in the parsing
process.(Username, password) pair, with value-equality semantics
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
A class whose purpose is to give a name to a collection of triple paths.
PathEngine, SPARQL semantics
Path evaluation - public interface
Match a graph node + basic graph pattern.
A mutable triple pattern
Get the variables potentially bound by an element.
Protobuf type
RDF_ANYProtobuf type
RDF_ANYProtobuf type
RDF_BNodeProtobuf type
RDF_BNodeProtobuf type
RDF_DataTupleProtobuf type
RDF_DataTupleProtobuf type
RDF_DecimalProtobuf type
RDF_DecimalProtobuf type
RDF_GraphProtobuf type
RDF_GraphProtobuf type
RDF_IRIProtobuf type
RDF_IRIProtobuf type
RDF_LiteralProtobuf type
RDF_Literal
Prefix declaration
Prefix declaration
A prefix name (abbrev for an IRI)
A prefix name (abbrev for an IRI)
Protobuf type
RDF_QuadProtobuf type
RDF_QuadProtobuf type
RDF_REPEATProtobuf type
RDF_REPEATProtobuf type
RDF_StreamProtobuf type
RDF_Stream
StreamRDF
StreamRDF
Protobuf type
RDF_TermProtobuf type
RDF_TermProtobuf type
RDF_TripleProtobuf type
RDF_TripleProtobuf type
RDF_UNDEFProtobuf type
RDF_UNDEFProtobuf type
RDF_VarProtobuf type
RDF_VarProtobuf type
RDF_VarTupleProtobuf type
RDF_VarTupleCommon case: take a node (subject) and
calculate something else, assign it to a
variable (object)
Common case: take a node (object) and
calculate something else, assign it to a
variable (subject)
The case of:
subject is a list
object is a list
call the implementation with one binding at a time
The case of:
subject is a list
object is a node, not a list
call the implementation with one binding at a time
Common, simple case:
arguments are not lists
attempt to put values in for any bound variables
call the implementation with one binding at a time
Common, simple case:
subject argument is not a list
object is a list
call the implementation with one binding at a time
Value of pi
An implementation of
QuadTable based on the use of nested PMaps.A
TripleTable employing persistent maps to index triples in one particular slot order (e.g.A partial implementation of
TupleTable that contains some common state management.Entry in a prefix map.
Functions related to
PrefixMap.Algorithms over
PrefixMap to abbreviate and expandInterface for lightweight prefix maps, this is similar to
PrefixMapping from Jena Core but it omits any reverse lookup
functionality.Provided
PrefixMap for a PrefixMapping.Abstract base implementation of a
PrefixMap which provides
some implementations of API methods.Factory which provides prefix maps
Base of always empty prefix maps
PrefixMapSink and PrefixMapZero.A prefix mapping based on global and local mappings.
Provided
PrefixMapping for a PrefixMap.Framework for implementing
PrefixMapping.A
PrefixMapping implemented as a pair of in-memory maps.Sink
PrefixMapping.Immutable empty
PrefixMapping.Delay touching the
DatasetGraph.prefixes() until an
operation (method call) happens.Empty prefix map that throws away updates.
In-memory implementation of a
PrefixMap.A PrefixMap that traps update operations on a wrapped prefix map
Always empty, immutable prefix map
Function that prints it's argument to stdout (debugging aid)
A StreamRDF which displays the items sent to the stream.
Print a logging message on every token
Interface for procedure factories.
Adapter between property functions and server procedures
When called, this wrapper reconstructs the usual property function calling conventions.
Send ticks to a
ProgressMonitor as an iterator moves forward.Interface
ProgressMonitor - monitor progress.Simple
ProgressMonitor that records time and ticks but does not print anythingThe counting state of a
ProgressMonitor.Progress monitor - output lines to show the progress of some long running operation.
Send ticks to a
ProgressMonitor as triples and quads
are sent along the StreamRDF.Prologue - combines with PrefixMapping (the RIOT Prologue uses PrefixMap)
Basic property function handler that calls the implementation
subclass one binding at a time
Basic property function handler that calls the implementation
subclass one binding at a time after evaluating the arguments (if bound).
Interface for extension factories registered with the extension registry.
Exception used to report that a required property is missing.
Class representing an argument (subject or object position) of a property function.
Converted from SPARQL result set encoded in Thrift to Bindings
Protobuf RDF (wire format items) to StreamRDF terms (Jena java objects)
Convert to and from Protobuf wire objects.
Operations on binary RDF using Google Protobuf.
Specialist.
Enum for HTTP push operations
Library of operations related to query execution.
Accumulate quads (including allowing variables) during parsing.
Accumulate quads into a Sink (including allowing variables) during parsing.
Accumulate quads (excluding allowing variables) during parsing.
Accumulate quads (excluding allowing variables) during parsing.
A class whose purpose is to give a name to a collection of quads
A simplex or multiplex table of
Quads.Six covering table forms and machinery to determine which of them is best suited to answer a given query.
The data structure for a query as presented externally.
QueryBuildException is exception for all exceptions during query execution
construction.
Indicate that a query execution has been cancelled and the operation can't be called
QueryDeniedException indicates an invalid condition or constraint was
encountered during query evaluation and the execution was abandoned.Main part of a QueryEngine - something that takes responsibility for a complete query execution
A
QueryEngineFactory builds query Plans via
QueryEngineFactory.create(Query, DatasetGraph, Binding, Context) or
QueryEngineFactory.create(Op, DatasetGraph, Binding, Context).Default processing for a DatasetGraphWrapper - unwrap and repeat
Same as QueryEngineMain except transform to quads
"Reference" query engine - this simply executes the algebra expression as-is
using a simple (non-scalable) execution strategy that follows the definition
of SPARQL as closely as possible.
QueryException is root exception for all (intentional) exceptions associated with
query parsing and execution.
Exception class for all operations in the SPARQL client library.
Query execution interface working at the Graph-Node-Triple level.
QueryExec that delays making the QueryExec until needed by a query operation
This means timeouts and initialBinding can still be set via the QueryExecMod.The common elements of a
QueryExec builder.QueryExecBuilder view over a QueryExecutionBuilder
All the SPARQL query result forms at the graph-level.
Query execution for local datasets - builder style.
QueryExecException indicates a condition encountered during
query evaluation.
A
QueryExec implementation where queries are executed against a remote
service over HTTP.Aspects of a building a
QueryExec that can be changed before use.This class is for the outcome of
QueryExec.Some utilities for query processing.
A interface for a single execution of a query.
QueryExecution for a QueryExec working at the Graph-Node-Triple level.
Common elements of query execution building.
Query Execution for local datasets - builder style.
Query execution that delays making the QueryExecution until needed by exec
Query Execution for local datasets - builder style.
QueryExecutionFactory provides some convenience operations for making
QueryExecution objects.A query execution implementation where queries are executed
against a remote service over HTTP.
QueryFatalException is such that the query aborts do to some
problem (this might be an internal error or something in the way the query
builds or executes).
This class provides the general machinery for iterators.
This class supports a QueryIter that takes one QueryIterator as input.
This class marks a QueryIter that takes two QueryIterators as input.
Binary operation done by looping on the left, and materializing the right - this is not streamed on the right
See also QueryIterRepeatApply
QueryIterator that calls a list of abort actions when a cancel happens.
Add
(var, matchTriple) to a QueryIterator.Extend each solution by a (var, expression)
Extend each solution by a (var, node)
When used with mustBeNewVar=false, this is a join.
Root of query iterators in ARQ.
This class provides the general machinery for iterators.
A caching QueryIterator.
Query iterator that checks everything was closed correctly
Intercept and print iterator operations
A query iterator which allows remapping variables to different names
Wrap a QueryIterator so it can have some/all of it's methods intercepted.
Yield new bindings, with a fixed parent, with values from an iterator.
A query iterator that joins two or more iterators into a single iterator.
Iterator over another QueryIterator, applying a converter function
to each object that is returned by .next()
An iterator that returns at least one element from another iterator
or a default value (once) if the wrapped iterator returns nothing.
Diff by materializing the RHS - this is not streamed on the right
A QueryIterator that suppresses items already seen.
Memory limited QueryIterDistinct
Implementation skeleton for DISTINCT and REDUCED.
Filter bindings for distinguished variables only
Currently unused.
Yield new bindings, with a fixed parent, with values from an iterator.
Filter a stream of bindings by a constraint.
Hash left join.
Hash left join.
Hash left join.
Minus by materializing the RHS - this is not streamed on the right
Nested Loop Join (materializing on the left, streaming on the right)
A simple, dependable join.
Nested Loop left Join (materializing on the right, streaming on the left)
A simple, dependable join.
Closeable empty query iterator
Turn an normal java.util.Iterator (of Bindings) into a QueryIterator
QueryIterator for a procedure.
An iterator that applies a condition.
Execute a projection in the middle of an execution.
Repeatedly execute the subclass operation for each Binding in the input iterator.
The root binding is one-row, usually no columns making it the join identity.
Deprecated.
To be removed.
A singleton iterator
Iterator until a limit is reached.
Sort a query iterator.
This class supports a QueryIter that uses a single sub iterator.
Track a QueryIterator
Execute each sub stage against the input.
A query iterator that yields the same thing N times.
QueryParseException is root exception for all (intentional) exceptions
from the various parsers where the error is to do with the syntax of a query.
Base class parsers, mainly SPARQL related
Enum of different ways to send a SPARQL query over HTTP
Serialize a query into SPARQL or ARQ formats
Interface for query serializer factories, these may be registered with the
SerializerRegistry thus allowing the serialization of queries to be
customisedA single answer from a SELECT query.
Implementation of QuerySolution that contains the canonicalization and casting code.
Implementation of QuerySolution that is backed by an in-memory map.
Support for transformation of query abstract syntax.
QueryType: one of the different kinds of query.
Query visitor pattern
Interface for writing quoted strings for Turtle, TriG, N-triples and N-Quads
Quoted string output - single line, settable quote character and char space.
Escape processor for N-Triples/N-Quads
Escape processor for Turtle.
Writing URI strings for Turtle etc.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
The set of fields this struct contains, along with convenience methods for finding and manipulating them.
General purpose reader framework for RDF (triples and quads) syntaxes.
Constants for writable formats
Modifier for an RDF Format
The rdfjs/representation-task-force
API for RDF terms.
RDF-JSON.
Central registry of RDF languages and syntaxes.
An
RDFParser is a process that will generate triples and quads;
RDFParserBuilder provides the means to create parsers.An
RDFParser is a process that will generate triples;
RDFParserBuilder provides the means to setup the parser.The registry of languages and parsers.
Adapter to old style Jena reader factory
Adapter from Jena2 original style to RIOT reader.
Factory for data+RDFS inference.
Library for RDF-star translation to and from reification form.
General converting of
Nodes to JSON.An
RDFWriter is a process that will output triples or quads in an RDF syntax.Adapter to old style Jena writer factory
Writer registry.
This class is used for indirecting all model.write calls to RIOT.
Wrapper to the RDF/XML writer (preRIOT).
Wrapper to the RDF/XML writer (preRIOT).
Read anything (RDF).
RDF/XML.
RDF/XML.
RDF/XML parser.
RDF/XML parser.
RDF/XML parser.
Interface to parsing processes that takes an input stream and emit items.
Create
ReaderRIOTRead TriX.
Interface to abstract away from specific regular expression systems
(Apache Xerces and java.util.regex)
A service registry is a collection of
HttpClients to use for
specific URLs.A service registry is a set of actions to take to modify an HTTP request before
sending it to a specific endpoint.
Support for renaming all the variables in an algebra expression.
Fixed scheme for choosing based on the triple patterns, without
looking at the data.
Alternative fixed reorder function.
Machinery.
A mapping from variable name to an RDF value.
Results from a query in a table-like manner for SELECT queries.
A class to walk a result set.
Deprecated.
To be removed.
Comparison of ResultSets.
ResultSetFactory - make result sets from places other than a query.
ResultSetFormatter - Convenience ways to call the various output formatters.
Vocabulary definitions from result-set.n3
A result set held in-memory.
Reading and writing of Result Sets.
Perform an action on a result set when iteration finishes
or
close() is called.Interfaces for result sets that allow peeking ahead
A wrapper around another result set that provides peek capabilities
The main ResultSet implementation for returning results from queries.
Wrap another
ResultSet (probably to modify operations on it).Registry for ResultSetWriter factories.
Factory for rewriters
Misc RIOT code
References:
Wikipedia on Roman Numerals
Therobs Lex & Yacc Example: Roman Numerals
which is were the idea of working right to left, instead of looking ahead, originated for me.
A buffering RowSet wrapper for stream-backed RowSets whose
RowSetBuffered.getResultVars() returns null as long as the header has not been
seen on the stream.Streaming RowSet implementation for application/sparql-results+json
The
RowSetJSONStreaming.getResultVars() will return null as long as the header has not
been consumed from the underlying stream.A row set held in-memory which is rewindable and peekable
Perform an action on a row set when iteration finishes
or
close() is called.RowSetFormatter - Convenience ways to call the various output formatters.
Read JSON format SPARQL Results.
Stream JSON format SPARQL Results.
Write results in
application/sparql-results+json format.Registry for RowSetWriter factories.
Addition registration of RDF/XML parsers to given each its own
Lang name.Seq membership
Information needed to serialize things
The injection point for the Quad
Serializable process.Provides a registry of serializers for queries and updates
Execution of OpService
Entry into the service executor from SPARQL queries.
Deprecated.
Deprecated in favor of QueryIterators that initialize lazily
Interface for handling service execution requests on a per-binding level.
Interface for abstracting
OpService execution.Factory for service executions w.r.t.
Bridge from bulk to individual binding level
Form a service executor from a base service executor and a 'chain' that acts as a decorator
Deprecated.
The default HTTP service executor implementation
Abstraction of a registry's single chain as a service executor
Registry for service executors that can be extended with custom ones.
An
IndexTable implementation optimized for the case where there is only a
single common variableRDFS setup in Node space
The severity controls how to relay error events to an error handler
ARQ Extension Function that will calculate the
SHA1 sum of any literal.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
A class that print quads, SPARQL style (maybe good for Trig too?)
Send quads to a dataset.
Send triples to a graph.
Serialization of a
Node using Thrift for the serialization.RDF-star - triple form.
RDF-star - quad form.
This data bag will gather items in memory until a size threshold is passed,
at which point it will write out all of the items to disk using the supplied
serializer.
This class provides the root of lower level access to all the parsers.
Token literal values and constants.
Token Manager.
Token literal values and constants.
Token Manager.
Token literal values and constants.
Token Manager.
Class that has all the parse event operations and other query/update specific things
The class "ResultSet" is reserved for the SELECT result format.
Alternative name for splitIRI
Spot TDB databases without needing TDB code on the class path.
sprintf(string,v1,v2,...) - Java style
sqrt(expression)
Serialization of a
Quad using Thrift for the serialization.SPARQL
S-Expressions is a unstandardized format for SPARQL-related and now
RDF-related objects.
Public interface to the SSE parser
Token literal values and constants.
Token Manager.
The stage builder (there is only one) is a library that encapsulates
evaluation of a basic graph pattern (BGP).
Interface for execution of a basic graph pattern.
Generic - always works - StageGenerator.
This is the data access step of quads and datasets.
Triple version of
StageMatchData.Register custom aggregates in addition to the SPARQL defined ones.
Standard function library.
Stats format:
State and settings management for
Graph Store Protocol
and Dataset Store Protocol clients.Property function to turn an RDF term (but not a blank node) into a string
StreamRDF that converts language tags to lower case or to canonical form (RFC 4646, 5646).Canonicalize literal lexical forms (in the object position).
Management of stream opening, including redirecting through a location mapper
whereby a name (e.g.
The interface for the output of RDF, such as the RIOT parsers.
Send to two stream
Encode StreamRDF in RDF_StreamRow and send to a handler.
Encode StreamRDF in Thrift.
Apply a function to every triple and quad.
Apply a function to the object of triple/quads.
Take one item from a StreamRDF and present as a StreamRowRDF
Provide counts of triples/quads/tuples
Wrap another StreamRDF and provide counts of items
Various Common StreamRDF setups
Utilities for sending to StreamRDF.
A wrapper around another
StreamRDFWrite RDF in a streaming fashion.
Writer registry
An item in a stream of RDF data.
Print (in debug format) an rdf-thrift stream
StreamRDF that expects triples not quads.Write TriX by streaming.
The seen form of a
TokenType.STRINGSerialization of a
Triple using Thrift for the serialization.Function that concatenates strings using a separator.
string length - Java operations
Property function that requires the object to
contain a list of two items, the first of which is a string to be split, and
the second is a regular expression denoting the split point.
Function that returns a UUID as a string
Substitution in SPARQL algebra.
substr - synonym for substring
substring(string, start[, finish]) - Java style
A way to write constants
Symbols for query language syntaxes
Factory for default policies for syntax labels to and from nodes.
Calculate in-scope variables from the AST
Common code across RRX parsers.
Function that returns the value of a system variable.
A table of one row of one binding
Table join - this only happens if the patterns can not be streamed.
Quads/Triples template.
Vocabulary definitions from test-dawg.n3
Vocabulary definitions from test-manifest-1_1.ttl
Vocabulary definitions from test-update.n3
More TestManifest
Converted from SPARQL result set encoded in Thrift to Bindings
An action that will happen on a different thread later when
ThreadAction.run()
is called.An action that will happen on a different thread later when
ThreadAction.run() is
called.A threshold policy based on the number of tuples added.
Thrift RDF (wire format) to RDF terms (Jena java objects)
Convert to and from Thrift wire objects.
Operations on binary RDF (which uses Apache Thrift).
Processing timeout strings.
Alternative name: afn:timezone for fn:implicit-timezone
Describes the input token stream.
Describes the input token stream.
Describes the input token stream.
Describes the input token stream.
Describes the input token stream.
Describes the input token stream.
Describes the input token stream.
Do nothing checker
Various algorithms
Tokenizer for all sorts of things JSON-ish
Tokenizer for the Turtle family of syntaxes.
Builder for TokenizerText
Token Manager Error.
Token Manager Error.
Token Manager Error.
Token Manager Error.
Token Manager Error.
Token Manager Error.
Token Manager Error.
Interface that encapsulates the begin/abort|commit/end operations.
Interface that encapsulates the transaction lifecycle for a component in a transaction.
Interface that encapsulates the transaction lifecycle for a component in a transaction.
An implementation of Transactional that provides MRSW locking but no abort.
Implementation for "un-Transactional" interface.
Mixin interface for the "un-Transactional" interface.
A null action
Transactional.Provide
Transactional as an indirection to another Transactional.Implementation of
TransactionHandler that does nothing but track the
transaction state.A graph
TransactionHandler for a graph view of a DatasetGraphOne step in the transformation process.
Transforms generic
DISTINCT plus ORDER BY combinations to
REDUCED plus ORDER BY which typically gives better
performance and memory consumption because engines have to keep less data
in-memory to evaluate it.A transform that tries to in-line/eliminate assignments
A bottom-top application of a transformation of SPARQL algebra
An optimizer that aims to combine multiple extend clauses together.
Redo FILTER (A&&B) as FILTER(A) FILTER(B) (as an expr list).
Filter disjunction.
A transform that aims to optimize queries where there is an equality
constraint on a variable to speed up evaluation e.g
Optimizer for transforming implicit joins.
A transform that aims to optimize queries where there is an inequality
constraint on a variable in an attempt to speed up evaluation e.g
Rewrite an algebra expression to put filters as close to their bound
variables.
Rewrite an algebra expression to put filters as close to their bound
variables in a BGP.
Rename quad form alegbra
Optimizer for transforming implicit joins.
Choose join strategy
Merge BGPs, additionally merges the special
OpTriple operator which is a BGP of a single triple pattern that
may be introduced by other transforms
(join BGP1 BGP2) => BGP
(sequence ...BGP1 BGP2 ...) => (sequence ...BGP ...)
Improved optimization for
ORDER BY plus DISTINCT or
REDUCED combinations, see JENA-441 for original proposal and
discussion.Perform the equivalent of the transactions in the SPARQL 1.1 spec.
The path transformation step mostly per the SPARQL 1.1 spec with some enhancement e.g.
Expand basic graph patterns and quad patterns to
joins of
(triple) and (quad).Optimizer that ensures that table empty is promoted as high
up a query as is possible
Rewrite to replace a property function property with the call to the property function implementation
Transform that rewrites an algebra into quadblock form
Transform that rewrites an algebra into quad form
A transform capable of removing assignments from the algebra tree
A Transformer that applies a reordering to all BGPs and Quad Patterns present in the algebra
Rename variables so that names can be treated globally.
Special purpose base class for a single transformation.
Optimization that changes queries that uses
OFFSET/LIMIT and ORDER BY
to execute using Top N: i.e.Convert query in algebra form so that the default graph of the query is the union of named graphs
Wrap another transform and pass on the transform operation
Maps string to string for use with convenience names.
Support operations for RDF Thrift
TriG pretty writer
TriG writer base class - ways to invoke a TriG writer
TriG writer that streams - print in blocks of quads clustered
by adjacent same graph and same subject
TriG writer that writes quads one per line
in TriG form with prefixes and short form literals (e.g.
A triples-only TripleCollector.
Return the object of a triple term.
Like a triple except it can be a path or a triple.
Return the predicate of a triple term.
Return the subject of a triple term.
A simplex or multiplex table of
Triples.Forms for triple indexes.
Create a triple term.
A three-way
TripleTable using all of the available forms in TripleTableForm.TriX - see HPL-2004-56 Jeremy Carroll and Patrick Stickler.
The various possible positions of a node in a tuple.
A mutable table of tuples.
Token literal values and constants.
Turtle parser, written using JavaCC.
Token Manager.
Base class to support the pretty forms of Turtle-related languages (Turtle, TriG)
Validation of Turtle terms
Turtle writer that streams - print in blocks of triples formatted
by adjacent same subject.
Write Turtle with one triple on one line with prefixed names, with short form literals (e.g.
Application utilities for executing code in transactions.
A MR+SW transactional Counter
A
Transactional that passes the transaction operations down to transactions on
independent graphs.Marker interface for a function that is "unstable".
A class of forms for executing SPARQL Update operations.
The mode an UpdateDataWriter is in.
Convenience class - renames UpdateModify so it follows the SPARQL Update spec.
An UpdateEngine provides an interface to execute a SPARQL update request.
Interface for factories that accept and process SPARQL update requests.
Default implementation of an update engine based on stream updates to a worker
function.
Example implementation of an update engine that does not stream data, instead it will build it up into an
in-memory UpdateRequest, and then traverse it after all update operations have finished.
Implementation of general purpose update request execution
Exception root for SPARQL Update
UpdateExecBuilder view over an UpdateExecutionBuilder
An instance of a execution of an UpdateRequest
Create
UpdateExecution execution objects.This class provides the root of lower level access to all the update parsers.
An instance of a execution of an UpdateRequest.
Class to hold the general state of a update request execution.
An instance of a parsing and execution of an UpdateRequest
Class to hold the general state of a update request execution.
A SPARQL Update consists of a number of operations (e.g.
Enum of different ways to send a SPARQL update over HTTP
Interface for update serializers which may be registered indirectly with the
SerializerRegistry via a UpdateSerializerFactory thus
allowing the customisation of update serialization.Interface for update serializer factories, these may be registered with the
SerializerRegistry thus allowing update serialization to be
customisedAn
UpdateSink is an object usually created by a container (such as a storage engine
or an UpdateRequest) that can process or store
the quads for INSERT DATA and DELETE DATA in a single SPARQL Update.Support for transformation of update abstract syntax.
UpdateSink that sends every Update to a worker except for the quads
of INSERT DATA, DELETE DATA which do to special sinks.
Represents a user defined function
Represents the definition of a user defined function
A function factory for managing user defined functions aka function macros.
Adds using clauses from the UsingList to UpdateWithUsing operations; will throw an
UpdateException if the modify operation already contains a using clause.
Miscellaneous operations - not query specific
Function that returns a UUID
Validation settings class
Value spaces.
A SPARQL variable
Allocate variables
Exception for an undefined expression (including unbound variable)
An after visitor for tracking variable usage
A before visitor for tracking variable usage
Tracker for variable usage
A visitor which tracks variable usage
Useful operations involving Var
Version number, as a string
An assembler that layers on top of another dataset given by
ja:dataset.Assembler to project a model out of a dataset.
Visitor for RDF_StreamRow
Visitor for RDF_StreamRow
Vocabulary
Vocabulary definitions from test-query.n3
Function that pauses for N milliseconds whenever it is called (for testing)
Walk algebra and expressions
Walk algebra and expressions, but don't walk into SERVICE
Walk algebra
Do project, don't walk into it.
Write a dataset as RDF Protobuf
A RIOT serializer for a language.
Factory for creating dataset writers
Write a dataset as RDF Thrift
Write a graph as RDF Protobuf
A RIOT serializer for a language.
Factory for creating graph writers
Write a graph as RDF Thrift
SSE Writer
Core engine for output of triples / quads that is streaming.
An output of triples / quads that print batches of same subject / same graph, same subject.
An output of triples / quads that is streaming.
An output of triples / quads that is streaming.
Write TriX.
Functions relating to XSD durations (F&O 3.1), using
javax.xml.datatype.DurationImplementation of XQuery/XPath functions and operators.