Database Configuration

This page discusses configuring a Stardog database’s options, otherwise known as a database’s metadata.

Page Contents

Overview
Getting and Setting Database Options
Database Options
1. Database
2. Docs
3. Edge Properties
4. GraphQL
5. Integrity Constraint Violations (ICV)
6. Index
7. Literal
8. Query
9. Reasoning
10. Search
11. Security
12. Service
13. Spatial
14. BI/SQL
15. Transaction
16. Virtual Graphs
17. Voicebox

Overview

To administer a Stardog database, some configuration options must be set at creation time; others may be changed subsequently and some may never be changed. All config options have sensible defaults (except for the database name), so you don’t have to twiddle any of the knobs till you really need to.

A database’s configuring options are often referred to as its metadata. In fact, in Stardog’s security model, the metadata resource type refers to this.

Getting and Setting Database Options

To configure an existing database via the CLI, you use the metadata-get and metadata-set commands.

Often times, a database must be set to offline status before most configuration parameters may be changed. These properties are known as being “mutable” as explained just below. Hence, the normal routine is to set the database offline, change the parameters, and then set the database online. All of these operations may be done programmatically from CLI tools, such that they can be scripted in advance to minimize downtime.

Below in the database options section, each option’s definition has an attribute “mutability”. The value set here describes a property’s ability to change values. We use the following terms to describe an option’s mutability.

Immutable: Properties that are immutable can only be set at database creation time.
Mutable: Properties that are mutable can only be set while the database is offline. See the db offline CLI command to offline a database.
Freely Mutable: Properties that are freely mutable can be set at any time. It does not matter if the database is online or offline.

You can get some information about a database by running the following command:

$ stardog-admin metadata get my_db_name

This will return all the metadata stored about the database, including the values of configuration options used for this database instance. If you want to get the value for a specific option then you can run the following command:

$ stardog-admin metadata get -o icv.enabled my_db_name

Similarly, to set a database configuration option we can use the metadata set CLI command:

$ stardog-admin metadata set -o icv.enabled=false -- my_db_name

Database Options

The following sections describe available configuration options in Stardog.

Database

`database.archetypes`

Mutability: Mutable
Default
Java API: DatabaseOptions.ARCHETYPES
Description: The name of one or more database archetypes, used to associate ontologies and constraints with new databases. Built-in archetypes are "PROV" and "SKOS", see the docs for instructions to create your own.

`database.connection.timeout`

Mutability: Freely Mutable
Default: 10m
Java API: DatabaseOptions.CONNECTION_TIMEOUT
Description: The amount of time a connection to the database can be open, but inactive, before being automatically closed to reclaim the resources. The following unit suffixes are available: "ms" for milliseconds, "s" for seconds, "m" for minutes, and "h" for hours.

`database.name`

Mutability: Immutable
Default
Java API: DatabaseOptions.NAME
Description: A database name, the legal value of which is given by the regular expression: [A-Za-z]{1}[A-Za-z0-9_-]

`database.namespaces`

Mutability: Freely Mutable
Default: owl, rdf, rdfs, stardog, xsd
Java API: DatabaseOptions.NAMESPACES
Description: The default namespaces for the database. Legal input is a comma-separated list of <prefix>=<namespace> values

`database.online`

Mutability: N/A
Default: true
Java API: DatabaseOptions.ONLINE
Description: Whether or not the database is online

`label.properties`

Mutability: Mutable
Default: {rdfs:label}
Java API: DatabaseOptions.LABEL_PROPERTIES
Description: Comma-separated list of property IRIs which may be used by the platform to look up entity labels by entity IRIs. The order of the properties in the list defines how labels from different properties will be ranked, see this section for details. By default, it's only rdfs:label but properties from SKOS or other schemas can be added.

`graph.aliases`

Mutability: Mutable
Default: false
Java API: DatabaseOptions.GRAPH_ALIASES
Description: Configuration option to enable or disable support for named graph aliases.

`preserve.bnode.ids`

Mutability: Immutable
Default: true
Java API: DatabaseOptions.PRESERVE_BNODE_IDS
Description: Determines how the Stardog parser handles bnode (blank node) identifiers that may be present in RDF input. If this property is enabled, parsing and data loading performance are improved; but the other effect is that if distinct input files use (randomly or intentionally) the same bnode identifier, that bnode will point to one and the same node in the database. If you have input files that use explicit bnode identifiers, and more than one of those files may use the same bnode identifiers, and you don’t want those bnodes to be smushed into a single node in the database, then this configuration option should be disabled.

`progress.monitor.enabled`

