All Classes and Interfaces
Class
Description
Abstract stub implementation of a Function.
Abstract base implementation for a SNARL API Connection which supports ICV.
A skeleton implementation of
LongIterator allowing subclasses to
concentrate of computing next elements.Base implementation of an
RDFHandler which provides no-op implementations for all of the methods
except handling of statementsAbstract
SkippingIterator implementation to help with concrete implementations.Enumeration containing all action types that can be used in
permissionsInterface for adding RDF to a Stardog database via a
connection.A connection to the Stardog DBMS allowing access to the administrative functions provided by Stardog.
Define behaviour of this aggregate when the input is unbound / erroneous
This is a comparator to perform a mix of alphabetical+numeric comparison.
Abstract base class for instantiating a pool backed by Apache Pool.
Pool implementation using an Apache object pool
Comparator to order sorted maps.
Adapter class for using an Array as an Iterable, particularly, for allowing parts of an array to be the iterable.
Class which adapts an array of objects to the Iterator interface, particularly to allow sub-arrays to be iterated over.
Literal consisting of an array of Stardog IDs
Utility methods for ASCII character checking.
A
GraphQueryResult which asynchronously parses the result set from an input stream.A
SelectQueryResult which asynchronously parses the result set from an input stream.Represents a mutable state that can be updated exclusively through
AtomicState.beginTransitionFrom(Enum[])
and AtomicState.endTransition() calls.This class is an equivalent of Guava's
Closer, that supports AutoCloseables.A special kind of
Disposable that keeps track of references to it and disposes the
object automatically when there are no references left.An OWL Axiom
An expression about a class
A datatype expression
A named datatype expression
An expression about a property
Deprecated.
Not used anymore, however since the class is part of our Public API
some users might still be using it.
Class which represents the various different datatypes
Expression which represents an rdf:List of other expressions.
Enumeration of the possible facets for a
Axioms.FacetRestriction on a Axiom.NamedDatatypeA restriction on a facet of a datatype.
A user-defined datatype which has facet restrictions placed on its value
An iterator which batches elements of the underlying iterator.
A language handler that can verify BCP47 formatted language tags.
An Iterator which can iterate back to previous elements.
Utility class for bidirectional iterators.
Simple implementation of a list that can have more than Integer.MAX_VALUE values.
A boolean predicate over tuples of two longs.
Interface defining constants for the binary table result format.
Constants for Binary RDF
Writer for RDF in a binary formatWriter for SelectQueryResult in a binary formatA variable binding in a single
solution to a select query.Utilities for working with
BindingA set of query result bindings
Iteration over a BindingSet elements
Utilities for working with
BindingSetBuilder for
BindingSetUtility class for manipulating bits.
ThreadPoolExecutor which has a limited number of outstanding permits for executing tasks and when there
are no more permits left, new tasks will block waiting for a permit to free up instead of throwing
an exception.A Blank Node, aka BNode, in an RDF graph.
Three-valued (true, false, unknown) boolean type.
A boolean (ASK) SPARQL query.
Result of a `boolean` query.
Adapted from the example in Java Concurrency in Practice to add new methods like pause, resume, size, and uninterruptibles.
A check that can be used to determine if a process has been cancelled.
Interface for classes supporting cancellable computation.
This is general abstraction to make 5 main functions:
1) Create cancellation point for specific database;
Locks global mutex in readLock mode; Locks database-related mutex in readLock mode;
2) Execute exclusive database operation for specific database;
Locks global mutex in readLock mode; Locks database-related mutex in writeLock mode;
So it is impossible to create new cancellation point or to execute critical section while this lock is acquired;
3) Unregister cancellation point;
Does not have locks with other operations;
4) Cancel cancellation points;
Does not have locks with other operations;
5) Dispose cancellation manager (for all databases);
Locks global mutex in write lock mode; It will be impossible to run all parallel methods during dispose;
Callable which may throw an exception.
Interface for cancellation points;
We create cancellation point in one place and have a contract that we don't dispose system or don't drop database while the point is active and
actual;
Utility methods for monitoring and cancellation of abstract processes.
Collection of utility methods for working with the Carrot Labs HPPC API
Class which represents a logical change to a resource.
An ordered list of
changes to some resource.The type of a
Change.A simplified version of the ServiceLoader in the JDK.
Public
AdminConnection for cluster/pack functions.Represents the role of a cluster node.
A convenience class to status information from many nodes
Represents the type of cluster node that is in use
Cluster status view for api response serialization/deserialization to JSON
Simple
RDFHandler that will collect the statements and return a result.Utility class to create different kinds of columns
Represents the approximate net number of triples added or removed in a transaction.
Class to represent the format of serialized RDF that is also compressed
Connection for importing files and virtual graphs via external compute
Representation of a configuration option.
Interface for a connection to a Stardog database.
This object is used to set the authentication mechanism on Stardog HTTP connections.
A pool of Stardog connections.
A configuration object for creating connection pools.
Interface to provide conversion of the 'view' of a connection to another type of connection.
This is a union of a long iterator with a constant.
Interface to represent an integrity constraint.
Factory to simplify creating constraint objects.
Interface to represent the violation of an integrity constraint.
StatementSource decorator that indicates that we are copying all triples from one context to another context.
StatementSource decorator which will provide a context for statements that don't have a context.
StatementSource decorator which will override the context of the underlying source.
Defines constants that represent special URIs for contexts (named graphs).
Defines constants for contexts (named graphs) that Stardog treats specially.
Interface for an object that can be copied.
Utility methods for copying collections of
Copyable objects.Builder class for creating new Stardog databases.
Exception thrown when there is a fatal transaction error when performing the commit or rollback operation and the database
signifying that the database needs recovery to be performed on the failed transaction.
Signals that an error has occurred while performing an operation on a
database
Non-structural database options.
Different types of datatype normalization algorithms supported by Stardog.
Different types of transaction isolation supported by Stardog.
An object that maps keys to values in a type-safe manner.
Amalgum of an RDF 1.1 Dataset, a SPARQL 1.1 RDF Dataset & a SPARQL 1.1 update
[graph](https://www.w3.org/TR/sparql11-update/#deleteInsert)
Utilities for working with
DatasetDefault implementation of a
Dataset.A builder for a
Dataset.Information about a data source
Options shared by data sources of all types.
DTO for storing DataSourceQuery results
Object representing the
datatype of a Literal.An interface defining methods related to verification and normalization of typed literals and datatype IRIs.
Utility methods for working with the Date object
Immutable representation of date time.
Inlining logic for datetime values.
Term constants for the DC vocabulary
Dublin Core Metadata Terms
Annotation to support the workaround for supporting the decorator design pattern with Guice where we have
some interface I, a default/base implementation A, and a decorator class B, which should accept as an argument
the default implementation A.
Provides a simple implementation of a PoolableObjectFactory that can be used with
ApachePoolConfig.The default implementation of the
SensitivePropertyManager interface using a database connection.Implementation of a
StatementSource which can be used as the base for StatementSource
decorator implementations.Disjoint set data structure.
A
Disposable is an object data that can be disposed once it is not needed anymore.Utility for tracking and mass
Disposable.dispose() of Disposable resources.The distance units for use with spatial queries
The interface that any Driver must implement.
Service for obtaining instances of
Drivers and Connection instances.A
Module interface for loading API drivers via GuiceImmutable representation of a duration.
A simple class to provide various formatting options for durations represented in
milliseconds.
Extends the java.util.Properties stuff to provide typed accessors to get property values as boolean, int, etc.
A very light-weight utility class to make it easier to run a set of tasks together and wait until all those jobs end.
Executors utils
Options supported for
Query.explain() command.API for exporting RDF data in bulk from the server.
An extension of
BufferList which can maintain its sorted state and eagerly remove duplicates when elements are inserted.A serializer which helps to serialize objects to
ByteWriters and read from ByteReaders.Utility class to generate a SPARQL CONSTRUCT query that will extract all resources that have specified types or
predicates.
Simple class which wraps a
Shape and associates it with the dictionary ID of the resource associated with the shape.Specifies the level of spatial expressivity.
Represents the format of a file or stream, such as XML or JSON.
Default implementation of
FileFormatConstants for the FOAF ontology
A
ForkJoinTask for performing a parallel for-each operation;Column that foramts values using
String.format(String, Object...).Simple extension to
ResourceBundle that handles message formatting via MessageFormat for values in the resource bundle.RDFHandler base implementation that will decorate a base handlerRDFWriter base for decorating another writerThis is the extension point for 17.6 (Extensible Value Testing) of the SPARQL spec.
Functional utilities
Root exception for all spatial related errors
A spatial index
All lengths and distances are given in DEGREES.
Factory for creating instances of
GeospatialIndexUtility class for reading the metadata about a spatial index
Set of options for configuring Stardog Spatial
Handler for something that can process geometric
ShapesA source of geospatial information
Interface for retrieving statements from a Stardog database.
Utility class for building a `Graph`
Extends the standard SNARL
Connection exposing the GraphQL query support.Executable GraphQL query.
Interface for the storage and retrieval of GraphQL schemas.
A SPARQL graph (describe or construct) query.
A query over a semantic graph whose
results are themselves a graphQuery result of a sequence of
statements which correspond to a `Graph` result.Iteration implementation over graph query results.
Utilities for working with collections of RDF
statements.An adapter for converting push-based data processing (aka handler-based) to pull-based data processing (aka iterator-based).
Can be thrown out of
Consumer.accept(Object) to indicate that the producer must stop generating data.Set of utility functions for dealing with Stardog ICV support.
End-user interface for Integrity Constraint Validation support on a Stardog database.
Extension of Connection that allows IC validation.
An immutable implementation of
EdgeImmutable implementation of
PathUtilities for spatial indexing
Set of options for configuring the low-level indexes.
Types of indexes.
Representation of a Stardog information option.
Utility class for working with Injectors and Guice in general.
Simple -javaagent compatible instrumentor.
Similar to an
InterProcessLock,
but we track the locks with specific transaction ids.Very simple BiMap implementation which simply wraps two IntObjectMaps
Exception thrown when a
Literal encountered during parsing is syntactically correct, but otherwise
invalid.Exception denoting parsing of serialized query results failed due to syntax errors
Exception thrown when
parsing an RDF file and the contents are not syntactically valid RDF.IO interface for reading RDF data from various input sources.
Helper class to adapter the Sesame push parsing for query results to a pull interface via an Iterator.
Function which performs I/O which declares throwing IOException
Extended parser state that wraps the stream to be parsed to provide common IO operations for most of the
basic text RDF formats.
An Internationalized Resource Identifier (IRI) within an RDF graph.
Adapter from an
Iterator produced during query evaluation to a BooleanQueryResult.Adapter class for using a StatementIteration as a Sesame GraphQueryResult.
Adapter class for using a BindingSetIteration as a
PathQueryResultBase super-class for all iterator-as-query-result classes.
Adapter class for using a BindingSetIteration as a TupleQueryResult
Options used by JDBC data sources.
Utility methods for converting between the Jena and Sesame APIs
Specifies constants to identify various modes that are relevant to JSONLD
documents.
Default parser for JSON-LD
Deprecated.
Use
StreamingJSONLDWriter insteadAn interface defining methods related to verification and normalization of language tags.
Batch of consecutive lines read from a stream.
A utility class that reads lines from a stream in one thread and supplies the output as
batches for
multiple threads to consume.Extends
IOParserContext to read the input from a LineSupplier instead of an input stream.Set of parsers and utilities for determining version information about the Linux distribution we are currently running on.
Implementatino of a Comparator for List's of Comparable objects
Base class for a collection of listeners
A literal value in an RDF graph
Service query which represents a logical service query to be used
in the early stages of rewriting and optimization.
Interface representing connection options such as authentication credentials and the server to connect to.
An iterator over primitive longs
Exception thrown when a evaluating a query that has parse errors
An interface to support multiple passes over a specific part of the iterator's output via mark/reset operations.
Implements the
mark-reset behavior via ResettableIterator.reset() and SkippingIterator.skipTo(Object).Math-related utils
Utility methods and constants for the Guava
MediaType classUtility class for memory related information.
Class for configuring memory used by different components.
TODO Merge this class into c.c.c.base.Memory when it is moved into Stardog codebase
A column that spans multiple columns.
Mapping from Stardog meta properties to values.
This class acts as the registry of valid Stardog options and provides convenience functions.
Representation of a Stardog metadata property.
The builder class for building an option instance.
Marker interface for classes that define Stardog options.
Provides nonreenterant locking capability for a given ID.
StatementIterator whose contents are the concatenation of multiple iterators.Utility for granting and revoking named graph permissions
A namespace; an IRI and prefix pair that can be used during serialization to shorten a
IRI to a
`QName`.A collection of
namespace defintionsThe namespaces stored in a database.
Utility methods for working with namespaces
Monitors memory usage as reported by the underlying Operating System.
Simple
Comparator implementation which can be used for Comparable objects.An immutable linked list object with structure sharing.
A collection which keeps all non-dominated solutions in terms of a (multi-objective) optimization problem.
A non-reentrate read-write lock.
Default implementation of a
parser for the RDF NQuads syntaxWriter for NQuadsFactory for NQuadsWriterDefault implementation of a
parser for the RDF NTriples syntaxUtilities for reading and writing NTriples
RDFWriter implementation for the N-Triples RDF formatObject utilities not provided by
Objects.Represents a configuration option.
Workaround for optional constructor parameters with Guice.
Utility class to check the operating system in runtime.
Native memory usage info collected from OS.
Constants for the OWL Web Ontology Language and
OWL2.
Tuple with 2 elements
A replacement for Java's own URI: java.net.URI.
Object to hold the current state of the parsing operation, parsing configuration, and
Value creation.Options for
RDF parsing.Interface for ordered data sources that returns a skipping iterator.
Representation of the results of a path query.
QueryResult for paths.Renders path query results as tuples.
Represents a result set of a path query as tuples.
API for managing permissions in Stardog
A
ServiceQuery with a PlanNode as the body.This machinery allows subclasses to return a "canonicalized" version of the query to be used
in plan caching.
Base builder for
PlanNodeBodyServiceQuery objectsAccess to sun.misc.VM included to get maxDirectMemory for the VM; this is actually pulled from
io.netty.util.internal.PlatformDependent
Simple interface for a Pool of objects
Interface for a resource that can be used with an object
Pool.Abstract configuration for a
PoolImplementation of
MultiLock interface with precise locking which means no thread will block for an ID unless that ID
is locked by another thread.Predefined memory configuration modes.
A class to convert URI's to QNames.
An Turtle
writer that abbreviates bnodes and lists.Class to manage the number of concurrent producer and consumer tasks across multiple
RDFStreamProcessor instances.Read-Only interface for progress info.
Immutable default implementation of a progress
A multi-thread safe progress monitor implementation that prints progress percent and elapsed time at specified
percent increments.
Builder class for a customizable progress monitor
Chain more than one monitor / reporter
Interface for progress reporting
Represents a proof tree.
Simple builder class for creating instances of
PropertiesAuto-generated vocabulary class.
Object for executing a query against a Stardog database.
A query over a semantic graph
Interface for something that is able to execute and explain
queries.Exception for errors that occur while evaluating a query
Interface for creating
queriesA simple structure that shows information about a query.
Marker interface for the language of a
queryProvides basic query management functions such as listing all the running queries and killing a running query
on-demand.
Options for configuring how Stardog will reuse query plans.
The results of executing a
QueryFormat denoting the different serialization options for
query results.Utilities for
QueryResultFormatHandler for processing query results.
Base exception for errors that occur while
handling results.Parser for serialized
query resultsOptions to control
parsing of query resultsUtilities for working with
query resultsUtilities for working with QueryResults
Factory interface for creating
result writersOptions for controlling the
writing of query resultsUtilities for
writing query results.A sorted iterator wrapper to which elements can be added dynamically.
Generates an infinite sequence of random RDF triples.
Generates an infinite sequence of random RDF terms.
Constants for the RDF language
A statement source that produces statements by parsing the contents of a file.
Represents the serialization used for RDF.
Marker interface for an
RDFFormat whose serialization is binary rather than textual.Utilities for
RDFFormatInterface for consuming RDF
Exception denoting something unexpected happened in an
RDFHandlerUtility methods for working with
RDFHandlerWriter for RDF in RDF/JSON formatFactory for RDFJSONWriterUtilities for working with RDF lists.
MediaType objects related to RDF, SPARQL, and other SemWeb concepts.
This is a simple utility program to obfuscate the contents of an RDF file.
An RDF Parser.
Utilities for working with
RDFParserConstants for the RDF Schema 1.1 (RDFS)
Handler for statements created by the
stream loader.Factory class to generate statement handlers.
List of statements with an optional context value that will override any context defined by the individual statement objects.
A simple interface for representing a stream for RDF input.
A simple interface for creating RDF streams
Options for
RDF parsing used only via RDFStreamBuilder.Stream processor that handles concurrent production of statements from multiple streams and passes the statements
to
handlers or provides the results as an RDFStreamProcessor.iteration(List).A simple interface for parsers.
A statement source that produces statements by parsing the contents of an input stream.
A writer to serialize
RDF statements in a particular RDF format.Factory interface for creating instances of the
RDFWriterUtility methods for working with
RDFWriterWrite builder for
RDFWriterUtility class to write statements with namespaces.
Default
RDFParser for the RDF/XML formatDeprecated.
Use
ParserOptions insteadAn extension of RDFXMLWriter that outputs a more concise form of RDF/XML.
Default writer for the RDF/XML serialization
Options for
writing RDF/XMLA read-only query, ie a select, construct, graph or ask query.
A read-only query over a semantic graph
SNARL Connection which exposes reasoning specific functionality such as explanations and consistency checking.
Options for controlling reasoning behavior.
Enumeration for the different reasoning levels available in stardog.
A series of basic Reflect based utility functions.
Interface for an object which can remove RDF data from a Stardog database.
A utility class to help with reporting progress at predefined intervals.
A report interval extension that also handles tracking progress.
Anything which has a state that can be reset and must be closed.
Iterator which can be reset to the first element.
An interface for stateful
Predicate implementations that provides a reset function to clearing the internal state.Utility class for creating a `Graph` where all the
statements are about a particular
resourceAn extension to the base interface to support restrictions on the base iterator, for example, to implement the mark-reset behaviour for the
cross phase of the merge join.
A language handler that can verify RFC3066 formatted language tags.
API for managing user roles in Stardog.
Convenience class to manage reasoning schemas for a database.
Constants for the Schema.org Schema
Convenience functions and constants for reasoning schemas.
Extends the standard SNARL
Connection exposing the full-text search support provided by Waldo.Interface for conducting full text searches against a Stardog database via the Waldo Semantic Search engine.
Database options for the waldo search index.
Simple search result data structure.
A wrapper around the search results that may additionally have suggestions for an alternative search string.
Options for controlling the initialization of Security in Stardog and security configuration in a database.
Interface for security resource types.
Convenience class to manage sensitive properties for a database.
Serf options
Provides support for serializing/deserializing object or primitive values to/from byte arrays.
Serializer for primitive integer values.
Serializes the given long to 8 bytes.
Generic serializer interface for objects.
Serializes the given short to 2 bytes.
Serialize longs in an "Unsigned" form.
Serializes the given long to as many bytes as required.
Basic interface for a Stardog server which allows a server to be started or shut down.
Interface for configuring and creating a Stardog server.
Simple interface for starting a server programmatically
Server configuration optionsInterface representing a Service that is capable of providing results due to the evaluation of a SPARQL query.
Wrapper around the Java ServiceLoader class which returns collections of instances of an interface as opposed to
iterators over instances that the normal ServiceLoader returns.
Parameters for services when the body does not represent a SPARQL query.
An immutable instance of a query on a given service.
Base service query builder class.
Registry for SPARQL federated service implementations.
Turn
logical service queries into their
physical counterparts.Utilities for working with the
Shape class.Stardog executor service to provide the functionality of a ScheduledExecutorService without the cost of creating a new executor service every time
the executor is needed.
Shutdown hook manager which unifies all logic with object's lifecycle;
An implementation of SimpleSAXListener providing dummy implementations for all its methods.
A listener for events reported by SimpleSAXParser.
An XML parser that generates "simple" SAX-like events from a limited subset of XML documents.
A simple queue that can hold at most one element while in addition provides a function to
SingletonQueue.close() the queue.An interface for computing (typically approximate) size of a specific kind of object.
Implementation of size computation for commonly used object types.
Interface for ordered data sources that returns a skipping iterator.
Few utility functions
Iterator over an ordered data source that is able to jump to a specific element (or the next greater after that).
Few utility methods to construct skipping iterators.
Iterator for primitive longs that allows skipping.
Constants for the [SKOS](http://www.w3.org/TR/skos-reference) vocabulary.
Few utility methods to construct skipping iterators
This class performs merge sort over an array but allocates the additional array used in merge sort upfront so if the
arrays of same size will be sorted repeatedly this sorter can be reused to minimize garbage collection with the price
of having memory for extra array always being used.
Sorter implementation for QuickSort.
The SPARQL Query language
Writer implements for SPARQL/CSV query result formatFactory for creating SPARQLCSVResultWriterBooleanQueryResultParser for results encoded in SPARQL/JSON.Writer for boolean results in SPARQL/JSON.Options for reading and writing SPARQL/JSON
SelectQueryResultParser for results encoded in SPARQL/JSON.SelectQueryResultWriter for select results as SPARQL/JSONImplementation of
parsing query results in SPARQL/TSV format.Implementation of writing
query results in SPARQL/TSV format.Default factory implementation for
SPARQLTSVResultWriterAn extension of
TrigParser that processes data in the format
specified in the SPARQL 1.1 grammar for Quad data (assuming no variables, as
is the case for INSERT DATA and DELETE DATA operations).Collection of utility methods for working with SPARQL strings
Parser for boolean results in SPARQL/XMLWriter for BooleanQueryResult which will
serialize results in SPARQL/XML format.SPARQL/XML parsing for
SelectQueryResultWriter for SelectQueryResult which will
serialize results in SPARQL/XML format.A wrapper around
MarkResetSkippingIterator with bounded spooling: once the SpoolingMarkResetIterator.mark(T) method has been called, the iterator
will start spooling until one of the following conditions occurs:
1) the spooling threshold is reached, in which case the iterator switches to the skipping-based mark-reset
behavior.Utility class for creating SSLContext instances for use by a Netty stack.
Represents that type of cluster node that is in use
A convenience class for standby status information
Exception thrown when it was not possible to authenticate a stardog user with the provided credentials
Exception thrown when the user is not authorized to perform the operation.
Base class for all Stardog exceptions
Interface for explainer that can provide explanations for inferences made by a Stardog reasoner.
Deprecated.
Deprecated.
Use
IRI insteadDeprecated.
Parser for Stardog mappings syntax.
A writer that outputs mappings in Stardog syntax.
Vocabulary terms used in Stardog Mapping Syntax.
An assembler implementation to build a Stardog model from an assembler description in RDF.
Stardog assembler vocabulary.
Implementation of a Stardog-based rdf4j Repository.
Stardog based Repository configuration for use with
StardogRepositoryFactoryStardog-based implementation of an RDF4J RepositoryConnection.
Implementation of Sesame's RepositoryFactory interface to support creating StardogRepository instances via their repository configuration API
This class manages state transitions in an organized way.
A Statement in RDF.
Used to serialize trig in a both pretty (all triples in a graph grouped together) and deterministic way.
Interface which will iterate over a source of Statements.
A
Statement implementation representing a Statement pattern, which is a Statement where some or all of the
SPOC elements are a wildcard.Utilities for working with
Statement.Interface which represents a source of a set of RDF
statements.Utility class for working with StatementSources
A mutable collection of stored queries.
Represents a query stored in the server.
Builder interface for creating instances of StoredQuery.
Enum representing the payload type for triggers.
Streaming writer for JSON-LD
Factory for creating StreamingJSONLDWriterUtility for streams
Exception indicating that Checked* threw an exception and the default handler was used
String utilities not provided by
Strings.Utility class to keep a list of
formats that are supported by an application.Constants for the [SWRL](https://www.w3.org/Submission/SWRL/) vocabulary.
Utility methods for working with
System, particularly safe,
default value supported lookups into System.getProperty(java.lang.String) and other OS/system level calls.Create a table data structure that has a list of column names and list of
data rows.
TextTable exporter with predefined settings and bug fixes.
Fixes a bug in TextTableWriter where right intersection was used in every place a right left intersection was
supposed to be used.
A single test that involves running a specific SPARQL query.
An object that represents a single test or a collection of tests.
Creates a
TestSuite from query files in a directory.Option to specify what the created tests will test
Reads a test suite definition from an RDF file.
Result of running a
Test.Enumeration of test result types.
Runs all the tests in a suite.
A collection of tests organized in a hierarchical structure.
RDF vocabulary used for serializing test definitions.
Writes the test suite definition to an RDF file.
QueryResult parser for text-based resultsWriter implementation for simple text-based
boolean resultsRenders path query results in a concise text syntax:
(node1)-[var1=value1, var2=value2]->(node2).Renders path query results in a table where each row shows an edge and multiple paths are separated by an empty row.
Implementation of
SelectQueryResultWriter interface to output a nice looking text table with many
customization options.Utility class to wrap a
DataExporter so column widths can be computed on-the-fly by buffering first 1000 results and inspecting values.A convenience class for getting a thread dump.
A cancellation check that cancels automatically if a timeout has been reached or delegates to another check timeout
has not occurred.
Class used to keep track how much time is spent for a specific operation.
Transforms an object iterator to a long iterator.
RDFHandler that will transform staements before passing them to a delegateA marker interface for a value which can never exist in the main MappingDictionary,
only at query time in a QueryMappingDictionary
Parser for TriG
Extended
TrigParser which includes support for embedded rules.Factory for
TrigWriterA simple Tuple object.
Adapter for
SelectQueryResult objects to IteratorA wrapper around
tuples with delimiters to restore paths.Default parser for the Turtle RDF syntax
A small extension of
IOParserContext to maintain the state related to edge property parsing.Utility methods for Turtle encoding/decoding.
A Turtle parser that parses single values (URI, bnodes, literals, and embedded triples) instead of just triples.
An Turtle writer that writes single values (URI, bnodes, literals) instead of triples.
Default implementation of a
writer for TurtleFactory for creating TurtleWriterA simple structure that shows information about a transaction.
PriorityQueue class implemented as a binary heap with the additional function that updates the head element if its
priority changes.
A SPARQL Update query
A query that will update a semantic graph
API for managing users in Stardog.
Interface to generate a SHACL validation report.
Validator for
ServiceParameters instancesBase type for a node in an RDF graph
Utility functions for creating and working with RDF values
Implementation of the Guava cache
Weigher interface which will calculate the weight for a Value based on how much
space is takes in memory.Constants for the VCard ontology
Function which supports a polymorphic view of one class as another
Exception to indicate the reason a
view failed.Information about a virtual graph.
Connection to manage data sources and virtual graphs
Information about a virtual graph.
Enumeration of syntax types supported for virtual graph mappings.
Options used by virtual graphs.
Constants for the VoiD ontology
Terms in the WGS ontology
A simple extension of StringColumn class that fixes the bug in calculating the max row height when word wrapping
introduces new lines.
Options to control the
RDF writing processIndicates that there was an unexpected failure while
writingRead-only access interface to underlying calendar value
Utility for XML schema datatypes
This class provides utility functions for comparisons operating on
xml:dateTime datatypes as specified in W3C, XML Schema Part 2:
Datatypes Second Edition Known deviations from the standard: - the range
of years in this implementation is limited to Integer.MIN_VALUE to
Integer.MAX_VALUE for practical reasons - this implementation accepts some
dates that have impossible month, day-of-month combinations (such as
2005-02-29, which was not a leap year)An implementation of a datatype handler that can process
XSD datatypes.A utility class offering convenience methods for writing XML.
Constants for XML Schema datatypes.