# All Classes and Interfaces

Class
Description
AbstractAdminConnection
AbstractAutoDisposable
AbstractConnectionConfiguration<T>
AbstractDataExporterQueryResultWriter
AbstractFunction
Abstract stub implementation of a Function.
AbstractICVConnection
Abstract base implementation for a SNARL API Connection which supports ICV.
AbstractLongIterator
A skeleton implementation of `LongIterator` allowing subclasses to concentrate of computing next elements.
AbstractQueryResultHandler<T>
AbstractRDFHandler
Base implementation of an `RDFHandler` which provides no-op implementations for all of the methods except handling of `statements`
AbstractReasoningConnection
AbstractSkippingIterator<T>
Abstract `SkippingIterator` implementation to help with concrete implementations.
AbstractSkippingLongIterator
AbstractSPARQLJSONWriter<T>
AbstractSPARQLXMLWriter<T>
ActionType
Enumeration containing all action types that can be used in `permissions`
ActiveResources
Adder
Interface for adding RDF to a Stardog database via a `connection`.
AdminConnection
A connection to the Stardog DBMS allowing access to the administrative functions provided by Stardog.
AdminConnection.StreamConsumer
AdminConnection.TxLogRange
AdminConnection.TxLogRange.Builder
AdminConnectionConfiguration
AdminConnectionView<Input,Output>
Aggregate
A `Function` which computes an aggregated value over a `group` of `solutions` during query execution.
Aggregate.ErrorBehaviour
Define behaviour of this aggregate when the input is unbound / erroneous
AlphaNumericComparator<T>
This is a comparator to perform a mix of alphabetical+numeric comparison.
ApachePoolConfig<T>
Abstract base class for instantiating a pool backed by Apache Pool.
ApachePoolImpl<T>
Pool implementation using an Apache object pool
ArbitrarySortedMapComparator<K,V>
Comparator to order sorted maps.
ArrayIterable<T>
Adapter class for using an Array as an Iterable, particularly, for allowing parts of an array to be the iterable.
ArrayIterator<T>
Class which adapts an array of objects to the Iterator interface, particularly to allow sub-arrays to be iterated over.
ArrayLiteral
Literal consisting of an array of Stardog IDs
ArrayUtil
ASCIIUtil
Utility methods for ASCII character checking.
AsyncGraphQueryResult
A `GraphQueryResult` which asynchronously parses the result set from an input stream.
AsyncSelectQueryResult
A `SelectQueryResult` which asynchronously parses the result set from an input stream.
AtomicState<S>
Represents a mutable state that can be updated exclusively through `AtomicState.beginTransitionFrom(Enum[])` and `AtomicState.endTransition()` calls.
AutoCloser
This class is an equivalent of Guava's `Closer`, that supports `AutoCloseable`s.
AutoDisposable
A special kind of `Disposable` that keeps track of references to it and disposes the object automatically when there are no references left.
Axiom
An OWL Axiom
Axiom.ClassExpression
An expression about a class
Axiom.Datatype
A datatype expression
Axiom.NamedDatatype
A named datatype expression
Axiom.PropertyExpression
An expression about a property
Axioms
Deprecated.
Not used anymore, however since the class is part of our Public API some users might still be using it.
Axioms.Datatypes
Class which represents the various different datatypes
Axioms.ExpressionList<T>
Expression which represents an rdf:List of other expressions.
Axioms.Facet
Enumeration of the possible facets for a `Axioms.FacetRestriction` on a `Axiom.NamedDatatype`
Axioms.FacetRestriction
A restriction on a facet of a datatype.
Axioms.RestrictedDatatype
A user-defined datatype which has facet restrictions placed on its value
BatchingIterator<T>
An iterator which batches elements of the underlying iterator.
BCP47LanguageHandler
A language handler that can verify BCP47 formatted language tags.
BidirectionalIterator<T>
An Iterator which can iterate back to previous elements.
BidirectionalIterators
Utility class for bidirectional iterators.
BigArrayList<T>
Simple implementation of a list that can have more than Integer.MAX_VALUE values.
BiLongPredicate
A boolean predicate over tuples of two longs.
BiLongPredicate.BiLongFunction<T>
BiLongPredicate.StatefulBiLongPredicate
BinaryQueryResultConstants
Interface defining constants for the binary table result format.
BinaryRDFConstants
Constants for Binary RDF
BinaryRDFParser
BinaryRDFWriter
`Writer` for RDF in a binary format
BinaryRDFWriter.BinaryRDFWriterFactory
`Factory` for `BinaryRDFWriter`
BinarySelectQueryResultParser
BinarySelectQueryResultWriter
`Writer` for `SelectQueryResult` in a binary format
BinarySelectQueryResultWriter.BinarySelectQueryResultWriterFactory
`Factory` for `BinarySelectQueryResultWriter`
Binding
A variable binding in a single `solution` to a `select query`.
Bindings
Utilities for working with `Binding`
BindingSet
A set of query result bindings
BindingSetIterator
Iteration over a BindingSet elements
BindingSets
Utilities for working with `BindingSet`
BindingSets.Builder
Builder for `BindingSet`
Bits
Utility class for manipulating bits.
BlockingThreadPoolExecutor
`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.
BlockingThreadPoolExecutor.ExceptionHandler
BlockingThreadPoolExecutor.SilentExceptionHandler
BNode
A Blank Node, aka BNode, in an RDF graph.
Bool
Three-valued (true, false, unknown) boolean type.
BooleanQuery
A boolean (ASK) SPARQL query.
BooleanQuery
A query over a semantic graph whose `results` are a single `boolean` `value`.
BooleanQueryResult
Result of a `boolean` query.
BooleanQueryResultHandler
`Result handler` for `boolean query results`
BooleanQueryResultParser
`Parser` for `BooleanQueryResult`
BooleanQueryResultWriter
`Writer` for `BooleanQueryResult`
BoundedBuffer<T>
Adapted from the example in Java Concurrency in Practice to add new methods like pause, resume, size, and uninterruptibles.
BufferList<T>
BufferLists
ByteBuffers
CancelCheck
A check that can be used to determine if a process has been cancelled.
Cancellable
Interface for classes supporting cancellable computation.
CancellationManager
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;
CancellationManager.CheckedFunction<T,R>
Callable which may throw an exception.
CancellationPoint
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;
CancellationUtil
Utility methods for monitoring and cancellation of abstract processes.
CarrotUtil
Collection of utility methods for working with the Carrot Labs HPPC API
Change<E,T>
Class which represents a logical change to a resource.
ChangeList<E,T>
An ordered list of `changes` to some resource.
ChangeType
The type of a `Change`.
Channels2
ClassServiceLoader
A simplified version of the ServiceLoader in the JDK.
Clock
CloseableIterator<T>
An `Iterator` which can be `closed`.
CloseableIterator.AbstractCloseableIterator<T>
CloseableIterator.DelegatingCloseableIterator<T>
CloseableIterator.EmptyCloseableIterator<T>
CloseableLongIterator
ClusterAdminConnection
Public `AdminConnection` for cluster/pack functions.
ClusterNodeRole
Represents the role of a cluster node.
ClusterNodeStatus
A convenience class to status information from many nodes
ClusterNodeType
Represents the type of cluster node that is in use
ClusterStatusView
Cluster status view for api response serialization/deserialization to JSON
CollectingRDFHandler<T>
Simple `RDFHandler` that will collect the `statements` and return a result.
Columns
Utility class to create different kinds of columns
CommitResult
Represents the approximate net number of triples added or removed in a transaction.
CompressedRDFFormat
Class to represent the format of serialized RDF that is also compressed
ComputeAdminConnection
Connection for importing files and virtual graphs via external compute
ConfigProperty<T>
Representation of a configuration option.
Connection
Interface for a connection to a Stardog database.
ConnectionConfiguration
ConnectionCredentials
This object is used to set the authentication mechanism on Stardog HTTP connections.
ConnectionPool
A pool of Stardog connections.
ConnectionPoolConfig
A configuration object for creating connection pools.
ConnectionView<I,O>
Interface to provide conversion of the 'view' of a connection to another type of connection.
ConstantAppendingLongIterator
This is a union of a long iterator with a constant.
Constraint
Interface to represent an integrity constraint.
ConstraintFactory
Factory to simplify creating constraint objects.
ConstraintViolation<T>
Interface to represent the violation of an integrity constraint.
ContextCopyStatementSource
StatementSource decorator that indicates that we are copying all triples from one context to another context.
ContextFallbackStatementSource
StatementSource decorator which will provide a context for statements that don't have a context.
ContextOverrideStatementSource
StatementSource decorator which will override the context of the underlying source.
Contexts
Defines constants that represent special URIs for contexts (named graphs).
ContextSets
Defines constants for contexts (named graphs) that Stardog treats specially.
Copyable<T>
Interface for an object that can be copied.
Copyables
Utility methods for copying collections of `Copyable` objects.
CuratorReadWriteTxLock
DaemonExecutor
DatabaseBuilder
Builder class for creating new Stardog databases.
DatabaseConsistencyException
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.
DatabaseException
Signals that an error has occurred while performing an operation on a `database`
DatabaseOptions
Non-structural database options.
DatabaseOptions.InlineStoredQuery
DatabaseOptions.LanguageNormalization
Different types of datatype normalization algorithms supported by Stardog.
DatabaseOptions.TransactionIsolation
Different types of transaction isolation supported by Stardog.
DataKey<E>
DataMap
An object that maps keys to values in a type-safe manner.
Dataset
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)
Datasets
Utilities for working with `Dataset`
Datasets.DatasetImpl
Default implementation of a `Dataset`.
Datasets.DatasetImpl.Builder
A builder for a `Dataset`.
DataSourceInfo
Information about a data source
DataSourceOptions
Options shared by data sources of all types.
DataSourceQueryResult
DTO for storing DataSourceQuery results
Datatype
Object representing the `datatype of a Literal`.
DatatypeHandler
An interface defining methods related to verification and normalization of typed literals and datatype IRIs.
Dates
Utility methods for working with the Date object
DateTime
Immutable representation of date time.
DateTimeInlineUtils
Inlining logic for datetime values.
DC
Term constants for the DC vocabulary
DCTERMS
Dublin Core Metadata Terms
Decorate
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.
DefaultCancellationPoint
DefaultPoolableObjectFactory
Provides a simple implementation of a PoolableObjectFactory that can be used with `ApachePoolConfig`.
DefaultSchemaManager
DefaultSensitivePropertyManager
The default implementation of the `SensitivePropertyManager` interface using a database connection.
DelegatingAdminConnection
DelegatingCancellationPoint
DelegatingRDFHandler
DelegatingRDFStream
DelegatingSkippingIterator<T>
DelegatingStatementSource
Implementation of a `StatementSource` which can be used as the base for StatementSource decorator implementations.
DisjointSet<T>
Disjoint set data structure.
Disposable
A `Disposable` is an object data that can be disposed once it is not needed anymore.
Disposables
Disposer
Utility for tracking and mass `Disposable.dispose()` of `Disposable` resources.
DistanceUnit
The distance units for use with spatial queries
Driver
The interface that any Driver must implement.
DriverManager
Service for obtaining instances of `Drivers` and `Connection` instances.
DriverModule
A `Module` interface for loading API drivers via Guice
DummyCancellationPoint
Duration
Immutable representation of a duration.
DurationFormat
A simple class to provide various formatting options for durations represented in milliseconds.
Durations
Edge
EnhancedProperties
Extends the java.util.Properties stuff to provide typed accessors to get property values as boolean, int, etc.
Exceptions
ExecutionGroup
A very light-weight utility class to make it easier to run a set of tasks together and wait until all those jobs end.
Executors2
Executors utils
Executors2.CachedThreadPoolBuilder
ExplainOptions
Options supported for `Query.explain()` command.
Exporter
API for exporting RDF data in bulk from the server.
ExtendedBufferList<T>
An extension of `BufferList` which can maintain its sorted state and eagerly remove duplicates when elements are inserted.
ExtendedObjectSerializer<T>
A serializer which helps to serialize objects to `ByteWriter`s and read from `ByteReader`s.
ExtractionQuery
Utility class to generate a SPARQL CONSTRUCT query that will extract all resources that have specified types or predicates.
Feature
Simple class which wraps a `Shape` and associates it with the dictionary ID of the resource associated with the shape.
Features
Specifies the level of spatial expressivity.
FileFormat
Represents the format of a file or stream, such as XML or JSON.
FileFormat.Compression
FileFormatImpl
Default implementation of `FileFormat`
FOAF
Constants for the FOAF ontology
ForEachIntTask
A `ForkJoinTask` for performing a parallel for-each operation;
FormattedColumn
Column that foramts values using `String.format(String, Object...)`.
FormattingResourceBundle
Simple extension to `ResourceBundle` that handles message formatting via `MessageFormat` for values in the resource bundle.
ForwardingRDFHandler
`RDFHandler` base implementation that will decorate a base handler
ForwardingRDFWriter
`RDFWriter` base for decorating another writer
Function
This is the extension point for 17.6 (Extensible Value Testing) of the SPARQL spec.
Functional
Functional utilities
GeoException
Root exception for all spatial related errors
Geosparql
Geosparql.Functions
Geosparql.ServiceVocabulary
Geosparql.SPATIAL_FUNCTIONS
Geosparql.Units
GeoSPARQLDatatypeHandler
GeospatialIndex
A spatial index
GeospatialIndexConnection
All lengths and distances are given in DEGREES.
GeospatialIndexFactory
Factory for creating instances of `GeospatialIndex`
GeospatialIndexMetadata
Utility class for reading the metadata about a spatial index
GeospatialIndexState
GeospatialOptions
Set of options for configuring Stardog Spatial
GeospatialSink
Handler for something that can process geometric `Shapes`
GeospatialSource
A source of geospatial information
Getter
Interface for retrieving statements from a Stardog database.
GlobalTimer
GraphBuilder
Utility class for building a `Graph`
GraphQLConnection
Extends the standard SNARL `Connection` exposing the GraphQL query support.
GraphQLOptions
GraphQLQuery
Executable GraphQL query.
GraphQLSchemaManager
Interface for the storage and retrieval of GraphQL schemas.
GraphQuery
A SPARQL graph (describe or construct) query.
GraphQuery
A query over a semantic graph whose `results` are themselves a graph
GraphQueryResult
Query result of a sequence of `statements` which correspond to a `Graph` result.
GraphQueryResultIterator
Iteration implementation over graph query results.
Graphs
Utilities for working with collections of RDF `statements`.
HandlerBackedIterator<T>
An adapter for converting push-based data processing (aka handler-based) to pull-based data processing (aka iterator-based).
HandlerBackedIterator.DataProducer<T>
HandlerBackedIterator.ProducerFinished
Can be thrown out of `Consumer.accept(Object)` to indicate that the `producer` must stop generating data.
HTMLQueryResultWriter
HTMLQueryResultWriter.HTMLQueryResultWriterFactory
ICV
Set of utility functions for dealing with Stardog ICV support.
ICValidator
End-user interface for Integrity Constraint Validation support on a Stardog database.
ICVConnection
Extension of Connection that allows IC validation.
ICVOptions
ImmutableCollectors
ImmutableEdge
An immutable implementation of `Edge`
ImmutablePath
Immutable implementation of `Path`
Indexing
Utilities for spatial indexing
IndexOptions
Set of options for configuring the low-level indexes.
IndexOptions.CompressionType
IndexOptions.IndexType
Types of indexes.
IndexOptions.WriteConflictStrategy
InfoProperty<T>
Representation of a Stardog information option.
Injectors
Utility class for working with Injectors and Guice in general.
Instrumentor
Simple -javaagent compatible instrumentor.
InterProcessTxLock
Similar to an `InterProcessLock`, but we track the locks with specific transaction ids.
IntObjectBiMap<T>
Very simple BiMap implementation which simply wraps two IntObjectMaps
InvalidLiteral
Exception thrown when a `Literal` encountered during parsing is syntactically correct, but otherwise invalid.
InvalidQueryResults
Exception denoting parsing of serialized query results failed due to syntax errors
InvalidQueryType
InvalidRDF
Exception thrown when `parsing` an RDF file and the contents are not syntactically valid RDF.
InvalidVariableException
IO
IO interface for reading RDF data from various input sources.
IOBindingSetIterator
Helper class to adapter the Sesame push parsing for query results to a pull interface via an Iterator.
IOFunction<T,R>
Function which performs I/O which declares throwing IOException
IOParserContext
Extended parser state that wraps the stream to be parsed to provide common IO operations for most of the basic text RDF formats.
IRI
An Internationalized Resource Identifier (IRI) within an RDF graph.
IteratorAsBooleanQueryResult
Adapter from an `Iterator` produced during query evaluation to a `BooleanQueryResult`.
IteratorAsGraphQueryResult
Adapter class for using a StatementIteration as a Sesame GraphQueryResult.
IteratorAsPathQueryResult
Adapter class for using a BindingSetIteration as a `PathQueryResult`
IteratorAsQueryResult<T>
Base super-class for all iterator-as-query-result classes.
IteratorAsTupleQueryResult
Adapter class for using a BindingSetIteration as a TupleQueryResult
JdbcOptions
Options used by JDBC data sources.
JdbcOptions.RowCountEstimateStrategy
JenaSesameUtils
Utility methods for converting between the Jena and Sesame APIs
JSONLDMode
Specifies constants to identify various modes that are relevant to JSONLD documents.
JSONLDOptions
JSONLDParser
Default parser for JSON-LD
JSONLDWriter
Deprecated.
Use `StreamingJSONLDWriter` instead
JSONLDWriter.JSONLDWriterFactory
KernelAdminConnection
Krb5Utils
LanguageHandler
An interface defining methods related to verification and normalization of language tags.
LineBatch
Batch of consecutive lines read from a stream.
LineSupplier
A utility class that reads lines from a stream in one thread and supplies the output as `batches` for multiple threads to consume.
LineSupplier.InputStreamSupplier
LineSupplierParserContext
Extends `IOParserContext` to read the input from a `LineSupplier` instead of an input stream.
LinuxDistribution
Set of parsers and utilities for determining version information about the Linux distribution we are currently running on.
LinuxDistribution.Distribution
ListComparator<T>
Implementatino of a Comparator for List's of Comparable objects
ListenerSupport<T>
Base class for a collection of listeners
Literal
A literal value in an RDF graph
LogicalServiceQuery
Service query which represents a logical service query to be used in the early stages of rewriting and optimization.
LogicalServiceQuery.LogicalServiceQueryBuilder
LoginConnectionConfiguration<T>
Interface representing connection options such as authentication credentials and the server to connect to.
LogJsonOuput
LogOutputter
LongIterator
An iterator over primitive longs
LongIterators
LowercaseBCP47LanguageHandler
MalformedQuery
Exception thrown when a evaluating a query that has parse errors
MarkResetIterator<T>
An interface to support multiple passes over a specific part of the iterator's output via mark/reset operations.
MarkResetSkippingIterator<T>
Implements the `mark-reset behavior` via `ResettableIterator.reset()` and `SkippingIterator.skipTo(Object)`.
Maths
Math-related utils
MediaTypes
Utility methods and constants for the Guava `MediaType` class
Memory
Utility class for memory related information.
MemoryConfiguration
Class for configuring memory used by different components.
MemoryConfiguration.HeapComponent
MemoryConfiguration.NativeComponent
MemoryConfiguration.StarrocksComponent
MemoryInfo
TODO Merge this class into c.c.c.base.Memory when it is moved into Stardog codebase
MergedColumn
A column that spans multiple columns.
Metadata
Mapping from Stardog meta properties to values.
MetaProperties
This class acts as the registry of valid Stardog options and provides convenience functions.
MetaProperty<T>
Representation of a Stardog metadata property.
MetaProperty.Builder<T,P>
The builder class for building an option instance.
MetaProperty.Flag
MetaPropertyProvider
Marker interface for classes that define Stardog options.
MultiLock
Provides nonreenterant locking capability for a given ID.
MultiStatementIterator
`StatementIterator` whose contents are the concatenation of multiple iterators.
N3Parser
NamedGraphPermissions
Utility for granting and revoking named graph permissions
Namespace
A namespace; an IRI and prefix pair that can be used during serialization to shorten a `IRI` to a `QName`.
Namespaces
A collection of `namespace defintions`
NamespacesInfo
The namespaces stored in a database.
NamespaceUtils
Utility methods for working with namespaces
NativeMemoryMonitor
Monitors memory usage as reported by the underlying Operating System.
NaturalOrderComparator<T>
Simple `Comparator` implementation which can be used for `Comparable` objects.
NestedList<T>
An immutable linked list object with structure sharing.
NonDominatedSolutions<T>
A collection which keeps all non-dominated solutions in terms of a (multi-objective) optimization problem.
NonReentrantCuratorReadWriteLock
A non-reentrate read-write lock.
NonReentrantMutex
NQuadsParser
Default implementation of a `parser` for the RDF NQuads syntax
NQuadsWriter
`Writer` for NQuads
NQuadsWriter.NQuadsWriterFactory
`Factory` for `NQuadsWriter`
NTParser
Default implementation of a `parser` for the RDF NTriples syntax
NTriplesUtil
Utilities for reading and writing NTriples
NTWriter
`RDFWriter` implementation for the N-Triples RDF format
NTWriter.NTWriterFactory
Numbers
Objects2
Object utilities not provided by `Objects`.
Option<V>
Represents a configuration option.
OptionalConstructorParam<T>
Workaround for optional constructor parameters with Guice.
OptionFunction
Options
OS
Utility class to check the operating system in runtime.
OSUtil
OSUtil.NativeMemoryUsage
Native memory usage info collected from OS.
OverrideModule
OWL
Constants for the OWL Web Ontology Language and OWL2.
Pair<K1,K2>
Tuple with 2 elements
ParsedURI
A replacement for Java's own URI: java.net.URI.
ParserConfigs
ParserContext
Object to hold the current state of the parsing operation, parsing configuration, and `Value` creation.
ParserContext.ParseError
ParserOptions
Options for `RDF parsing`.
PartitionedSkippingIterable<T>
Interface for ordered data sources that returns a skipping iterator.
Path
Representation of the results of a path query.
PathQuery
PathQueryResult
`QueryResult` for `paths`.
PathQueryResultWriter
Renders path query results as tuples.
PathsAsTupleQueryResult
Represents a result set of a path query as tuples.
PeekingLongIterator
PeekingSkippingIterator<T>
PermissionManager
API for managing permissions in Stardog
Permissions
Permissions.ActionBuilder
Permissions.ResourceBuilder
Permissions.TypeBuilder
PlanNodeBodyServiceQuery
A `ServiceQuery` with a `PlanNode` as the body.
PlanNodeBodyServiceQuery.CanonicalizedPlanNodeBodyServiceQuery
This machinery allows subclasses to return a "canonicalized" version of the query to be used in plan caching.
PlanNodeBodyServiceQuery.CanonicalizedPlanNodeBodyServiceQueryBuilder
PlanNodeBodyServiceQuery.PlanNodeBodyServiceQueryBuilder
Base builder for `PlanNodeBodyServiceQuery` objects
PlatformDependent
Access to sun.misc.VM included to get maxDirectMemory for the VM; this is actually pulled from io.netty.util.internal.PlatformDependent
Pool<T,E>
Simple interface for a Pool of objects
Poolable<E>
Interface for a resource that can be used with an object `Pool`.
PoolConfig<T,E>
Abstract configuration for a `Pool`
PreciseMultiLock
Implementation of `MultiLock` interface with precise locking which means no thread will block for an ID unless that ID is locked by another thread.
PredefinedMemoryRatio
Predefined memory configuration modes.
PrefixMapping
A class to convert URI's to QNames.
PrettyTurtleWriter
An Turtle `writer` that abbreviates bnodes and lists.
PrettyTurtleWriter.PrettyTurtleWriterFactory
ProcessorContext
Class to manage the number of concurrent producer and consumer tasks across multiple `RDFStreamProcessor` instances.
Progress
Read-Only interface for progress info.
Progress.Default
Immutable default implementation of a progress
ProgressMonitor
A multi-thread safe progress monitor implementation that prints progress percent and elapsed time at specified percent increments.
ProgressMonitor.Builder
Builder class for a customizable progress monitor
ProgressMonitor.DefaultProgressFormatter
ProgressMonitor.DelegatingProgressMonitor
ProgressMonitor.ProgressFormatter
ProgressMonitor.ReportingProgressMonitor
Chain more than one monitor / reporter
ProgressReporter
Interface for progress reporting
Proof
Represents a proof tree.
PropertiesBuilder
Simple builder class for creating instances of `Properties`
PROV
Auto-generated vocabulary class.
Providers
QUDT
Query<T>
Object for executing a query against a Stardog database.
Query
A query over a semantic graph
QueryEngine
Interface for something that is able to execute and explain `queries`.
QueryExecutionFailure
Exception for errors that occur while evaluating a query
QueryFactory
Interface for creating `queries`
QueryInfo
A simple structure that shows information about a query.
QueryInfo.Status
QueryLanguage
Marker interface for the language of a `query`
QueryManager
Provides basic query management functions such as listing all the running queries and killing a running query on-demand.
QueryPlan
An `execution` plan for a `Query`
QueryPlanReuse
Options for configuring how Stardog will reuse query plans.
QueryResult<T>
The results of executing a `Query`
QueryResultBuilder<T>
QueryResultFormat
Format denoting the different serialization options for `query results`.
QueryResultFormats
Utilities for `QueryResultFormat`
QueryResultHandler<T>
Handler for processing query results.
QueryResultHandlerException
Base exception for errors that occur while `handling results`.
QueryResultParser<P>
Parser for serialized `query results`
QueryResultParserOptions
Options to control `parsing` of `query results`
QueryResultParsers
Utilities for working with `query results`
QueryResults
Utilities for working with QueryResults
QueryResultWriter<T>
QueryResultWriterFactory
Factory interface for creating `result writers`
QueryResultWriterOptions
Options for controlling the `writing` of `query results`
QueryResultWriters
Utilities for `writing` `query results`.
QueuedSortedIterator<T>
A sorted iterator wrapper to which elements can be added dynamically.
RandomStatementGenerator
Generates an infinite sequence of random RDF triples.
RandomStream
RandomStream.Factory
RandomValueGenerator
Generates an infinite sequence of random RDF terms.
RDF
Constants for the RDF language
RDFDatatypesHandler
RDFFileSupplier
A statement source that produces statements by parsing the contents of a file.
RDFFormat
Represents the serialization used for RDF.
RDFFormat.BinaryRDFFormat
Marker interface for an `RDFFormat` whose serialization is binary rather than textual.
RDFFormats
Utilities for `RDFFormat`
RDFHandler
Interface for consuming RDF
RDFHandlerException
Exception denoting something unexpected happened in an `RDFHandler`
RDFHandlers
Utility methods for working with `RDFHandler`
RDFHandlers.DefaultRDFHandler
RDFHandlers.GraphBuilder
RDFJSONParser
RDFJSONWriter
`Writer` for RDF in RDF/JSON format
RDFJSONWriter.RDFJSONWriterFactory
`Factory` for `RDFJSONWriter`
RDFLists
Utilities for working with RDF lists.
RDFMediaTypes
MediaType objects related to RDF, SPARQL, and other SemWeb concepts.
RDFNamespaceHandler
RDFObfuscator
This is a simple utility program to obfuscate the contents of an RDF file.
RDFParser
An RDF Parser.
RDFParsers
Utilities for working with `RDFParser`
RDFS
Constants for the RDF Schema 1.1 (RDFS)
RDFStatementHandler
Handler for statements created by the `stream loader`.
RDFStatementHandler.Factory
Factory class to generate statement handlers.
RDFStatementList
List of statements with an optional context value that will override any context defined by the individual statement objects.
RDFStream
A simple interface for representing a stream for RDF input.
RDFStreamBase
RDFStreamBuilder
RDFStreamFactory
A simple interface for creating RDF streams
RDFStreamOptions
Options for `RDF parsing` used only via `RDFStreamBuilder`.
RDFStreamProcessor
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)`.
RDFStreams
A simple interface for parsers.
RDFStreamSupplier
A statement source that produces statements by parsing the contents of an input stream.
RDFValueColumn
RDFWriter
A writer to serialize `RDF statements` in a particular RDF format.
RDFWriterFactory
Factory interface for creating instances of the `RDFWriter`
RDFWriters
Utility methods for working with `RDFWriter`
RDFWriters.RDFWriterConfig
Write builder for `RDFWriter`
RDFWriters2
Utility class to write statements with namespaces.
RDFXMLParser
Default `RDFParser` for the RDF/XML format
RDFXMLParserOptions
Deprecated.
Use `ParserOptions` instead
RDFXMLPrettyWriter
An extension of RDFXMLWriter that outputs a more concise form of RDF/XML.
RDFXMLWriter
Default writer for the RDF/XML serialization
RDFXMLWriter.RDFXMLWriterFactory
RDFXMLWriterOptions
Options for `writing RDF/XML`
ReadQuery<T>
A read-only query, ie a select, construct, graph or ask query.
ReadQuery
A read-only query over a semantic graph
ReasoningAPIUtils
ReasoningConnection
SNARL Connection which exposes reasoning specific functionality such as explanations and consistency checking.
ReasoningOptions
Options for controlling reasoning behavior.
ReasoningType
Enumeration for the different reasoning levels available in stardog.
Reflect
A series of basic Reflect based utility functions.
Remover
Interface for an object which can remove RDF data from a Stardog database.
ReportInterval
A utility class to help with reporting progress at predefined intervals.
ReportIntervalCounter
A report interval extension that also handles tracking progress.
Resettable
Anything which has a state that can be reset and must be closed.
ResettableIterator<T>
Iterator which can be reset to the first element.
ResettableIterators
ResettableLongIterator
ResettablePredicate<T>
An interface for stateful `Predicate` implementations that provides a reset function to clearing the internal state.
Resource
Super interface for `BNode` and `IRI` which are disjoint RDF node types from `Literal`
ResourceBuilder
Utility class for creating a `Graph` where all the `statements` are about a particular `resource`
Resources2
RestrictedMarkResetIterator<T>
An 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.
ResultWritingFailed
RFC3066LanguageHandler
A language handler that can verify RFC3066 formatted language tags.
RoleManager
API for managing user roles in Stardog.
RuleVocab
SchemaManager
Convenience class to manage reasoning schemas for a database.
SchemaOrg
Constants for the Schema.org Schema
Schemas
Convenience functions and constants for reasoning schemas.
SDJenaFactory
Factory for obtaining instances of the Jena framework core, specifically `Models` and `Datasets`, which are backed by Stardog.
SearchConnection
Extends the standard SNARL `Connection` exposing the full-text search support provided by Waldo.
Searcher
Interface for conducting full text searches against a Stardog database via the Waldo Semantic Search engine.
SearchOptions
Database options for the waldo search index.
SearchResult
Simple search result data structure.
SearchResults
A wrapper around the search results that may additionally have suggestions for an alternative search string.
SecurityOptions
Options for controlling the initialization of Security in Stardog and security configuration in a database.
SecurityResourceType
Interface for security resource types.
SelectPlanQuery
SelectQuery
SelectQuery
SelectQueryResult
Represents tabular query results of `rows` of `tuples` which represent the variable-value pairs of the results
SelectQueryResultHandler
`Result handler` for `boolean query results`
SelectQueryResultParser
`Parser` for `SelectQueryResult`
SelectQueryResultWriter
`Writer` for `SelectQueryResult`
SensitivePropertyManager
Convenience class to manage sensitive properties for a database.
SerfOptions
Serf options
Serializers
Provides support for serializing/deserializing object or primitive values to/from byte arrays.
Serializers.IntSerializer
Serializer for primitive integer values.
Serializers.LittleEndianLongSerializer
Serializers.LongSerializer
Serializes the given long to 8 bytes.
Serializers.ObjectSerializer<T>
Generic serializer interface for objects.
Serializers.ShortSerializer
Serializes the given short to 2 bytes.
Serializers.UnsignedLongSerializer
Serialize longs in an "Unsigned" form.
Serializers.VarLongSerializer
Serializes the given long to as many bytes as required.
Server
Basic interface for a Stardog server which allows a server to be started or shut down.
ServerBuilder
Interface for configuring and creating a Stardog server.
ServerException
ServerFactory
Simple interface for starting a server programmatically
ServerOptions
`Server` configuration options
Service
Interface representing a Service that is capable of providing results due to the evaluation of a SPARQL query.
ServiceLoaders
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.
ServiceParameters
Parameters for services when the body does not represent a SPARQL query.
ServiceQuery
An immutable instance of a query on a given service.
ServiceQuery.DistinctValuesEstimationFunction
ServiceQuery.ServiceQueryBuilder
Base service query builder class.
ServiceRegistry
Registry for SPARQL federated service implementations.
ServiceTranslator
Turn `logical service queries` into their `physical counterparts`.
Shapes
Utilities for working with the `Shape` class.
SharedExecutor
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.
SharedExecutor.CallerRunsPolicy
SharedForkJoinExecutor
ShutDownHookManager
Shutdown hook manager which unifies all logic with object's lifecycle;
SimpleSAXAdapter
An implementation of `SimpleSAXListener` providing dummy implementations for all its methods.
SimpleSAXListener
A listener for events reported by `SimpleSAXParser`.
SimpleSAXParser
An XML parser that generates "simple" SAX-like events from a limited subset of XML documents.
SingletonQueue<T>
A simple queue that can hold at most one element while in addition provides a function to `SingletonQueue.close()` the queue.
SizeFunction<T>
An interface for computing (typically approximate) size of a specific kind of object.
SizeFunctions
Implementation of size computation for commonly used object types.
SkippingIterable<T>
Interface for ordered data sources that returns a skipping iterator.
SkippingIterables
Few utility functions
SkippingIterator<T>
Iterator over an ordered data source that is able to jump to a specific element (or the next greater after that).
SkippingIterators
Few utility methods to construct skipping iterators.
SkippingLongIterator
Iterator for primitive longs that allows skipping.
SKOS
Constants for the [SKOS](http://www.w3.org/TR/skos-reference) vocabulary.
SortedIterators
Few utility methods to construct skipping iterators
SortedIterators.UnionBuilder<T>
Sorter<T>
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.QuickSorter<T>
Sorter implementation for QuickSort.
SPARQL
The SPARQL Query language
SPARQLCSVResultParser
SPARQLCSVResultWriter
`Writer` implements for SPARQL/CSV query result format
SPARQLCSVResultWriter.CSVRWFactory
`Factory` for creating `SPARQLCSVResultWriter`
SPARQLJSONBooleanResultParser
`BooleanQueryResultParser` for `results` encoded in SPARQL/JSON.
SPARQLJSONBooleanResultWriter
`Writer` for `boolean results` in SPARQL/JSON.
SPARQLJSONBooleanResultWriter.SPARQLJSONBooleanResultWriterFactory
`QueryResultWriterFactory` for `SPARQLJSONBooleanResultWriter`
SPARQLJSONConstants
SPARQLJSONOptions
Options for reading and writing SPARQL/JSON
SPARQLJSONSelectResultParser
`SelectQueryResultParser` for `results` encoded in SPARQL/JSON.
SPARQLJSONSelectResultWriter
`SelectQueryResultWriter` for `select results` as SPARQL/JSON
SPARQLJSONSelectResultWriter.SPARQLJSONSelectResultWriterFactory
SPARQLTSVResultParser
Implementation of `parsing` `query results` in SPARQL/TSV format.
SPARQLTSVResultWriter
Implementation of writing `query results` in SPARQL/TSV format.
SPARQLTSVResultWriter.SPARQLTSVResultWriterFactory
Default factory implementation for `SPARQLTSVResultWriter`
SPARQLUpdateDataBlockParser
An 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).
SPARQLUtil
Collection of utility methods for working with SPARQL strings
SPARQLUtil.QueryType
SPARQLXMLBooleanResultParser
`Parser` for `boolean results` in SPARQL/XML
SPARQLXMLBooleanResultWriter
`Writer` for `BooleanQueryResult` which will serialize results in SPARQL/XML format.
SPARQLXMLBooleanResultWriter.SPARQLXMLSelectResultWriterFactory
`Factory` for `SPARQLXMLBooleanResultWriter`.
SPARQLXMLParserOptions
SPARQLXMLSelectResultParser
SPARQL/XML parsing for `SelectQueryResult`
SPARQLXMLSelectResultWriter
`Writer` for `SelectQueryResult` which will serialize results in SPARQL/XML format.
SPARQLXMLSelectResultWriter.SPARQLXMLSelectResultWriterFactory
`Factory` for `SPARQLXMLSelectResultWriter`.
SpoolingMarkResetIterator<T>
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.
SSD
SSLContextFactory
Utility class for creating SSLContext instances for use by a Netty stack.
StackTrace
StandbyNodeState
Represents that type of cluster node that is in use
StandbyNodeStatus
A convenience class for standby status information
StardogAuthenticationException
Exception thrown when it was not possible to authenticate a stardog user with the provided credentials
StardogAuthorizationException
Exception thrown when the user is not authorized to perform the operation.
StardogException
Base class for all Stardog exceptions
StardogExplainer
Interface for explainer that can provide explanations for inferences made by a Stardog reasoner.
StardogExplainerOptions
Deprecated.
StardogIRI
Deprecated.
Use `IRI` instead
StardogMappings
Deprecated.
StardogMappingSyntaxParser
Parser for Stardog mappings syntax.
StardogMappingSyntaxWriter
A writer that outputs mappings in Stardog syntax.
StardogMappingVocabulary
Vocabulary terms used in Stardog Mapping Syntax.
StardogModelAssembler
An assembler implementation to build a Stardog model from an assembler description in RDF.
StardogModelAssembler.Vocabulary
Stardog assembler vocabulary.
StardogRepository
Implementation of a Stardog-based rdf4j Repository.
StardogRepositoryConfig
Stardog based Repository configuration for use with `StardogRepositoryFactory`
StardogRepositoryConnection
Stardog-based implementation of an RDF4J RepositoryConnection.
StardogRepositoryFactory
Implementation of Sesame's RepositoryFactory interface to support creating StardogRepository instances via their repository configuration API
StateMachine<S,E,O>
This class manages state transitions in an organized way.
Statement
A Statement in RDF.
StatementComparator
Used to serialize trig in a both pretty (all triples in a graph grouped together) and deterministic way.
StatementIterator
Interface which will iterate over a source of Statements.
StatementPattern
A `Statement` implementation representing a Statement pattern, which is a Statement where some or all of the SPOC elements are a wildcard.
StatementPattern.Builder
Statements
Utilities for working with `Statement`.
StatementSource
Interface which represents a source of a set of RDF `statements`.
StatementSources
Utility class for working with StatementSources
StatementSources.RDFStreamStatementSource
StoredQueries
A mutable collection of stored queries.
StoredQuery
Represents a query stored in the server.
StoredQuery.Builder
Builder interface for creating instances of StoredQuery.
StoredQuery.TriggerPayloadType
Enum representing the payload type for triggers.
StoredQuery.TriggerStatus
StreamingJSONLDWriter
Streaming writer for JSON-LD
StreamingJSONLDWriter.StreamingJSONLDWriterFactory
`Factory` for creating `StreamingJSONLDWriter`
Streams
Utility for streams
Streams.CheckedBiConsumer<U,T>
Streams.CheckedBiFunction<In1,In2,Out>
Streams.CheckedConsumer<T>
Streams.CheckedFunction<In,Out>
Streams.CheckedPredicate<T>
Streams.CheckedRunnable
Streams.CheckedSupplier<Out>
Streams.UncheckedException
Exception indicating that Checked* threw an exception and the default handler was used
Strings2
String utilities not provided by `Strings`.
SupportedFileFormats<T>
Utility class to keep a list of `formats` that are supported by an application.
SWRL
Constants for the [SWRL](https://www.w3.org/Submission/SWRL/) vocabulary.
SystemClock
SystemUtil
Utility methods for working with `System`, particularly safe, default value supported lookups into `System.getProperty(java.lang.String)` and other OS/system level calls.
TableData
Create a table data structure that has a list of column names and list of data rows.
TableExporter
TextTable exporter with predefined settings and bug fixes.
TableExporter.FixedTextTableWriter
Fixes a bug in TextTableWriter where right intersection was used in every place a right left intersection was supposed to be used.
Test
A single test that involves running a specific SPARQL query.
Testable
An object that represents a single test or a collection of tests.
TestCreator
Creates a `TestSuite` from query files in a directory.
TestCreator.CreateOption
Option to specify what the created tests will test
TestDefinitionException
TestFailedException
TestReader
Reads a test suite definition from an RDF file.
TestResult
Result of running a `Test`.
TestResultType
Enumeration of test result types.
TestRunner
Runs all the tests in a suite.
TestSuite
A collection of tests organized in a hierarchical structure.
TestVocab
RDF vocabulary used for serializing test definitions.
TestWriter
Writes the test suite definition to an RDF file.
TextBooleanQueryResultParser
`QueryResult` `parser` for text-based results
TextBooleanQueryResultWriter
`Writer` implementation for simple text-based `boolean results`
TextBooleanQueryResultWriter.BQRWriterFactory
`Factory` for `TextBooleanQueryResultWriter`
TextPathQueryResultWriter
Renders path query results in a concise text syntax: `(node1)-[var1=value1, var2=value2]->(node2)`.
TextTablePathQueryResultWriter
Renders path query results in a table where each row shows an edge and multiple paths are separated by an empty row.
TextTableQueryResultWriter
Implementation of `SelectQueryResultWriter` interface to output a nice looking text table with many customization options.
TextTableQueryResultWriter.TextTableQueryResultWriterFactory
TextTabularOutput
Utility class to wrap a `DataExporter` so column widths can be computed on-the-fly by buffering first 1000 results and inspecting values.
ThreadDump
A convenience class for getting a thread dump.
TimeoutCancelCheck
A cancellation check that cancels automatically if a timeout has been reached or delegates to another check timeout has not occurred.
Timer
Class used to keep track how much time is spent for a specific operation.
Timers
ToStringComparator<T>
TransformingLongIterator<T>
Transforms an object iterator to a long iterator.
TransformingRDFHandler
`RDFHandler` that will transform staements before passing them to a delegate
TransientValue
A marker interface for a value which can never exist in the main MappingDictionary, only at query time in a QueryMappingDictionary
TrigParser
Parser for TriG
TrigParserWithRules
Extended `TrigParser` which includes support for embedded rules.
TrigWriter
TrigWriter.TrigWriterFactory
Factory for `TrigWriter`
Tuple
A simple Tuple object.
TupleQueryResultIterator
Adapter for `SelectQueryResult` objects to `Iterator`
TuplesAsPathQueryResult
A wrapper around `tuples` with delimiters to restore paths.
TurtleParser
Default parser for the Turtle RDF syntax
TurtleParserContext
A small extension of `IOParserContext` to maintain the state related to edge property parsing.
TurtleUtil
Utility methods for Turtle encoding/decoding.
TurtleValueParser
A Turtle parser that parses single values (URI, bnodes, literals, and embedded triples) instead of just triples.
TurtleValueWriter
An Turtle writer that writes single values (URI, bnodes, literals) instead of triples.
TurtleWriter
Default implementation of a `writer` for Turtle
TurtleWriter.TurtleWriterFactory
`Factory` for creating `TurtleWriter`
TxInfo
A simple structure that shows information about a transaction.
UnknownQuery
UnsafeUtil
UpdatablePriorityQueue<T>
PriorityQueue class implemented as a binary heap with the additional function that updates the head element if its priority changes.
UpdateQuery
A SPARQL Update query
UpdateQuery
A query that will update a semantic graph
UserManager
API for managing users in Stardog.
ValidationReporter
Interface to generate a SHACL validation report.
Validator
Validator for `ServiceParameters` instances
Value
Base type for a node in an RDF graph
Values
Utility functions for creating and working with RDF values
ValueWeigher<K>
Implementation of the Guava cache `Weigher` interface which will calculate the weight for a `Value` based on how much space is takes in memory.
VCard
Constants for the VCard ontology
Version
View<Input,Output>
Function which supports a polymorphic view of one class as another
View.ViewException
Exception to indicate the reason a `view` failed.
Views<Input>
VirtualGraph
Information about a virtual graph.
VirtualGraphAdminConnection
Connection to manage data sources and virtual graphs
VirtualGraphAdminConnection.InputFileType
VirtualGraphInfo
Information about a virtual graph.
VirtualGraphMappingSyntax
Enumeration of syntax types supported for virtual graph mappings.
VirtualGraphOptions
Options used by virtual graphs.
VoiD
Constants for the VoiD ontology
WGS
Terms in the WGS ontology
WordWrapStringColumn
A simple extension of StringColumn class that fixes the bug in calculating the max row height when word wrapping introduces new lines.
WriterOptions
Options to control the `RDF writing process`
WritingFailed
Indicates that there was an unexpected failure while `writing`
XMLCalendar
Read-only access interface to underlying calendar value
XMLCalendar.Delegate
XMLDatatypes
Utility for XML schema datatypes
XMLDateTime
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)
XMLSchemaDatatypeHandler
An implementation of a datatype handler that can process `XSD` datatypes.
XMLWriter
A utility class offering convenience methods for writing XML.
XSD
Constants for XML Schema datatypes.