Mutability: Freely Mutable
Default: true
Java API: DatabaseOptions.PROGRESS_MONITOR_ENABLED
Description: When enabled, the progress of various tasks will be printed in the server log.

`strict.parsing`

Mutability: Immutable
Default: true
Java API: DatabaseOptions.STRICT_PARSING
Description: Controls whether Stardog parses RDF strictly (true, the default) or loosely (false). Setting this to "false" will allow, for example, integer literals with leading zeros.

Docs

Configuration properties for working with unstructured content in Stardog. Read more about working with unstructured content

`docs.default.rdf.extractors`

Mutability: Mutable
Default: tika
Java API: BitesOptions.DOCS_DEFAULT_RDF_EXTRACTORS
Description: Comma-separated list of names of RDF extractors to use when processing documents when no RDF extractor names are given. Built-in extractors include tika, text, entities, linked and dictionary. See the docs for instructions to create your own.

`docs.default.text.extractors`

Mutability: Mutable
Default: tika
Java API: BitesOptions.DOCS_DEFAULT_TEXT_EXTRACTORS
Description: Comma-separated list of names of text extractors to use when processing documents when no text extractor names are given. See the docs to create your own.

`docs.filesystem.uri`

Mutability: Mutable
Default: file:///
Java API: BitesOptions.DOCS_FILESYSTEM_URI
Description: A URI indicating which FileSystem provider to use for document storage. In addition to local storage (file:///), documents can be stored on Amazon S3 (s3:///) or document storage can be disabled altogether (none)

`docs.opennlp.models.path`

Mutability: Freely Mutable
Default
Java API: BitesOptions.DOCS_OPENNLP_MODELS_PATH
Description: The directory where OpenNLP models are located

`docs.path`

Mutability: Mutable
Default: docs
Java API: BitesOptions.DOCS_PATH
Description: The path under which documents will be stored. A relative path is relative to the database directory. S3 storage should specify an absolute path with the bucket name as the first part of the path

`docs.s3.protocol`

Mutability: Mutable
Default: HTTPS
Java API: BitesOptions.DOCS_S3_PROTOCOL
Description: Protocol used when storing unstructured text documents on S3 (and compatible) stores. Can be set to HTTP to disable TLS/SSL

Edge Properties

Read more about working with edge properties in Stardog.

`edge.properties`

Mutability: Immutable
Default: false
Java API: DatabaseOptions.EDGE_PROPERTIES
Description: Option for enabling edge properties that allows RDF statements to appear as subjects of RDF statements (a.k.a. RDF*).

GraphQL

Read more about Stardog’s support for GraphQL

`graphql.auto.schema`

Mutability: Freely Mutable
Default: false
Java API: GraphQLOptions.AUTO_SCHEMA
Description: Enables automatic generation of the default GraphQL schema if one has not been created by the user.

`graphql.auto.schema.source`

Mutability: Freely Mutable
Default: owl
Java API: GraphQLOptions.AUTO_SCHEMA_SOURCE
Description: Specifies the input source to use for generating the default GraphQL schema automatically.

`graphql.default.limit`

Mutability: Freely Mutable
Default: 10000
Java API: GraphQLOptions.DEFAULT_LIMIT
Description: The maximum number of results a GraphQL query can return. The argument "first" can be used within queries to limit results as well.

`graphql.data.graphs`

Mutability: Freely Mutable
Default: tag:stardog:api:context:local
Java API: GraphQLOptions.DATA_GRAPHS
Description: Specifies which graphs will be queried by default via GraphQL queries. The default value (tag:stardog:api:context:local) is to query all local graphs (default or named). Use the special graph tag:stardog:api:context:all to query all local graphs plus the virtual graphs. Multiple graphs or graph aliases can be used as the option value.

Integrity Constraint Violations (ICV)

Read more about using ICV constraints in Stardog.

`icv.active.graphs`

Mutability: Immutable
Default: stardog:context:local
Java API: ICVOptions.ICV_ACTIVE_GRAPHS
Description: Specifies which part of the database, in terms of named graphs, is checked with IC validation

`icv.consistency.automatic`

Mutability: Mutable
Default: false
Java API: ICVOptions.ICV_CONSISTENCY_AUTOMATIC
Description: Enables automatic ICV consistency check as part of transactions. Ensures that both reasoning consistencies and constraint violations are checked during ICV "Guard Mode" validation (with each commit). This is only effective when "icv.reasoning.enabled" is set to true.

`icv.enabled`

Mutability: Mutable
Default: false
Java API: ICVOptions.ICV_ENABLED
Description: Determines if all database mutations are subject to ICV. When enabled, each commit is inspected to ensure that the contents of the database are valid. Should a transaction attempt to commit invalid data, the commit will fail and the data will not be added/removed.

`icv.explanation.limit`

Mutability: Freely Mutable
Default: 1
Java API: ICVOptions.ICV_EXPLANATION_LIMIT
Description: The number of violations that will be computed and returned in the error message when guard mode is enabled. If the option is set to 0 no explanations will be computed and transaction failure will only indicate there was a violation without specifying which constraint failed.

`icv.reasoning.enabled`

Mutability: Mutable
Default: false
Java API: ICVOptions.ICV_REASONING_ENABLED
Description: Determines if reasoning is used during ICV.

Index

Set of options for configuring the low-level indexes.

`index.literals.canonical`

Mutability: Immutable
Default: true
Java API: IndexOptions.CANONICAL_LITERALS
Description: Specify that non-string typed literals are canonicalized in the database. Improves query and loading performance, but does change literal values to a canonical form. For example, "1"^^xsd:byte is canonicalized to "1"^^xsd:integer. Set this option to false if you require literals to be exactly as specified, rather than canonicalized. The default value is true. Note that, this value can only be set at database creation time and cannot be changed at a future time.

`index.lucene.mmap`

Mutability: Mutable
Default: true
Java API: DatabaseOptions.LUCENE_MMAP
Description: Enables memory-mapping in lucene indices (e.g., search, spatial).

`index.statistics.cache.capacity`

Mutability: Mutable
Default: 1024
Java API: IndexOptions.CARDINALITY_CACHE_CAPACITY
Description: The max capacity for the query pattern cardinality cache that is shared across queries to the same database.

`index.statistics.chains.enabled`

Mutability: Freely Mutable
Default: true
Java API: IndexOptions.STATISTICS_CHAINS_ENABLED
Description: If true, Stardog will pre-compute the number of times frequent binary chains occur in the data and will use that information for query optimization.Could be disabled for very large or very complex datasets. Changes to this option will take effect the next time statistics is recomputed.

`index.statistics.ranges.enabled`

Mutability: Freely Mutable
Default: true
Java API: IndexOptions.STATISTICS_RANGES_ENABLED
Description: If true, Stardog will pre-compute the number of common objects for pairs of properties in the dataset. This information is used for query optimization. Could be disabled for very large or very complex datasets. Changes to this option will take effect the next time statistics is recomputed.

`index.statistics.characteristic.limit`

Mutability: Freely Mutable
Default: 10000
Java API: IndexOptions.STATISTICS_CHARACTERISTIC_SETS_LIMIT
Description: The max number of characteristic sets computed as a part of the statistical summary of the database. More diverse datasets may require a higher number for more accurate query planning. The downside is higher memory footprint and slower planning

`index.statistics.enable_active_graph`

Mutability: Mutable
Default: true
Java API: IndexOptions.STATS_ENABLE_ACTIVE_GRAPH
Description: If true, Stardog will adjust the cardinality estimation for a query based on the size of the active graph and the size of all graphs in the database. Could be disabled for databases with few large named graphs with non-overlapping data. For details, see the section in managing query performance.

`index.statistics.on_db_create`

Mutability: Immutable
Default: Sync
Java API: IndexOptions.STATISTICS_ON_DB_CREATION
Description: Determines whether and how selectivity statistics are computed when a database is bulk loaded. By default, they're computed synchronously.

`index.statistics.update.automatic`

Mutability: Freely Mutable
Default: true
Java API: IndexOptions.AUTO_STATS_UPDATE
Description: Determines whether statistics are maintained automatically. When set to "true", Stardog will decide when to update statistics as the database is modified through additions and removals and update statistics as needed. If this option is set to "false", Stardog will never update the statistics regardless of how much the database is updated.

`index.statistics.update.blocking.ratio`

Mutability: Freely Mutable
Default: 0.0
Java API: IndexOptions.STATS_UPDATE_BLOCKING_RATIO
Description: Once the ratio of updated triples to database size goes over this limit statistics computation will be performed synchronously within the transaction instead of a background thread. Setting this option to a non-positive number (<= 0) will disable blocking updates.

`index.statistics.update.min.size`

Mutability: Freely Mutable
Default: 10000
Java API: IndexOptions.STATS_UPDATE_DB_MIN_SIZE
Description: Minimum number of triples that should be in the database for statistics to be updated automatically

`index.statistics.update.ratio`

Mutability: Freely Mutable
Default: 0.1
Java API: IndexOptions.STATS_UPDATE_RATIO
Description: Ratio of updated triples to the number of triples in the database that triggers the automatic statistics computation in a background thread

`index.bulk.load.sst.txlimit`

Mutability: Mutable
Default: 4000000
Java API: IndexOptions.TX_SST_WRITE_LIMIT
Description: The threshold of number of quads at which the bulk loading mechanism is used for transactional updates.

Literal

`literal.comparison.extended`

Mutability: Mutable
Default: true
Java API: DatabaseOptions.EXTENDED_COMPARISON
Description: Controls whether query evaluation will use extended literal comparison. If enabled, literals of different datatypes are first compared based on their string values and then based on the string value of their datatypes.

`literal.language.normalization`

Mutability: Freely Mutable
Default: DEFAULT
Java API: DatabaseOptions.LANGUAGE_NORMALIZATION
Description: Configuration option for determining the normalization algorithm for the language tags of literals. Other options are RFC3066 and BCP47

Query

Configuration for queries in Stardog. Read more about query management in Stardog.

`query.all.graphs`

Mutability: Freely Mutable
Default: false
Java API: DatabaseOptions.QUERY_ALL_GRAPHS
Description: This option controls the behavior for answering queries that don’t specify a dataset (FROM or FROM NAMED) in the query. In such cases, the SPARQL specification says that the query should be answered only using the information in default graph (no context). However, sometimes it is desirable to answer such queries using all the information in the database including the default graph and all named graphs. Setting this option to "true" changes the behavior of Stardog to do this. Queries that specify a dataset are not affected by this option.

`query.describe.strategy`

Mutability: Freely Mutable
Default: default
Java API: DatabaseOptions.QUERY_DESCRIBE_STRATEGY
Description: The default DESCRIBE query strategy for the database. Built-in strategies include default, cbd and bidirectional. Read more about this in Querying Stardog.

`query.memory.limit`

Mutability: Freely Mutable
Default: 9223372036854775807B
Java API: DatabaseOptions.QUERY_MEMORY_LIMIT
Description: Configuration option for determining the memory limit used by query. Value should be provided in bytes as seen in the default value. This value may be overridden by the server configuration.

`query.memory.exceeds.strategy`

Mutability: Freely Mutable
Default: SPILL_TO_DISK
Java API: DatabaseOptions.QUERY_MM_EXCEEDS_STRATEGY
Description: Configuration option for determining strategy for the query behaviour once query memory limit reached. Query memory limit is determined by the database configuration option query.memory.limit. The server configuration may prohibit spilling.

`query.plan.reuse`

Mutability: Freely Mutable
Default: ALWAYS
Java API: DatabaseOptions.QUERY_PLAN_REUSE
Description: The conditions under which a cached plan will be reused. ALWAYS and NEVER determine query plan reuse as you would expect. CARDINALITY instructs Stardog to reuse cached query plans for structurally equivalent queries if the cardinality estimations of scans are similar.

`query.timeout`

Mutability: Freely Mutable
Default: 5m
Java API: DatabaseOptions.QUERY_TIMEOUT
Description: Determines max execution time for read query evaluation. This can also be overridden in a query’s parameters. The following unit suffixes are available: "ms" for milliseconds, "s" for seconds, "m" for minutes, and "h" for hours.

`query.update.timeout`

Mutability: Freely Mutable
Default: 10h
Java API: DatabaseOptions.QUERY_UPDATE_TIMEOUT
Description: Determines max execution time for SPARQL Update query evaluation. It also applies to queries copying Virtual Graphs. This can also be overridden in a query’s parameters. The following unit suffixes are available: "ms" for milliseconds, "s" for seconds, "m" for minutes, and "h" for hours.

Reasoning

Configuration options for reasoning in Stardog. Read more about reasoning in Stardog.

`reasoning.approximate`

Mutability: Mutable
Default: false
Java API: ReasoningOptions.APPROXIMATE
Description: Enables approximate reasoning. With this flag enabled Stardog will approximate an axiom that is outside the profile Stardog supports and normally ignored. For example, an equivalent class axiom might be split into two subclass axioms and only one subclass axiom is used.

`reasoning.classify.eager`

Mutability: Mutable
Default: true
Java API: ReasoningOptions.EAGER_CLASSIFY
Description: Perform schema classification eagerly when the schema is loaded. Classifying eagerly ensures subclass and equivalence queries between named classes can be answered with a simple lookup. However, if the schema is changing frequently then this option can be turned off so classification is performed only if necessary.

`reasoning.consistency.automatic`

Mutability: Mutable
Default: false
Java API: ReasoningOptions.CONSISTENCY_AUTOMATIC
Description: Enables automatic consistency checking as part of every query performed with reasoning enabled. If the underlying database did not change since the last consistency check, the check will not be performed.

`reasoning.precompute.non_empty.predicates`

Mutability: Freely Mutable
Default: true
Java API: ReasoningOptions.PRECOMPUTE_NON_EMPTY_TERMS
Description: If true, Stardog will pre-compute class and property names which have assertions in the data. That can speed-up reasoning but may slow things down when data changes often.

`reasoning.punning.enabled`

Mutability: Mutable
Default: false
Java API: ReasoningOptions.PUNNING_ENABLED
Description: Enables punning; the ability for an IRI to represent both a class and an individual.

`reasoning.rewriting`

Mutability: Mutable
Default: PER_SCOPE
Java API: ReasoningOptions.REWRITING_STRATEGY
Description: Allows one to choose how query patterns are rewritten for reasoning: as a whole (per scope) or individually (per pattern).

`reasoning.sameas`

Mutability: Mutable
Default: OFF
Java API: ReasoningOptions.EQUALITY_REASONING
Description: Option to enable owl:sameAs reasoning. When this option is set to ON, then the reflexive, symmetric, and transitive closure of owl:sameAs triples in the database are computed. When it is set to FULL, then owl:sameAs inferences are computed based on schema axioms, such as functional properties. See the section on sameAs reasoning.

`reasoning.schema.timeout`

Mutability: Freely Mutable
Default: 1m
Java API: ReasoningOptions.SCHEMA_REASONING_TIMEOUT
Description: Timeout for schema reasoning. If schema reasoning cannot be completed in the specified time then only RDFS reasoning will be performed for the schema which might yield incomplete answers for the schema queries. The timeout values specified as test be a positive integer followed by either letter 'h' (for hours), letter 'm' (for minutes), letter 's' (for seconds), or letters 'ms' (for milliseconds). Examples: 1h for 1 hour, 5m for 5 minutes, 90s for 90 seconds, 500ms for 500 milliseconds.

`reasoning.schemas`

Mutability: Freely Mutable
Default
Java API: ReasoningOptions.SCHEMAS
Description: Option to specify the schemas and the named graphs that constitute each schema. The value is a comma-separated collection of schema=IRI pairs. There should be one pair for each named graph in a schema. The graphs for the default schema are set via the reasoning.schema.graphs option.

`reasoning.schema.graphs`

Mutability: Freely Mutable
Default
Java API: ReasoningOptions.SCHEMA_GRAPHS
Description: Determines which, if any, named graph or graphs contains the schema (ontology, "TBox") part of the data. The legal value is a comma-separated list of named graph identifiers, including (optionally) the special names, tag:stardog:api:context:default and tag:stardog:api:context:local, which represent the default graph and the union of all local (non-virtual) named graphs and the default graph, respectively. In the context of database configurations only, Stardog will recognize default and * as short forms of those URIs, respectively.

`reasoning.schemas.memory.count`

Mutability: Mutable
Default: 5
Java API: ReasoningOptions.SCHEMAS_MEMORY_COUNT
Description: Option to specify the number of schemas to keep in memory. There can be more schemas defined in the database but only this many schemas will be kept in memory and other schemas will be pulled into memory as queries are getting answered. If this limit is too high, the amount of memory used for schemas will increase and might cause memory problems. If it is too low then answering reasoning queries might slow down.

`reasoning.type`

Mutability: Mutable
Default: SL
Java API: ReasoningOptions.REASONING_TYPE
Description: Specifies the reasoning type associated with the database, most corresponding to the OWL Profiles of the same name. The following reasoning types are available: RDFS (OWL 2 axioms allowed in RDF Schema), QL (OWL 2 QL axioms), RL (OWL 2 RL axioms), EL (OWL 2 EL axioms), DL (OWL 2 DL axioms), SL (a combination of RDFS, QL, RL and EL axioms + user-defined rules) and NONE (disables reasoning). Any axiom outside the selected type will be ignored by the reasoner.

`reasoning.virtual.graph.enabled`

Mutability: Freely Mutable
Default: true
Java API: ReasoningOptions.VIRTUAL_GRAPH
Description: Flag to enable reasoning over virtual graphs and SERVICE clauses.

Search

Configuration options for working with full-text search. Read more about Stardog’s full-text search capabilities.

`search.enabled`

Mutability: Mutable
Default: false
Java API: SearchOptions.SEARCHABLE
Description: Enables the full-text (unstructured) search index for the database; important for Lexical and Semantic Search applications.

`search.index.compute.norm`

Mutability: Mutable
Default: false
Java API: SearchOptions.INDEX_COMPUTE_NORM
Description: Specify the value lengths (norms) should be computed and indexed. This is required for document length to influence scoring rank.

`search.index.datatypes`

Mutability: Immutable
Default: xsd:string, rdf:langString
Java API: SearchOptions.INDEX_DATATYPES
Description: Specify the data types for which to index literals in Lucene. Literals with other data types will not be accessible via full-text search.

`search.index.properties.excluded`

Mutability: Mutable
Default
Java API: SearchOptions.INDEX_PROPERTIES_EXCLUDED
Description: Specify the set of property IRIs for which values in triples with these predicates will not be indexed.

`search.index.properties.included`

Mutability: Mutable
Default
Java API: SearchOptions.INDEX_PROPERTIES_INCLUDED
Description: Specify the set of property IRIs for which values in triples only with these predicates will be indexed.

`search.index.contexts.filter`

Mutability: Mutable
Default
Java API: SearchOptions.SEARCH_CONTEXTS_FILTER
Description: Specify the collection of contexts in named graphs to be excluded or included for literals to be indexed depending on SearchOptions.SEARCH_CONTEXTS_EXCLUDED option.

`search.index.contexts.excluded`

Mutability: Mutable
Default: true
Java API: SearchOptions.SEARCH_CONTEXTS_EXCLUDED
Description: Specify if the collection of contexts in named graphs is going to be leveraged as either excluded or included for literals to be indexed.

`search.index.stopwords`

Mutability: Mutable
Default
Java API: SearchOptions.INDEX_STOPWORDS
Description: Specify the list of the stop words to omit while indexing literal content and analyzing queries.

`search.index.wordbreak.chars`

Mutability: Mutable
Default
Java API: SearchOptions.WORD_BREAK_CHARS
Description: A set of characters which are used to break words. Whitespace is also included. See [here](https://support.stardog.com/support/solutions/articles/151000197169-how-do-i-reset-tokenization-S) for how to reset this value.

`search.reindex.tx`

Mutability: Freely Mutable
Default: true
Java API: SearchOptions.SEARCH_REINDEX_IN_TX
Description: Whether literals added during a transaction are automatically indexed. If this flag is set to 'false', then full-text search queries will return incomplete results until the index is rebuilt.

`search.reindex.cache.size`

Mutability: Freely Mutable
Default: 16384
Java API: SearchOptions.REINDEX_CACHE_SIZE
Description: Option to specify the cache size of how many literals to be kept to check if a literal is indexed before. This cache is leveraged to prevent heavy memory usage when large amount of data with literals indexed for full-text search. Therefore, when vast amount of literals are planned to be indexed, the cache size could be increased according to the data size.

`search.wildcard.search.enabled`

Mutability: Freely Mutable
Default: false
Java API: SearchOptions.LEADING_WILDCARD_SEARCH_ENABLED
Description: Enable support to query the Lucene full-text search index with leading wildcards.

`search.lexical.enabled`

Mutability: Mutable
Default: true
Java API: SearchOptions.SEARCH_LEXICAL
Description: Enables the lexical mode for full-text (unstructured) search index for the database. Has effect only when search.enabled is true.

`search.semantic.enabled`

Mutability: Mutable
Default: false
Java API: SearchOptions.SEARCH_SEMANTIC
Description: Enables semantic search. Has effect only when search.enabled is true.

`search.semantic.model`

Mutability: Mutable
Default
Java API: SearchOptions.SEARCH_SEMANTIC_MODEL
Description: Specifies URI of language model for semantic search. Has effect only when both search.enabled and search.semantic.enabled are true.

`search.index.batch.size`

Mutability: Mutable
Default: 1000
Java API: SearchOptions.SEARCH_INDEX_BATCH_SIZE
Description: Specifies the number of Lucene documents that are written to search index in one batch.

Security

Security configuration options in Stardog.

`security.named.graphs`

Mutability: Freely Mutable
Default: false
Java API: SecurityOptions.NAMED_GRAPH_SECURITY_ENABLED
Description: If enabled, named graphs are an explicit resource type in Stardog’s security model. Read more about named graph security.

`security.masking.function`

Mutability: Freely Mutable
Default
Java API: SecurityOptions.MASKING_FUNCTION
Description: SPARQL function to mask values of sensitive properties. There should be one variable in there which will be replaced by actual sensitive nodes at query time. See Fine Grained Security for more information.

`security.properties.sensitive`

Mutability: Freely Mutable
Default
Java API: SecurityOptions.SENSITIVE_PROPERTIES
Description: Comma-separated set of property IRIs to which access is granted explicitly. See Fine Grained Security for more information.

Service

Configuration options for services in Stardog. Read more about federated queries in Stardog.

`service.sparql.result.limit`

Mutability: Mutable
Default: 1000
Java API: DatabaseOptions.SPARQL_SERVICE_RESULT_LIMIT
Description: Limits the number of results generated by SERVICE calls to SPARQL endpoints. A negative value means no limit.

`service.sparql.credentials.passthrough.regex`

Mutability: Mutable
Default
Java API: DatabaseOptions.SPARQL_SERVICE_CREDENTIALS_PASSTHROUGH_REGEX
Description: Specifies SPARQL endpoints for which SERVICE calls are allowed to pass through current credentials.

`service.prefetch.threshold`

Mutability: Mutable
Default: -1
Java API: DatabaseOptions.SPARQL_SERVICE_CREDENTIALS_PASSTHROUGH_REGEX
Description: The cardinality threshold for prefetching solutions from remote services. A negative value disables prefetching and a value of Integer.MAX_VALUE (i.e., 2147483647) means prefetching is always enabled. If the estimated cardinality of a service is below the threshold, 10000 solutions will be prefetched by default. The number of solutions to be prefetched can be customized with the service.prefetch.limit query hint.

Spatial

Configuration options for working with spatial data in Stardog. Read more about Stardog’s geospatial support.

`spatial.enabled`

Mutability: Mutable
Default: false
Java API: GeospatialOptions.SPATIAL_ENABLED
Description: Enables the geospatial search index for the database.

`spatial.error.percentage`

Mutability: Immutable
Default: 0.025
Java API: GeospatialOptions.SPATIAL_ERROR_PCT
Description: A measure of acceptable error of the shape as a fraction. The value roughly corresponds to the fraction of a shape's approximate radius. This setting does not affect points which are always indexed at the configured maximum precision as specified by spatial.precision but will affect other shapes. The default value is 0.025 (2.5%) and the valid values are between 0 and 0.5 (50%). Increasing this value will improve performance as less levels are used but results will be less accurate.

`spatial.precision`

Mutability: Immutable
Default: 11
Java API: GeospatialOptions.SPATIAL_PRECISION
Description: Specifies the precision used for the indexing of geospatial data. The smaller the value, the less precision, but the better the performance of geospatial queries. The default value is 11 which yields sub-meter precision; a value of 8 will give a precision +/- 50m.

`spatial.result.limit`

Mutability: Freely Mutable
Default: 10000
Java API: GeospatialOptions.SPATIAL_RESULT_LIMIT
Description: Specify the default limit on the number of results returned from a geospatial query (-1 returns all results). This only limits the number of results returned from the geospatial index, not from its containing query.

BI/SQL

Stardog provides a facility to bridge the flexible schema of the graph data model to the traditional relational model required by business intelligence tools using SQL. Read more about using BI tools with Stardog.

`sql.schema.auto`

Mutability: Mutable
Default: true
Java API: SerfOptions.AUTO_SCHEMA
Description: Enables automatic SQL schema generation when one does not exist in the database.

`sql.schema.auto.source`

Mutability: Mutable
Default: owl
Java API: SerfOptions.AUTO_SCHEMA_FORMAT
Description: Specifies the input source to use for generating the SQL schema automatically when one does not exist in the database.

`sql.data.graphs`

Mutability: Mutable
Default: tag:stardog:api:context:all
Java API: SerfOptions.DATA_GRAPHS
Description: Specifies which graphs will be queried by default via SQL queries. The default value (tag:stardog:api:context:all) is to query all local graphs (default or named) plus any virtual graphs that might have been defined. Setting this option to another value will mean any other graph will be ignored by the SQL queries. Use the special graph tag:stardog:api:local to query all graphs but exclude virtual graphs. Multiple graphs or graph aliases can be used as the option value.

`sql.schema.graph`

Mutability: Mutable
Default: tag:stardog:api:sql:schema
Java API: SerfOptions.SCHEMA_GRAPH
Description: Specifies which named graph in the database is used to read SQL schema mapping.

Transaction

Configuration for transactions in Stardog. Read more about Stardog’s transactional semantics and guarantees.

`transaction.isolation`

Mutability: Mutable
Default: SNAPSHOT
Java API: DatabaseOptions.TRANSACTION_ISOLATION
Description: Configures isolation level for transactions

`transaction.logging`

Mutability: Mutable
Default: false
Java API: DatabaseOptions.TRANSACTION_LOGGING
Description: Option for whether or not the database logs all transactions events to disk. The default when not in Cluster mode is "false", and when in Cluster mode the default is "true".

`transaction.logging.rotation.remove`

Mutability: Mutable
Default: true
Java API: DatabaseOptions.TRANSACTION_LOGGING_ROTATION_REMOVE
Description: Determines whether old log files will be deleted after rotation

`transaction.logging.rotation.size`

Mutability: Mutable
Default: 524288000
Java API: DatabaseOptions.TRANSACTION_LOGGING_ROTATION_SIZE
Description: Determines the size (in bytes) at which the transaction log will be rotated

`transaction.logging.use.rotated`

Mutability: Mutable
Default: true
Java API: DatabaseOptions.TRANSACTION_LOGGING_USE_ROTATED
Description: Enables using rotated transaction log

`transaction.write.conflict.strategy`

Mutability: Immutable
Default: LAST_COMMIT_WINS
Java API: IndexOptions.WRITE_CONFLICT_STRATEGY
Description: Which conflict resolution strategy to use for this database. Write conflicts occur when two transactions attempt to modify the same statement in the database simultaneously.

`transaction.commit.twophase`

Mutability: Mutable
Default: false
Java API: DatabaseOptions.TX_COMMIT_2P
Description: Enables two phase commit protocol for the cluster (this option has no effect for the single node server). When this option is enabled all the nodes in the cluster will prepare the transaction in the first phase of the commit. This ensures all nodes complete time-consuming operations and only after that the second phase of the commit will start where the coordinator will send the commit command to the other nodes. Once a node completes the commit operation the effects of the transaction will be visible in query results. With this option enabled the period of time where nodes might return different results to queries will be minimized. This option is most useful for long transactions (e.g., transactions that take several minutes or more) where the commit time for each node might differ in a noticeable way without the additional commit phase. For short transactions, enabling this option will not provide visible benefits (especially if transactions complete under a second) and the overhead of the additional commit phase will result in increased transaction times.

Virtual Graphs

Configuration options for virtual graphs and related to Virtual Transparency. Read more in depth about Virtual Graphs

`virtual.transparency`

Mutability: Freely Mutable
Default: false
Java API: DatabaseOptions.VIRTUAL_TRANSPARENCY
Description: Determines what data the database evaluates queries against; if true, it will query over the default graph and the union of all accessible virtual graphs; if false (the default), it will query only over the default graph. Requires query.all.graphs to be true.

`local.iri.template.includes`

Mutability: Freely Mutable
Default
Java API: DatabaseOptions.LOCAL_IRI_TEMPLATE_INCLUDES
Description: The set of IRI templates representing the form of IRIs that may be present in the subject position of triples in the local database. Used when optimizing queries including both the local database and virtual graphs. IRI templates use the same placeholder syntax as mappings (eg, {field}) but the field names are ignored. Templates included here should be used to indicate which IRIs may be present and should be updated when that changes.

`local.iri.template.excludes`

Mutability: Freely Mutable
Default
Java API: DatabaseOptions.LOCAL_IRI_TEMPLATE_EXCLUDES
Description: The set of IRI templates representing the form of IRIs that may **not** be present in the subject position of triples in the local database. Used when optimizing queries including both the local database and virtual graphs. IRI templates use the same placeholder syntax as mappings (eg, {field}) but the field names are ignored. Templates included here should be used to indicate which IRIs are guaranteed **not** to be present and should be updated when that changes.

Voicebox

Configuration options for Stardog’s Voicebox generative AI service.

`voicebox.enabled`

Mutability: Mutable
Default: false
Java API: DatabaseOptions.VOICEBOX_ENABLED
Description: If set to true, enables the Voicebox LLM-based features for this database. Enabling Voicebox for this database also enables the options for full-text search (search.enabled), semantic search (search.semantic.enabled), and indexing value lengths (norms) (search.index.compute.norm). Note that if semantic search is auto-enabled as a result of enabling Voicebox, only selected graphs will have semantic indexing enabled, specifically, schema graphs and the graph where Voicebox queries are stored.

`voicebox.preprocessors`

Mutability: Mutable
Default: "default"
Java API: DatabaseOptions.VOICEBOX_PREPROCESORS
Description: List of preprocessors that will be applied to the stored queries to canonicalize the query serialization. Preprocessors transform queries into a form that is more suitable for Voicebox. Using the "default" value enables the default list of preprocessors. The value "noop" can be used to disable preprocessing.