blob: 19f61aab0cede6a0863bd1efa86117cade3a6088 [file] [log] [blame]
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
<channel>
<title>Documentations on Apache Jena</title>
<link>https://jena.apache.org/documentation.html</link>
<description>Recent content in Documentations on Apache Jena</description>
<generator>Hugo -- gohugo.io</generator>
<language>en</language>
<atom:link href="https://jena.apache.org/documentation/index.xml" rel="self" type="application/rss+xml" />
<item>
<title>A brief guide to Jena Eyeball</title>
<link>https://jena.apache.org/documentation/archive/eyeball/eyeball-guide.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/eyeball/eyeball-guide.html</guid>
<description>This page is historical &amp;ldquo;for information only&amp;rdquo; - there is no Apache release of Eyeball and the code has not been updated for Jena3.
The original source code is available.
So you&amp;rsquo;ve got Eyeball installed and you&amp;rsquo;ve run it on one of your files, and Eyeball doesn&amp;rsquo;t like it. You&amp;rsquo;re not sure why, or what to do about it. Here&amp;rsquo;s what&amp;rsquo;s going on.
Eyeball inspects your model against a set of schemas.</description>
</item>
<item>
<title>Adding Jena Permissions to Fuseki</title>
<link>https://jena.apache.org/documentation/permissions/example.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/permissions/example.html</guid>
<description>Overview The goal of this document is to add Jena Permissions to a fuseki deployment to restrict access to graph data. This example will take the example application, deploy the data to a fuseki instance and add the Jena Permissions to achieve the same access restrictions that the example application has.
To do this you will need a Fuseki installation, the Permissions Packages and a SecurityEvaluator implementation. For this example we will use the SecurityEvaluator from the permissions-example.</description>
</item>
<item>
<title>Apache Jena documentation overview</title>
<link>https://jena.apache.org/documentation/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/</guid>
<description>This section contains detailed information about the various Jena sub-systems, aimed at developers using Jena. For more general introductions, please refer to the Getting started and Tutorial sections.
Documentation index The RDF API - the core RDF API in Jena SPARQL - querying and updating RDF models using the SPARQL standards Fuseki - SPARQL server which can present RDF data and answer SPARQL queries over HTTP I/O - reading and writing RDF data RDF Connection - a SPARQL API for local datasets and remote services Assembler - describing recipes for constructing Jena models declaratively using RDF Inference - using the Jena rules engine and other inference algorithms to derive consequences from RDF models Ontology - support for handling OWL models in Jena Data and RDFS - apply RDFS to graphs in a dataset TDB2 - a fast persistent triple store that stores directly to disk TDB - Original TDB database SHACL - SHACL processor for Jena ShEx - ShEx processor for Jena Text Search - enhanced indexes using Lucene for more efficient searching of text literals in Jena models and datasets.</description>
</item>
<item>
<title>Apache Jena Elephas</title>
<link>https://jena.apache.org/documentation/archive/hadoop/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/hadoop/</guid>
<description> The Jena Elephas module has been retired. The last release of Jena with Elephas is Jena 3.17.0. See jena-elephas/README.md. The original documentation.
</description>
</item>
<item>
<title>Apache Jena Elephas</title>
<link>https://jena.apache.org/documentation/archive/hadoop/elephas_index.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/hadoop/elephas_index.html</guid>
<description>Apache Jena Elephas is a set of libraries which provide various basic building blocks which enable you to start writing Apache Hadoop based applications which work with RDF data.
Historically there has been no serious support for RDF within the Hadoop ecosystem and what support has existed has often been limited and task specific. These libraries aim to be as generic as possible and provide the necessary infrastructure that enables developers to create their application specific logic without worrying about the underlying plumbing.</description>
</item>
<item>
<title>Apache Jena Elephas - Common API</title>
<link>https://jena.apache.org/documentation/archive/hadoop/common.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/hadoop/common.html</guid>
<description>The Common API provides the basic data model for representing RDF data within Apache Hadoop applications. This primarily takes the form of Writable implementations and the necessary machinery to efficiently serialise and deserialise these.
Currently we represent the three main RDF primitives - Nodes, Triples and Quads - though in future a wider range of primitives may be supported if we receive contributions to implement them.
RDF Primitives Nodes The Writable type for nodes is predictably enough called NodeWritable and it implements the WritableComparable interface which means it can be used as both a key and/or value in Map/Reduce.</description>
</item>
<item>
<title>Apache Jena Elephas - IO API</title>
<link>https://jena.apache.org/documentation/archive/hadoop/io.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/hadoop/io.html</guid>
<description>The IO API provides support for reading and writing RDF within Apache Hadoop applications. This is done by providing InputFormat and OutputFormat implementations that cover all the RDF serialisations that Jena supports.
{% toc %}
Background on Hadoop IO If you are already familiar with the Hadoop IO paradigm then please skip this section, if not please read as otherwise some of the later information will not make much sense.</description>
</item>
<item>
<title>Apache Jena Elephas - Map/Reduce API</title>
<link>https://jena.apache.org/documentation/archive/hadoop/mapred.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/hadoop/mapred.html</guid>
<description>The Map/Reduce API provides a range of building block Mapper and Reducer implementations that can be used as a starting point for building Map/Reduce applications that process RDF. Typically more complex applications will need to implement their own variants but these basic ones may still prove useful as part of a larger pipeline.
{% toc %}
Tasks The API is divided based upon implementations that support various common Hadoop tasks with appropriate Mapper and Reducer implementations provided for each.</description>
</item>
<item>
<title>Apache Jena Elephas - RDF Stats Demo</title>
<link>https://jena.apache.org/documentation/archive/hadoop/demo.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/hadoop/demo.html</guid>
<description>The RDF Stats Demo is a pre-built application available as a ready to run Hadoop Job JAR with all dependencies embedded within it. The demo app uses the other libraries to allow calculating a number of basic statistics over any RDF data supported by Elephas.
To use it you will first need to build it from source or download the relevant Maven artefact:
&amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.apache.jena&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;jena-elephas-stats&amp;lt;/artifactId&amp;gt; &amp;lt;version&amp;gt;x.y.z&amp;lt;/version&amp;gt; &amp;lt;classifier&amp;gt;hadoop-job&amp;lt;/classifier&amp;gt; &amp;lt;/dependency&amp;gt; Where x.</description>
</item>
<item>
<title>Apache Jena Fuseki</title>
<link>https://jena.apache.org/documentation/fuseki2/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/</guid>
<description>Apache Jena Fuseki is a SPARQL server. It can run as a operating system service, as a Java web application (WAR file), and as a standalone server.
Fuseki comes in in two forms, a single system &amp;ldquo;webapp&amp;rdquo;, combined with a UI for admin and query, and as &amp;ldquo;main&amp;rdquo;, a server suitable to run as part of a larger deployment, including with Docker or running embedded. Both forms use the same core protocol engine and same configuration file format.</description>
</item>
<item>
<title>Apache Jena GeoSPARQL</title>
<link>https://jena.apache.org/documentation/geosparql/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/geosparql/</guid>
<description>An implementation of GeoSPARQL 1.0 standard for SPARQL query or API.
Integration with Fuseki is provided either by using the GeoSPARQL assembler or using the self-contained original jena-fuseki-geosparql. In either case, this page describes the GeoSPARQL supported features.
Getting Started GeoSPARQL Jena can be accessed as a library using Maven etc. from Maven Central.
&amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.apache.jena&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;jena-geosparql&amp;lt;/artifactId&amp;gt; &amp;lt;version&amp;gt;...&amp;lt;/version&amp;gt; &amp;lt;/dependency&amp;gt; Features This implementation follows the 11-052r4 OGC GeoSPARQL standard (https://www.ogc.org/standards/geosparql). The implementation is pure Java and does not require any set-up or configuration of any third party relational databases and geospatial extensions.</description>
</item>
<item>
<title>Apache Jena Initialization</title>
<link>https://jena.apache.org/documentation/notes/system-initialization.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/system-initialization.html</guid>
<description>Jena has a simple initialization sequence that is used to setup components available at runtime.
Application code is welcome to also use this mechanism. This must be done with care. Java initialization can lead to visibility of uninitialized data.
The standard initialization sequence is
Core -&amp;gt; RIOT -&amp;gt; ARQ -&amp;gt; TDB -&amp;gt; other (including jena text)
The sequence from core to TDB should be executed before application components. See below for how to control the order.</description>
</item>
<item>
<title>Apache Jena SDB - persistent triple stores using relational databases</title>
<link>https://jena.apache.org/documentation/archive/sdb/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/</guid>
<description> The Jena SDB module has been retired. The last release of Jena with this module is Jena 3.17.0. See jena-sdb/README.md. The original documentation.
</description>
</item>
<item>
<title>Apache Jena SHACL</title>
<link>https://jena.apache.org/documentation/shacl/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/shacl/</guid>
<description>jena-shacl is an implementation of the W3C Shapes Constraint Language (SHACL). It implements SHACL Core and SHACL SPARQL Constraints.
In addition, it provides:
SHACL Compact Syntax SPARQL-based targets Command line The command shacl introduces shacl operations; it takes a sub-command argument.
To validate:
shacl validate --shapes SHAPES.ttl --data DATA.ttl shacl v -s SHAPES.ttl -d DATA.ttl The shapes and data files can be the same; the --shapes is optional and defaults to the same as --data.</description>
</item>
<item>
<title>Apache Jena ShEx</title>
<link>https://jena.apache.org/documentation/shex/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/shex/</guid>
<description>jena-shex is an implementation of the ShEx (Shape Expressions) language.
This implementation is experimental, starting with Jena 4.2.0. Please send usage reports and experience to users@jena.apache.org. Status jena-shex reads ShExC (the compact syntax) files.
Not currently supported:
semantic actions EXTERNAL Blank node label validation is meaningless in Jena because a blank node label is scoped to the file, and not retained after the file has been read.</description>
</item>
<item>
<title>Apache Jena SPARQL APIs</title>
<link>https://jena.apache.org/documentation/sparql-apis/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/sparql-apis/</guid>
<description>Jump to the &amp;ldquo;Changes&amp;rdquo; section.
Overview The SPARQL specifications provide query, update and the graph store protocol (GSP). In addition, Jena provided store operations for named graph formats.
For working with RDF data:
API GPI Model Graph Statement Triple Resource Node Literal Node String Var Dataset DatasetGraph Quad and for SPARQL,</description>
</item>
<item>
<title>ARQ - A SPARQL Processor for Jena</title>
<link>https://jena.apache.org/documentation/query/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/</guid>
<description>ARQ is a query engine for Jena that supports the SPARQL RDF Query language. SPARQL is the query language developed by the W3C RDF Data Access Working Group.
ARQ Features Standard SPARQL Free text search via Lucene SPARQL/Update Access and extension of the SPARQL algebra Support for custom filter functions, including javascript functions Property functions for custom processing of semantic relationships Aggregation, GROUP BY and assignment as SPARQL extensions Support for federated query Support for extension to other storage systems Client-support for remote access to any SPARQL endpoint Introduction A Brief Tutorial on SPARQL Application API - covers the majority of application usages Frequently Asked Questions ARQ Support Application javadoc Command line utilities Querying remote SPARQL services HTTP Authentication for ARQ Logging Explaining queries Tutorial: manipulating SPARQL using ARQ Basic federated query (SERVICE) Property paths GROUP BY and counting SELECT expressions Sub-SELECT Negation Features of ARQ that are legal SPARQL syntax</description>
</item>
<item>
<title>ARQ - Aggregates</title>
<link>https://jena.apache.org/documentation/query/group-by.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/group-by.html</guid>
<description>ARQ includes support for GROUP BY and counting. This was previously an ARQ extension but is now legal SPARQL 1.1
GROUP BY A GROUP BY clause transforms a result set so that only one row will appear for each unique set of grouping variables. All other variables from the query pattern are projected away and are not available in the SELECT clause.
PREFIX SELECT ?p ?q { . . . } GROUP BY ?</description>
</item>
<item>
<title>ARQ - Application API</title>
<link>https://jena.apache.org/documentation/query/app_api.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/app_api.html</guid>
<description>The application API is in the package org.apache.jena.query.
Other packages contain various parts of the system (execution engine, parsers, testing etc). Most applications will only need to use the main package. Only applications wishing to programmatically build queries or modify the behaviour of the query engine need to use the others packages directly.
Key Classes The package org.apache.jena.query is the main application package.
Query - a class that represents the application query.</description>
</item>
<item>
<title>ARQ - Assignment</title>
<link>https://jena.apache.org/documentation/query/assignment.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/assignment.html</guid>
<description>ARQ includes support for a logical assignment of variables. If the variable is already bound, it acts like a filter, otherwise the value is assignment. This makes it position independent.
This involves is syntactic extension and is available is the query is parsed with language Syntax.syntaxARQ (which is the default).
See also SELECT expressions which is also a form of assignment.
Assignment The general form is:
LET ( variable := expression ) For example:</description>
</item>
<item>
<title>ARQ - Basic Federated SPARQL Query</title>
<link>https://jena.apache.org/documentation/query/service.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/service.html</guid>
<description>There are already ways to access remote RDF data. The simplest is to read a document which is an RDF graph and query it. Another way is with the SPARQL protocol which allows a query to be sent to a remote service endpoint and the results sent back (in RDF, or an XML-based results format or even a JSON one).
SERVICE is a feature of SPARQL 1.1 that allows an executing query to make a SPARQL protocol to another SPARQL endpoint.</description>
</item>
<item>
<title>ARQ - Building Queries Programmatically</title>
<link>https://jena.apache.org/documentation/query/programmatic.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/programmatic.html</guid>
<description>It is possible to build queries by building and abstract syntax tree (as the parser does) or by building the algebra expression for the query. It is usually better to work with the algebra form as it is more regular.
See the examples such as arq.examples.algrebra.AlgebraExec at jena-examples:arq/examples
See also ARQ - SPARQL Algebra
ARQ documentation index</description>
</item>
<item>
<title>ARQ - Collation</title>
<link>https://jena.apache.org/documentation/query/collation.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/collation.html</guid>
<description>ARQ supports sorting results in a query. Users are able to specify an expression that can be a function (built-in function, custom function, or a variable).
By default, results are sorted using the default behavior provided by the JVM. If you have the following query.
SELECT ?label WHERE { VALUES ?label { &amp;quot;tsahurin kieli&amp;quot;@fi &amp;quot;tšekin kieli&amp;quot;@fi &amp;quot;tulun kieli&amp;quot;@fi &amp;quot;töyhtöhyyppä&amp;quot;@fi } } ORDER BY ?label The results will be returned exactly in the following order.</description>
</item>
<item>
<title>ARQ - Command Line Applications</title>
<link>https://jena.apache.org/documentation/query/cmds.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/cmds.html</guid>
<description>The arq package contains some command line applications to run queries, parse queries, process result sets and run test sets.
You will need to set the classpath, or use the helper scripts, to run these applications from the command line. The helper scripts are in bin/ (Linux, Unix, Cygwin, OS/X) and bat/ (Windows) directories. There are ancillary scripts in the directories that the main commands need - see the tools page for setup details.</description>
</item>
<item>
<title>ARQ - Construct Quad</title>
<link>https://jena.apache.org/documentation/query/construct-quad.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/construct-quad.html</guid>
<description>The current W3C recommendation of SPARQL 1.1 supports the CONSTRUCT query form, which returns a single RDF graph specified by a graph template. The result is an RDF graph formed by taking each query solution in the solution sequence, substituting for the variables in the graph template, and combining the triples into a single RDF graph by set union. However, it does not directly generate quads or RDF datasets.
In order to eliminate this limitation, Jena ARQ extends the grammar of the CONSTRUCT query form and provides the according components, which brings more conveniences for the users manipulating RDF datasets with SPARQL.</description>
</item>
<item>
<title>ARQ - Custom aggregates</title>
<link>https://jena.apache.org/documentation/query/custom_aggregates.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/custom_aggregates.html</guid>
<description>ARQ supports custom aggregate functions as allowed by the SPARQL 1.1 specification.
See jena-examples:arq/examples/aggregates.</description>
</item>
<item>
<title>ARQ - Extending Query Execution</title>
<link>https://jena.apache.org/documentation/query/arq-query-eval.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/arq-query-eval.html</guid>
<description>This page describes the mechanisms that can be used to extend and modify query execution within ARQ. Through these mechanisms, ARQ can be used to query different graph implementations and to provide different query evaluation and optimization strategies for particular circumstances. These mechanisms are used by TDB.
ARQ can be extended in various ways to incorporate custom code into a query. Custom filter functions and property functions provide ways to add application specific code.</description>
</item>
<item>
<title>ARQ - Filter Forms</title>
<link>https://jena.apache.org/documentation/query/function_forms.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/function_forms.html</guid>
<description>This page describes function-like operators that can be used in expressions, such as FILTERs, assignments and SELECT expressions.
These are not strictly functions - the evaluation semantics of custom functions is to evaluate each argument then call the function with the results of the sub-expressions. Examples in standard SPARQL include bound, which does not evaluate a variable as an expression but just tests whether it is set or not, and boolean operators || and &amp;amp;&amp;amp; which handle errors and do not just evaluate each branch and combining the results.</description>
</item>
<item>
<title>ARQ - Frequently Asked Questions</title>
<link>https://jena.apache.org/documentation/query/faq.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/faq.html</guid>
<description>java.lang.NoClassDefFoundError : Exception in thread &amp;ldquo;main&amp;rdquo; : The classpath is wrong. Include all the jar files in lib/ before running one of the command line applications.
java.lang.NoSuchFieldError: actualValueType : This is almost always due to using the wrong version of the Xerces library. Jena and ARQ make use of XML schema support that changed at Xerces 2.6.0 and is not compatible with earlier versions. At the time of writing Jena ships with Xerces 2.</description>
</item>
<item>
<title>ARQ - Generate JSON from SPARQL</title>
<link>https://jena.apache.org/documentation/query/generate-json-from-sparql.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/generate-json-from-sparql.html</guid>
<description>The current W3C recommendation of SPARQL 1.1 supports the query results in JSON format. What is described in this page is not that format, but an extension of Apache Jena, which allows users to define how results should be returned in a key/value pair fashion, providing this way a simpler output. This output can be easily used as model for web applications, or inspecting data.
Compare the output of this extension:</description>
</item>
<item>
<title>ARQ - Internal Design</title>
<link>https://jena.apache.org/documentation/query/architecture.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/architecture.html</guid>
<description>@@ Incomplete / misnamed?
ARQ consists of the following parts:
The SPARQL abstract syntax tree (AST) and the SPARQL parser
The algebra generator that turns SPARQL AST into algebra expressions
Implementation of the translation in the SPARQL specification. Quad version compiling SPARQL to quad expressions, not basic graph patterns. Query engines to execute queries
SPARQL protocol client - remote HTTP requests Reference engine - direct implementation of the algebra Quad engine - direct implementation of the algebra except The main engine TDB, a SPARQL database for large-sale persistent data Result set handling for the SPARQL XML results format, the JSON and text versions.</description>
</item>
<item>
<title>ARQ - JavaScript SPARQL Functions</title>
<link>https://jena.apache.org/documentation/query/javascript-functions.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/javascript-functions.html</guid>
<description>ARQ supports (Jena v3.7.0 onwards) writing custom SPARQL functions in JavaScript. These functions can be used in FILTERs and for calculating values to assign with AS in BIND and SELECT expressions.
XSD datatypes for strings, numbers and booleans are converted to the native JavaScript datatypes. RDFterms that do not fit easily into JavaScript datatypes are handled with a object class NV.
Loading JavaScript functions JavaScript is loaded from an external file using the context setting &amp;ldquo;http://jena.</description>
</item>
<item>
<title>ARQ - Logging</title>
<link>https://jena.apache.org/documentation/query/logging.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/logging.html</guid>
<description>ARQ uses SLF4j as the logging API and the query and RIOT commands use Log4J2 as a deployment system. You can use Java 1.4 logging instead.
ARQ does not output any logging messages at level INFO in normal operation. The code uses level TRACE and DEBUG. Running with logging set to an application at INFO will cause no output in normal operation. Output below INFO can be very verbose and is intended mainly to help debug ARQ.</description>
</item>
<item>
<title>ARQ - Negation</title>
<link>https://jena.apache.org/documentation/query/negation.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/negation.html</guid>
<description>Negation by Failure (OPTIONAL + !BOUND) Standard SPARQL 1.0 can perform negation using the idiom of OPTIONAL/!BOUND. It is inconvenient and can be hard to use as complexity increases. SPARQL 1.1 supports additional operators for negation.
# Names of people who have not stated that they know anyone PREFIX foaf: &amp;lt;http://xmlns.com/foaf/0.1/&amp;gt; SELECT ?name WHERE { ?x foaf:givenName ?name . OPTIONAL { ?x foaf:knows ?who } . FILTER (!BOUND(?who)) } EXISTS and NOT EXISTS The EXISTS and NOT EXISTS are now legal SPARQL 1.</description>
</item>
<item>
<title>ARQ - Querying Remote SPARQL Services</title>
<link>https://jena.apache.org/documentation/query/sparql-remote.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/sparql-remote.html</guid>
<description>SPARQL is a query language and a remote access protocol. The remote access protocol runs over HTTP.
See Fuseki for an implementation of the SPARQL protocol over HTTP. Fuseki uses ARQ to provide SPARQL query access to Jena models, including Jena persistent models.
ARQ includes a query engine capable of using the HTTP version.
From your application The QueryExecutionHTTP has methods for creating a QueryExecution object for remote use. There are various HTTP specific settings; the default should work in most cases.</description>
</item>
<item>
<title>ARQ - RDF Collections</title>
<link>https://jena.apache.org/documentation/query/rdf_lists.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/rdf_lists.html</guid>
<description>RDF collections, also called RDF lists, are difficult to query directly.
ARQ provides a 3 property functions to work with RDF collections.  list:member &amp;ndash; members of a list list:index &amp;ndash; index of a member in a list list:length &amp;ndash; length of a list list:member is similar to rdfs:member except for RDF lists. ARQ also provides rdfs:member.
See the property functions library page.
ARQ documentation index</description>
</item>
<item>
<title>ARQ - SELECT Expressions</title>
<link>https://jena.apache.org/documentation/query/select_expr.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/select_expr.html</guid>
<description>The SELECT statement of a query can include expressions, not just variables. This was previously a SPARQL extension but is now legal SPARQL 1.1
Expressions are enclosed in () and can be optionally named using AS. If no name is given, and internal name is allocated which may not be a legal SPARQL variable name. In order to make results portable in the SPARQL Query Results XML Format, the application must specify the name so using AS is strongly encouraged.</description>
</item>
<item>
<title>ARQ - SPARQL Algebra</title>
<link>https://jena.apache.org/documentation/query/algebra.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/algebra.html</guid>
<description>A SPARQL query in ARQ goes through several stages of processing:
String to Query (parsing) Translation from Query to a SPARQL algebra expression Optimization of the algebra expression Query plan determination and low-level optimization Evaluation of the query plan This page describes how to access and use expressions in the SPARQL algebra within ARQ. The definition of the SPARQL algebra is to be found in the SPARQL specification in section 12.</description>
</item>
<item>
<title>ARQ - SPARQL Update</title>
<link>https://jena.apache.org/documentation/query/update.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/update.html</guid>
<description>SPARQL Update is a W3C standard for an RDF update language with SPARQL syntax. It is described in &amp;ldquo;SPARQL 1.1 Update&amp;quot;.
A SPARQL Update request is composed of a number of update operations, so in a single request graphs can be created, loaded with RDF data and modified.
Some examples of ARQ&amp;rsquo;s SPARQL Update support are to be found in the download in jena-examples:arq/examples/update.
The main API classes are:
UpdateRequest - A list of Update to be performed.</description>
</item>
<item>
<title>ARQ - Sub Queries</title>
<link>https://jena.apache.org/documentation/query/sub-select.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/sub-select.html</guid>
<description>ARQ includes support for nested SELECTs. This was previously an ARQ extension but is now legal SPARQL 1.1
Nested SELECT A SELECT query can be placed inside a graph pattern to produce a table that is used within the outer query. A nested SELECT statement is enclosed in {} and is the only element in that group.
Example: find toys with more than five orders:
PREFIX : &amp;lt;http://example/&amp;gt; SELECT ?x { ?</description>
</item>
<item>
<title>ARQ - The `java:` URI scheme</title>
<link>https://jena.apache.org/documentation/query/java-uri.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/java-uri.html</guid>
<description>ARQ uses URIs of the form &amp;lt;java:&amp;lt;i&amp;gt;package.class&amp;lt;/i&amp;gt;&amp;gt; to provide dynamic loading of code for value functions and property functions. ARQ loads the class when needed. For functions and property functions, it also wraps it in the necessary factory code. A new instance of the function or property function is created for each mention of the name in each query.
Dynamic Code Loading Any classes loaded by ARQ must already be on the java classpath.</description>
</item>
<item>
<title>ARQ - Writing Filter Functions</title>
<link>https://jena.apache.org/documentation/query/writing_functions.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/writing_functions.html</guid>
<description>Applications can add SPARQL functions to the query engine. This is done by writing a class implementing the right interface, then either registering it or using the fake java: URI scheme to dynamically call the function.
Writing SPARQL Value Functions A SPARQL value function is an extension point of the SPARQL query language that allows URI to name a function in the query processor.
In the ARQ engine, code to implement function must implement the interface org.</description>
</item>
<item>
<title>ARQ - Writing Property Functions</title>
<link>https://jena.apache.org/documentation/query/writing_propfuncs.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/writing_propfuncs.html</guid>
<description>ARQ - Writing Property Functions
See also Writing Filter Functions.
Applications can add SPARQL property functions to the query engine. This is done by first implementing the PropertyFunction interface, and then either registering that function or using the fake java: URI scheme to dynamically load the function.
Writing SPARQL Property Functions
Similar to SPARQL Filter Functions, a SPARQL Property Function is an extension point of the SPARQL query language that allows a URI to name a function in the query processor.</description>
</item>
<item>
<title>ARQ Downloads</title>
<link>https://jena.apache.org/documentation/query/download.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/download.html</guid>
<description>For details on downloading ARQ, please see the Jena downloads page.
ARQ documentation index</description>
</item>
<item>
<title>ARQ Property Paths</title>
<link>https://jena.apache.org/documentation/query/property_paths.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/property_paths.html</guid>
<description>ARQ - Property Paths A property path is a possible route through a graph between two graph nodes. A trivial case is a property path of length exactly one, which is a triple pattern.
Most property paths are now legal SPARQL 1.1 syntax, there are some advanced property paths which are syntactic extensions and are only available if the query is parsed with language Syntax.syntaxARQ.
Path Language A property path expression (or just &amp;lsquo;path&amp;rsquo;) is similar to a string regular expression but over properties, not characters.</description>
</item>
<item>
<title>ARQ – Support</title>
<link>https://jena.apache.org/documentation/query/support.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/support.html</guid>
<description>Read the following first:
Frequently Asked Questions Submitting a support request or bug reports The documentation Support for ARQ is provided via the Jena mailing list &amp;lt;mailto:users@jena.apache.org&amp;gt;.
ARQ documentation index</description>
</item>
<item>
<title>Combining Apache Jena jars</title>
<link>https://jena.apache.org/documentation/notes/jena-repack.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/jena-repack.html</guid>
<description>Apache Jena initializes uses Java&amp;rsquo;s ServiceLoader mechanism to locate initialization steps. The documentation for process in Jena is available here.
There are a number of files (Java resources) in Jena jars named:
META-INF/services/org.apache.jena.sys.JenaSubsystemLifecycle Each has different contents, usually one or two lines.
When making a combined jar (&amp;ldquo;uber-jar&amp;rdquo;, jar with dependencies) from Jena dependencies and application code, the contents of the Jena files must be combined and be present in the combined jar as a java resource of the same name.</description>
</item>
<item>
<title>Command-line and other tools for Jena developers</title>
<link>https://jena.apache.org/documentation/tools/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tools/</guid>
<description>Jena includes various command-line utilities which can help you with a variety of tasks in developing Jena-based applications.
Index of tools schemagen using schemagen from maven Setting up your Environment An environment variable JENA_HOME is used by all the command line tools to configure the class path automatically for you. You can set this up as follows:
On Linux / Mac
export JENA_HOME=the directory you downloaded Jena to export PATH=$PATH:$JENA_HOME/bin On Windows</description>
</item>
<item>
<title>Concurrent access to Models</title>
<link>https://jena.apache.org/documentation/notes/concurrency-howto.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/concurrency-howto.html</guid>
<description>All datasets provide transactions. This is the preferred way to handle concurrenct access to data. Applications need to be aware of the concurrency issues in access Jena models. API operations are not thread safe by default. Thread safety would simple ensure that the model data-structures remained intact but would not give an application consistent access to the RDF graph. It would also limit the throughput of multi-threaded applications on multiprocessor machines where true concurrency can lead to a reduction in response time.</description>
</item>
<item>
<title>Creating a Custom Jena JDBC Driver</title>
<link>https://jena.apache.org/documentation/jdbc/custom_driver.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/jdbc/custom_driver.html</guid>
<description>As noted in the overview Jena JDBC drivers are built around a core library which implements much of the common functionality required in an abstract way. This means that it is relatively easy to build a custom driver just by relying on the core library and implementing a minimum of one class.
Custom Driver class The one and only thing that you are required to do to create a custom driver is to implement a class that extends JenaDriver.</description>
</item>
<item>
<title>Creating Jena models</title>
<link>https://jena.apache.org/documentation/notes/model-factory.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/model-factory.html</guid>
<description>Introduction Jena is a moderately complicated system, with several different kinds of Model and ways of constructing them. This note describes the Jena ModelFactory, a one-stop shop for creating Jena models. ModelFactory lives in Java package org.apache.jena.rdf.model.
This note is an introduction, not an exhaustive description. As usual consult the Javadoc for details of the methods and classes to use.
Simple model creation The simplest way to create a model (if not the shortest) is to call ModelFactory.</description>
</item>
<item>
<title>CSV PropertyTable</title>
<link>https://jena.apache.org/documentation/archive/csv/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/csv/</guid>
<description> This page covers the jena-csv module which has been retired. The last release of Jena with this module is Jena 3.9.0. See jena-csv/README.md. The original documentation.
</description>
</item>
<item>
<title>CSV PropertyTable</title>
<link>https://jena.apache.org/documentation/archive/csv/csv_index.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/csv/csv_index.html</guid>
<description>This page covers the jena-csv module which has been retired. The last release of Jena with this module is Jena 3.9.0. See jena-csv/README.md. This is the original documentation.
This module is about getting CSVs into a form that is amenable to Jena SPARQL processing, and doing so in a way that is not specific to CSV files. It includes getting the right architecture in place for regular table shaped data, using the core abstraction of PropertyTable.</description>
</item>
<item>
<title>CSV PropertyTable - Design</title>
<link>https://jena.apache.org/documentation/archive/csv/design.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/csv/design.html</guid>
<description>Architecture The architecture of CSV PropertyTable mainly involves 2 components:
PropertyTable GraphPropertyTable PropertyTable A PropertyTable is collection of data that is sufficiently regular in shape it can be treated as a table. That means each subject has a value for each one of the set of properties. Irregularity in terms of missing values needs to be handled but not multiple values for the same property. With special storage, a PropertyTable</description>
</item>
<item>
<title>CSV PropertyTable - Get Started</title>
<link>https://jena.apache.org/documentation/archive/csv/get_started.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/csv/get_started.html</guid>
<description>Using CSV PropertyTable with Apache Maven See &amp;ldquo;Using Jena with Apache Maven&amp;rdquo; for full details.
&amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.apache.jena&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;jena-csv&amp;lt;/artifactId&amp;gt; &amp;lt;version&amp;gt;X.Y.Z&amp;lt;/version&amp;gt; &amp;lt;/dependency&amp;gt; Using CSV PropertyTable from Java through the API In order to switch on CSV PropertyTable, it&amp;rsquo;s required to register LangCSV into Jena RIOT, through a simple method call:
import org.apache.jena.propertytable.lang.CSV2RDF; ... CSV2RDF.init() ; It&amp;rsquo;s a static method call of registration, which needs to be run just one time for an application before using CSV PropertyTable (e.</description>
</item>
<item>
<title>CSV PropertyTable - Implementation</title>
<link>https://jena.apache.org/documentation/archive/csv/implementation.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/csv/implementation.html</guid>
<description>PropertyTable Implementations There are 2 implementations for PropertyTable. The pros and cons are summarised in the following table:
PropertyTable Implementation Description Supported Indexes Advantages Disadvantages PropertyTableArrayImpl implemented by a two-dimensioned Java array of Nodes SPO, PSO compact memory usage, fast for querying with S and P, fast for query a whole Row slow for query with O, table Row/Column size provided PropertyTableHashMapImpl implemented by several Java HashMaps PSO, POS fast for querying with O, table Row/Column size not required more memory usage for HashMaps By default, [PropertyTableArrayImpl]((https://github.</description>
</item>
<item>
<title>Data Access Control for Fuseki</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-data-access-control.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-data-access-control.html</guid>
<description>Fuseki can provide access control at the level on the server, on datasets, on endpoints and also on specific graphs within a dataset. It also provides native https to protect data in-flight.
Fuseki Main provides some common patterns of authentication and also Graph level Data Access Control to provide control over the visibility of graphs within a dataset, including the union graph of a dataset and the default graph. Currently, Graph level access control only applies to read-only datasets.</description>
</item>
<item>
<title>Data with RDFS Inferencing</title>
<link>https://jena.apache.org/documentation/rdfs/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/rdfs/</guid>
<description>This page describes support for accessing data with additional statements derived using RDFS. It supports rdfs:subClassOf, rdfs:subPropertyOf, rdfs:domain and rdfs:range. It does not provide RDF axioms. The RDFS vocabulary is not included in the data.
It does support use with RDF datasets, where each graph in the dataset has the same RDFS vocabulary applied to it.
This is not a replacement for the Jena RDFS Reasoner support which covers full RDFS inference.</description>
</item>
<item>
<title>Event handling in Jena</title>
<link>https://jena.apache.org/documentation/notes/event-handler-howto.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/event-handler-howto.html</guid>
<description>ModelChangedListener In Jena it is possible to monitor a Model for changes, so that code can be run after changes are applied without the coding for that Model having to do anything special. We call these changes &amp;ldquo;events&amp;rdquo;. This first design and implementation is open for user comment and we may refine or reduce the implementation as more experience is gained with it.
To monitor a Model, you must register a ModelChangedListener with that Model:</description>
</item>
<item>
<title>Explaining ARQ queries</title>
<link>https://jena.apache.org/documentation/query/explain.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/explain.html</guid>
<description>Optimization in ARQ proceeds on two levels. After the query is parsed, the SPARQL algebra for the query is generated as described in the SPARQL specification. High-level optimization occurs by rewriting the algebra into new, equivalent algebra forms and introducing specialized algebra operators. During query execution, the low-level, storage-specific optimization occurs such as choosing the order of triple patterns within basic graph patterns.
The effect of high-level optimizations can be seen using arq.</description>
</item>
<item>
<title>Extensions in ARQ</title>
<link>https://jena.apache.org/documentation/query/extension.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/extension.html</guid>
<description>There are several ways to extend the ARQ query engine within the SPARQL syntax.
Expression Functions - additional operations in FILTERS, BIND and SELECT expressions. Property functions - adding predicates that introduce custom query stages DESCRIBE handlers Support for finding blank nodes by label Extending query evaluation for querying different storage and inference systems Functions are standard part of SPARQL. ARQ provides application-written functions and provides a function library.</description>
</item>
<item>
<title>Eyeball - checking RDF/OWL for common problems</title>
<link>https://jena.apache.org/documentation/archive/eyeball/eyeball-getting-started.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/eyeball/eyeball-getting-started.html</guid>
<description>Eyeball is a Jena-based tool for checking RDF models (including OWL) for common problems. It is user-extensible using plugins.
This page is historical &amp;ldquo;for information only&amp;rdquo; - there is no Apache release of Eyeball and the code has not been updated for Jena3.
The original source code is available.
Documentation index The brief guide. The manual. The JavaDoc. Getting the Eyeball release Installation Eyeball needs to be compiled from source.</description>
</item>
<item>
<title>Functions in ARQ</title>
<link>https://jena.apache.org/documentation/query/library-function.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/library-function.html</guid>
<description>The regular expressions for fan:localname and afn:namespace were incorrect. SPARQL allows custom functions in expressions so that queries can be used on domain-specific data. SPARQL defines a function by URI (or prefixed name) in FILTER expressions. ARQ provides a function library and supports application-provided functions. Functions and property functions can be registered or dynamically loaded.
Applications can also provide their own functions.
ARQ also provides an implementation the Leviathan Function Library.</description>
</item>
<item>
<title>Fuseki : Docker Tools</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-docker.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-docker.html</guid>
<description>The jena-fuseki-docker package contains a Dockerfile, docker-compose file, and helper scripts to create a docker container for Apache Jena Fuseki.
The docker container is based on Fuseki main for running a SPARQL server.
There is no UI - all configuration is by command line and all usage by via the network protocols.
Databases can be mounted outside the docker container so they are preserved when the container terminates.
This build system allows the user to customize the docker image.</description>
</item>
<item>
<title>Fuseki : Embedded Server</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-embedded.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-embedded.html</guid>
<description>Fuseki can be run within a larger JVM application as an embedded triplestore.
Dependencies and Setup Logging Building a Server Examples The application can safely access and modify the data published by the server if it does so inside a transaction using an appropriate storage choice. DatasetFactory.createTxnMem() is a good choice for in-memory use; TDB is a good choice for a persistent database.
To build and start the server:</description>
</item>
<item>
<title>Fuseki : Main Server</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-main.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-main.html</guid>
<description>Fuseki main is a packaging of Fuseki as a triple store without a UI for administration.
Fuseki can be run in the background by an application as an embedded server. The application can safely work with the dataset directly from java while having Fuseki provide SPARQL access over HTTP. An embedded server is useful for adding functionality around a triple store and also for development and testing.
Running as a deployment or development server Running from Docker Running as an embedded server Dependencies and Setup Logging Building a Server Examples The main server does not depend on any files on disk (other than for databases provided by the application), and does not provide the Fuseki UI or admins functions to create dataset via HTTP.</description>
</item>
<item>
<title>Fuseki Data Service Configuration Syntax</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-config-endpoint.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-config-endpoint.html</guid>
<description>A data service provides a number of operations on a dataset. These can be explicitly named endpoints or operations at the URL of the dataset. New operations can be configured in; these typically have their own named endpoints.
Syntax Here is an example of a server configuration that provides one operation, SPARQL query, and then only on the dataset URL.
PREFIX : &amp;lt;#&amp;gt; PREFIX fuseki: &amp;lt;http://jena.apache.org/fuseki#&amp;gt; PREFIX rdf: &amp;lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#&amp;gt; [] rdf:type fuseki:Server .</description>
</item>
<item>
<title>Fuseki Data Service Configuration Syntax - Old Style</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-old-config-endpoint.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-old-config-endpoint.html</guid>
<description>This page describes the original Fuseki2 server configuration syntax.
Example:
## Updatable dataset. &amp;lt;#service1&amp;gt; rdf:type fuseki:Service ; fuseki:name &amp;quot;ds&amp;quot; ; # http://host:port/ds fuseki:serviceQuery &amp;quot;sparql&amp;quot; ; # SPARQL query service fuseki:serviceQuery &amp;quot;query&amp;quot; ; # SPARQL query service (alt name) fuseki:serviceUpdate &amp;quot;update&amp;quot; ; # SPARQL update service fuseki:serviceReadWriteGraphStore &amp;quot;data&amp;quot; ; # SPARQL Graph Store Protocol (read and write) fuseki:serviceReadGraphStore &amp;quot;get&amp;quot; ; # SPARQL Graph Store Protocol (read only) fuseki:dataset &amp;lt;#dataset&amp;gt; ; . &amp;lt;#dataset&amp;gt; refers to a dataset description in the same file.</description>
</item>
<item>
<title>Fuseki File System Layout</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-layout.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-layout.html</guid>
<description>There are two areas: the fixed files provided by the distribution and the changing files for the local deployment,including the default location for TDB databases.
Two environment variables control the file system usage. Symbolic links can be used to create variations on the standard layout.
FUSEKI_HOME - this contains the fixed files from the distribution and is used for Unix service deployments. When deployment as a WAR file, everything is in the WAR file itself.</description>
</item>
<item>
<title>Fuseki HTTP Administration Protocol</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-server-protocol.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-server-protocol.html</guid>
<description>This page describes the HTTP Protocol used to control an Fuseki server via its administrative interface.
Operations Server Information Datasets and Services Adding a Dataset and its Services Removing a Dataset Dormant and Active Removing a dataset All admin operations have URL paths starting /$/ to avoid clashes with dataset names and this prefix is reserved for the Fuseki control functions. Further operations may be added within this naming scheme.</description>
</item>
<item>
<title>Fuseki Logging</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-logging.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-logging.html</guid>
<description>Fuseki logs operation details and also provides a standard NCSA request log.
Logging is via SLF4J over Apache Log4J2, or by the Tomcat configuration if running the WAR file.
Full Log name Usage org.apache.jena.fuseki.Server General Server Messages org.apache.jena.fuseki.Request NCSA request Log. org.apache.jena.fuseki.Fuseki The HTTP request log org.apache.jena.fuseki.Admin Administration operations org.apache.jena.fuseki.Builder Dataset and service build operations org.</description>
</item>
<item>
<title>Fuseki Modules</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-modules.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-modules.html</guid>
<description>Fuseki modules are a mechanism to include extension code into a Fuseki server. Modules are invoked during the process of building a Fuseki Main server. The module can modify the server configuration, add new functionality, or react to a server being built and started.
This feature was added in Jena version 4.3.0. They are an expeirmental feature that will evolve based on experineace and use cases.
Fuseki Modules are loaded use the JDK ServiceLoader by being placing a jar file on the classpath, together with any additional dependencies.</description>
</item>
<item>
<title>Fuseki Quickstart</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-quick-start.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-quick-start.html</guid>
<description>This page describes how to achieve certain common tasks in the most direct way possible.
Running with Apache Tomcat and loading a file. Unpack the distribution. Copy the WAR file into the Apache tomcat webapp directory, under the name &amp;lsquo;fuseki&amp;rsquo; If the user under which Apache tomcat is running does not have write access to /etc, then please make sure to set the environment variable FUSEKI_BASE, whereas the value should be a directory where the user running Apache tomcat is able to write to.</description>
</item>
<item>
<title>Fuseki: Configuring Fuseki</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-configuration.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-configuration.html</guid>
<description>A Fuseki server is configured by defining the data services (data and actions available on the data). There is also server configuration although this is often unnecessary.
The data services configuration can come from:
For Fuseki Full (webapp with UI):
The directory FUSEKI_BASE/configuration/ with one data service assembler per file (includes endpoint details and the dataset description.) The system database. This includes uploaded assembler files. It also keeps the state of each data service (whether it&amp;rsquo;s active or offline).</description>
</item>
<item>
<title>Fuseki: Server Information</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-server-info.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-server-info.html</guid>
<description>A Fuseki server keeps detailed statistics for each dataset and each service of a dataset keeps counters as to the number of incoming requests, number of successful requests, number of bad requests (i.e client errors), and number of failing requests (i.e. server errors).
Statistics are available in JSON and in Prometheus format. The Prometheus data includes both database and JVM metrics.
Endpoints The following servers endpoints are available. They are present in Fuseki/UI; they need to be enabled with Fuseki/main, either on the command line or in the server configuration file with a boolean setting.</description>
</item>
<item>
<title>Fuseki: serving RDF data over HTTP</title>
<link>https://jena.apache.org/documentation/archive/serving_data/fuseki1.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/serving_data/fuseki1.html</guid>
<description>See the Fuseki2 documentation. This page covers Fuseki v1. Fuseki1 is deprecated and has been retired. The last release of Jena with this module is Jena 3.9.0.
Fuseki is a SPARQL server. It provides REST-style SPARQL HTTP Update, SPARQL Query, and SPARQL Update using the SPARQL protocol over HTTP.
The relevant SPARQL standards are:
SPARQL 1.1 Query SPARQL 1.1 Update SPARQL 1.1 Protocol SPARQL 1.1 Graph Store HTTP Protocol Contents Download Getting Started Security Logging Server URI scheme Running a Fuseki Server Fuseki Configuration File SPARQL Over HTTP Use from Java Development System Download Fuseki1 Binaries for Fuseki1 are available from the maven repositories.</description>
</item>
<item>
<title>Fuseki: SPARQL and RDF Standards</title>
<link>https://jena.apache.org/documentation/fuseki2/rdf-sparql-standards.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/rdf-sparql-standards.html</guid>
<description>SPARQL Standards The relevant SPARQL 1.1 standards are:
SPARQL 1.1 Query SPARQL 1.1 Update SPARQL 1.1 Protocol SPARQL 1.1 Graph Store HTTP Protocol SPARQL 1.1 Query Results JSON Format SPARQL 1.1 Query Results CSV and TSV Formats SPARQL Query Results XML Format RDF Standards Some RDF 1.1 standards
RDF 1.1 Turtle RDF 1.1 Trig RDF 1.1 N-Triples RDF 1.1 N-Quads JSON-LD </description>
</item>
<item>
<title>General notes and how-to&#39;s</title>
<link>https://jena.apache.org/documentation/notes/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/</guid>
<description> Dataset Transactions Concurrency how-to Handling concurrent access to Jena models Event handler how-to Responding to events Stream manager how-to Redirecting URLs to local files Model factory Creating Jena models of various kinds RDF frames Viewing RDF statements as frame-like objects Reification API support for RDF reification Typed literals Creating and extracting RDF typed literals SSE SPARQL Syntax Expressions Repacking Jena jars Jena Initialization </description>
</item>
<item>
<title>GeoSPARQL Assembler</title>
<link>https://jena.apache.org/documentation/geosparql/geosparql-assembler.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/geosparql/geosparql-assembler.html</guid>
<description>Details of the GeoSPARQL support are proivded on the GeoSPARQL page.
The assembler for GeoSPARQL support is part of the jena-geosparql artifact and must be on the Fuseki server classpath, along with its dependencies.
&amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.apache.jena&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;jena-geosparql&amp;lt;/artifactId&amp;gt; &amp;lt;version&amp;gt;...&amp;lt;/version&amp;gt; &amp;lt;/dependency&amp;gt; or download the binary from the Maven central repository org/apache/jena/jena-geosparql
The GeoSPARQL assembler can be used in a Fuseki configuration file.
This example is of a read-only:
PREFIX fuseki: &amp;lt;http://jena.apache.org/fuseki#&amp;gt; PREFIX rdf: &amp;lt;http://www.</description>
</item>
<item>
<title>GeoSPARQL Fuseki</title>
<link>https://jena.apache.org/documentation/geosparql/geosparql-fuseki.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/geosparql/geosparql-fuseki.html</guid>
<description>This application provides a HTTP server compliant with the GeoSPARQL standard.
GeoSPARQL can also be integrated with Fuseki using the GeoSPARQL assembler with a general Fuseki server.
jena-fuseki-geosparql GeoSPARQL Fuseki can be accessed as an embedded server using Maven etc. from Maven Central or run from the command line. SPARQL queries directly on Jena Datasets and Models can be done using the GeoSPARQL Jena module.
&amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.apache.jena&amp;lt;/groupId&amp;gt; &amp;lt;artifactId&amp;gt;jena-fuseki-geosparql&amp;lt;/artifactId&amp;gt; &amp;lt;version&amp;gt;...&amp;lt;/version&amp;gt; &amp;lt;/dependency&amp;gt; or download the binary from the Maven central repository org/apache/jena/jena-fuseki-geosparql</description>
</item>
<item>
<title>HTTP Authentication</title>
<link>https://jena.apache.org/documentation/sparql-apis/http-auth.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/sparql-apis/http-auth.html</guid>
<description>Old documentation (Jena 3.1.1 to Jena 4.2.0)
Jena 4.3.0 and later uses the JDK java.net.http package. Jena adds API support for challenge-based authentication and also provide HTTP digest authentication.
Authentication There are 5 variations:
Basic authentication Challenge-Basic authentication Challenge-Digest authentication URL user (that is, user@host.net in the URL) URL user and password in the URL (that is, user:password@host.net in the URL) Basic authentication occurs where the app provides the user and password information to the JDK HttpClient and that information is always used when sending HTTP requests with that HttpClient.</description>
</item>
<item>
<title>HTTP Authentication in ARQ (Superseded)</title>
<link>https://jena.apache.org/documentation/archive/versions/http-auth-old.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/versions/http-auth-old.html</guid>
<description>Documentation for HTTP Authentication (Jena3.1.1 to Jena 4.2.0) using Apache Commons HttpClient.
After Jena 3.1.0, Jena exposes the underlying HTTP Commons functionality to support a range of authentication mechanisms as well as other HTTP configuration. From Jena 3.0.0 through Jena 3.1.0 there is a Jena-specific framework that provides a uniform mechanism for HTTP authentication. This documentation is therefore divided into two sections. The first explains how to use HTTP Commons code, and the second explains the older Jena-specific functionality.</description>
</item>
<item>
<title>In-memory, transactional Dataset</title>
<link>https://jena.apache.org/documentation/rdf/datasets.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/rdf/datasets.html</guid>
<description>The in-memory, transactional dataset provides a dataset with full ACID transaction semantics, including abort. It provides for multiple readers and a concurrent writer together with full snapshot isolation of the dataset. Readers see an unchanging, consistent dataset where aggregate operations return stable results.
First introduced in Jena version 3.0.1 as a beta, then in 3.1.0.
During the beta phase, please log any issues with Apache Jena JIRA.
API use A new instance of the class is obtained by a call to DatasetFactory.</description>
</item>
<item>
<title>Inside assemblers</title>
<link>https://jena.apache.org/documentation/assembler/inside-assemblers.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/assembler/inside-assemblers.html</guid>
<description>This document describes Jena&amp;rsquo;s built-in assembler classes and how to write and integrate your own assemblers. If you just need a quick guide to the common model specifications, see the assembler quickstart; if you want more details on writing assembler descriptions, see the assembler howto.
The Assembler interface An Assembler is an object that builds objects (most importantly, Models) from RDF descriptions.
public Object open( Assembler a, Resource root, Mode mode ); public Object open( Assembler a, Resource root ); public Object open( Resource root ); public Model openModel( Resource root ); public Model openModel( Resource root, Mode mode ); The fundamental method is the first: all the others are shorthands for ways of calling it.</description>
</item>
<item>
<title>Jena Assembler howto</title>
<link>https://jena.apache.org/documentation/assembler/assembler-howto.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/assembler/assembler-howto.html</guid>
<description>Introduction This document describes the vocabulary and effect of the built-in Jena assembler descriptions for constructing models (and other things). A companion document describes the built-in assembler classes and how to write and integrate your own assemblers. If you just need a quick guide to the common model specifications, see the assembler quickstart.
This document describes how to use the Assembler classes to construct models &amp;ndash; and other things &amp;ndash; from RDF descriptions that use the Jena Assembler vocabulary.</description>
</item>
<item>
<title>Jena assembler quickstart</title>
<link>https://jena.apache.org/documentation/assembler/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/assembler/</guid>
<description>Jena&amp;rsquo;s assembler provides a means of constructing Jena models according to a recipe, where that recipe is itself stated in RDF. This is the Assembler quickstart page. For more detailed information, see the Assembler howto or Inside assemblers.
What is an Assembler specification? An Assembler specification is an RDF description of how to construct a model and its associated resources, such as reasoners, prefix mappings, and initial content. The Assembler vocabulary is given in the Assembler schema, and we&amp;rsquo;ll use the prefix ja for its identifiers.</description>
</item>
<item>
<title>Jena Extras - Extra packages for Jena development.</title>
<link>https://jena.apache.org/documentation/extras/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/extras/</guid>
<description>Jena Extra modules are modules that provide utilities and larger packages that make Apache Jena development or usage easier but that do not fall within the standard Jena framework.
Sub Packages Query Builder </description>
</item>
<item>
<title>Jena Eyeball manual</title>
<link>https://jena.apache.org/documentation/archive/eyeball/eyeball-manual.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/eyeball/eyeball-manual.html</guid>
<description>This page is historical &amp;ldquo;for information only&amp;rdquo; - there is no Apache release of Eyeball and the code has not been updated for Jena3.
The original source code is available.
This document describes Eyeball, an &amp;ldquo;RDF lint&amp;quot;. See the release notes for descriptions of changes from previous versions. Eyeball was a part of the Jena family of RDF/OWL tools.
Throughout this document, the prefix eye: stands for the URL http://jena.</description>
</item>
<item>
<title>Jena Full Text Search</title>
<link>https://jena.apache.org/documentation/query/text-query.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/text-query.html</guid>
<description>This extension to ARQ combines SPARQL and full text search via Lucene. It gives applications the ability to perform indexed full text searches within SPARQL queries. Here is a version compatibility table:
 Jena   Lucene   Solr   ElasticSearch  upto 3.2.0 5.x or 6.x 5.x or 6.x not supported 3.3.0 - 3.9.0 6.4.x not supported 5.2.2 - 5.</description>
</item>
<item>
<title>Jena JavaDoc</title>
<link>https://jena.apache.org/documentation/javadoc.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/javadoc.html</guid>
<description> Jena Core JavaDoc ARQ JavaDoc (SPARQL) TDB JavaDoc RDF Connection Fuseki JavaDoc Fuseki2 Webapp Fuseki2 Main Text search SHACL ShEx GeoSPARQL Security Permissions JavaDoc JDBC JavaDoc </description>
</item>
<item>
<title>Jena JDBC - A SPARQL over JDBC driver framework</title>
<link>https://jena.apache.org/documentation/jdbc/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/jdbc/</guid>
<description>Jena JDBC is a set of libraries which provide SPARQL over JDBC driver implementations.
This is a pure SPARQL over JDBC implementation, there is no attempt to present the underlying RDF data model as a relational model through the driver and only SPARQL queries and updates are supported.
It provides type 4 drivers in that they are pure Java based but the drivers are not JDBC compliant since by definition they do not support SQL.</description>
</item>
<item>
<title>Jena JDBC Drivers</title>
<link>https://jena.apache.org/documentation/jdbc/drivers.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/jdbc/drivers.html</guid>
<description>Jena JDBC comes with three built in drivers by default with the option of building custom drivers if desired. This page covers the differences between the provided drivers and the connection URL options for each.
Connection URL Basics Connection URLs for Jena JDBC drivers have a common format, they all start with the following:
jdbc:jena:foo: Where foo is a driver specific prefix that indicates which specific driver implementation is being used.</description>
</item>
<item>
<title>Jena Ontology API</title>
<link>https://jena.apache.org/documentation/ontology/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/ontology/</guid>
<description>This section is a general introduction to the Jena ontology API, including some of the common tasks you may need to perform. We won&amp;rsquo;t go into all of the many details of the API here: you should expect to refer to the Javadoc to get full details of the capabilities of the API.
Prerequisites We&amp;rsquo;ll assume that you have a basic familiarity with RDF and with Jena. If not, there are other Jena help documents you can read for background on these topics, and a collection of tutorials.</description>
</item>
<item>
<title>Jena Permissions - A Permissions wrapper around the Jena RDF implementation</title>
<link>https://jena.apache.org/documentation/permissions/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/permissions/</guid>
<description>Jena Permissions is a SecurityEvaluator interface and a set of dynamic proxies that apply that interface to Jena Graphs, Models, and associated methods and classes. It does not implement any specific security policy but provides a framework for developers or integrators to implement any desired policy.
Documentation Overview Usage Notes Design Security Evaluator implementation Assembler for a Secured Model Adding Jena Permissions to Fuseki Overview Jena Permissions transparently intercepts calls to the Graph or Model interface, evaluates access restrictions and either allows or rejects the access.</description>
</item>
<item>
<title>Jena Permissions - Assembler for a Secured Model</title>
<link>https://jena.apache.org/documentation/permissions/assembler.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/permissions/assembler.html</guid>
<description>Jena Permissions provides a standard Jena assembler making it easy to use the SecuredModel in an Assembler based environment. To use the permissions assembler the assembler file must contain the lines:
[] ja:loadClass &amp;quot;org.apache.jena.permissions.SecuredAssembler&amp;quot; . sec:Model rdfs:subClassOf ja:NamedModel . The secured assembler provides XXXXXXXXXXXx properties for the assembler files.
Assuming we define:
@prefix sec: &amp;lt;http://apache.org/jena/permissions/Assembler#&amp;gt; . Then the following resources are defined:
sec:Model - A secured model.</description>
</item>
<item>
<title>Jena Permissions - Design</title>
<link>https://jena.apache.org/documentation/permissions/design.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/permissions/design.html</guid>
<description>Jena Permissions is designed to allow integrators to implement almost any security policy. Fundamentally it works by implementing dynamic proxies on top of the Jena Graph and Model interfaces as well as objects returned by those interfaces. The proxy verifies that the actions on those objects are permitted by the policy before allowing the actions to proceed.
The graph or model is created by the org.apache.jena.permissions.Factory object by wrapping a Graph or Model implementation and associating it with a URI (graphIRI) and a SecurityEvaluator implementation.</description>
</item>
<item>
<title>Jena Permissions - Migration notes: Version 2.x to Version 3.x</title>
<link>https://jena.apache.org/documentation/permissions/migration2To3.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/permissions/migration2To3.html</guid>
<description>When Jena moved from version 2 to version 3 there was a major renaming of packages. One of the packages renamed was the Jena Permissions package. It was formerly named Jena Security. There are several changes that need to occur to migrate from jena-security version 2.x to jena-permissions version 3.x.
Changes Package Rename There are two major changes to package names.
As with the rest of the Jena code all references to com.</description>
</item>
<item>
<title>Jena Permissions - SecurityEvaluator implementation</title>
<link>https://jena.apache.org/documentation/permissions/evaluator.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/permissions/evaluator.html</guid>
<description>Overview The SecurityEvaluator interface defines the access control operations. It provides the interface between the authentication (answers the question: &amp;ldquo;who are you?&amp;quot;) and the authorization (answers the question: &amp;ldquo;what can you do?&amp;quot;), as such it provides access to the current principal (user). The javadocs contain detailed requirements for implementations of the SecurityEvaluator interface, short notes are provided below.
NOTE The permissions system caches intermediate results and will only call the evaluator if the answer is not already in the cache.</description>
</item>
<item>
<title>Jena Query Builder - A query builder for Jena.</title>
<link>https://jena.apache.org/documentation/extras/querybuilder/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/extras/querybuilder/</guid>
<description>Table of Contents {% toc %}
Overview Query Builder provides implementations of Ask, Construct, Select and Update builders that allow developers to create queries without resorting to StringBuilders or similar solutions. The Query Builder module is an extra package and is found in the jena-querybuilder jar.
Each of the builders has a series of methods to define the query. Each method returns the builder for easy chaining. The example:
SelectBuilder sb = new SelectBuilder() .</description>
</item>
<item>
<title>Jena RDF/XML How-To</title>
<link>https://jena.apache.org/documentation/io/rdfxml_howto.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/rdfxml_howto.html</guid>
<description>This is a guide to the RDF/XML I/O subsystem of Jena, ARP. The first section gives a quick introduction to the I/O subsystem. The other sections are aimed at users wishing to use advanced features within the RDF/XML I/O subsystem.
Contents Quick Introduction RDF/XML, RDF/XML-ABBREV Character Encoding Issues Encodings Supported in Jena 2.2 and later When to Use Reader and Writer? Introduction to Advanced Jena I/O Advanced RDF/XML Input ARP properties Interrupting ARP Advanced RDF/XML Output Conformance Faster RDF/XML I/O Details of ARP, the Jena RDF/XML parser Quick Introduction The main I/O methods in Jena use InputStreams and OutputStreams.</description>
</item>
<item>
<title>Jena schemagen HOWTO</title>
<link>https://jena.apache.org/documentation/tools/schemagen.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tools/schemagen.html</guid>
<description>The schemagen provided with Jena is used to convert an OWL or RDFS vocabulary into a Java class file that contains static constants for the terms in the vocabulary. This documents outlines the use of schemagen, and the various options and templates that may be used to control the output.
Schemagen is typically invoked from the command line or from a built script (such as Ant). Synopsis of the command:</description>
</item>
<item>
<title>Jena Transactions</title>
<link>https://jena.apache.org/documentation/txn/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/txn/</guid>
<description>This page gives an overview of transactions in Jena.
There are two API for transactions: the basic transaction interface styled after the conventional begin-commit and a higher level Txn API that builds on the basic API using Java8 features.
APIs Basic API for Transactions Txn, a high level API to transactions Overview Transaction provide applications with a safe way to use and update data between threads. The properties of transactions are ACID</description>
</item>
<item>
<title>Jena Transactions API</title>
<link>https://jena.apache.org/documentation/txn/transactions_api.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/txn/transactions_api.html</guid>
<description>API for Transactions Read transactions Write transactions Transaction promotion Txn - A higher level API to transactions API for Transactions This page describes the basic transaction API in Jena (3.1.0 and later).
There is also a higher-level API useful in many situations but sometimes it is necessary to use the basic transaction API described here.
Read transactions These are used for SPARQL queries and code using the Jena API actions that do not change the data.</description>
</item>
<item>
<title>LARQ - adding free text searches to SPARQL</title>
<link>https://jena.apache.org/documentation/archive/larq/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/larq/</guid>
<description>As of Jena 2.11.0, LARQ is replaced by jena-text
jena-text includes use of Apache Solr as a shared, search server, or Apache Lucene as a local text index. From Fuseki 0.2.7, jena-text is built into Fuseki.
LARQ is not compatible with jena-text; the index format has changed and the integration with SPARQL is different.
LARQ is a combination of ARQ and Lucene. It gives users the ability to perform free text searches within their SPARQL queries.</description>
</item>
<item>
<title>Maven Artifacts for Apache Jena Elephas</title>
<link>https://jena.apache.org/documentation/archive/hadoop/artifacts.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/hadoop/artifacts.html</guid>
<description>The Apache Jena Elephas libraries for Apache Hadoop are a collection of maven artifacts which can be used individually or together as desired. These are available from the same locations as any other Jena artifact, see Using Jena with Maven for more information.
Hadoop Dependencies The first thing to note is that although our libraries depend on relevant Hadoop libraries these dependencies are marked as provided and therefore are not transitive.</description>
</item>
<item>
<title>Maven Artifacts for Jena JDBC</title>
<link>https://jena.apache.org/documentation/jdbc/artifacts.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/jdbc/artifacts.html</guid>
<description>The Jena JDBC libraries are a collection of maven artifacts which can be used individually or together as desired. These are available from the same locations as any other Jena artifact, see Using Jena with Maven for more information.
Core Library The jena-jdbc-core artifact is the core library that contains much of the common implementation for the drivers. This is a dependency of the other artifacts and will typically only be required as a direct dependency if you are implementing a custom driver</description>
</item>
<item>
<title>Migrating from Jena2 to Jena3</title>
<link>https://jena.apache.org/documentation/migrate_jena2_jena3.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/migrate_jena2_jena3.html</guid>
<description>Apache Jena3 is a major version release for Jena - it is not binary compatible with Jena2. The migration consists of package renaming and database reloading.
Key Changes Package renaming RDF 1.1 Semantics for plain literals Persistent data (TDB, SDB) should be reloaded. Java8 is required. Security renamed to Permissions. Security Evaluator changes required Package Name Changes Packages with a base name of com.hp.hpl.jena become org.apache.jena.
Global replacement of import com.</description>
</item>
<item>
<title>Notes on Jena internals</title>
<link>https://jena.apache.org/documentation/notes/jena-internals.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/jena-internals.html</guid>
<description>Note: These notes are not kept up to date.
They may be of interest into the original design of the Enhanced Node mechanism.
Enhanced Nodes This note is a development of the original note on the enhanced node and graph design of Jena 2.
Key objectives for the enhanced node design One problem with the Jena 1 design was that both the DAML layer and the RDB layer independently extended Resource with domain-specific information.</description>
</item>
<item>
<title>Parameterized SPARQL String</title>
<link>https://jena.apache.org/documentation/query/parameterized-sparql-strings.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/parameterized-sparql-strings.html</guid>
<description>A Parameterized SPARQL String is a SPARQL query/update into which values may be injected.
The intended usage of this is where using a QuerySolutionMap as initial bindings is either inappropriate or not possible e.g.
Generating query/update strings in code without lots of error prone and messy string concatenation Preparing a query/update for remote execution Where you do not want to simply say some variable should have a certain value but rather wish to insert constants into the query/update in place of variables Defending against SPARQL injection when creating a query/update using some external input, see SPARQL Injection notes for limitations.</description>
</item>
<item>
<title>Presenting RDF as frames</title>
<link>https://jena.apache.org/documentation/notes/rdf-frames.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/rdf-frames.html</guid>
<description>The origins of RDF as a representation language include frame languages, in which an object, or frame, was the main unit of structuring data. Frames have slots, for example a Person frame might have an age slot, a heightslot etc. RDF, however, has taken a step beyond frame languages by making rdf:Property a first class value, not an element of a frame or resource per se. In RDF, for example, an age property can be defined: &amp;lt;rdf:Property rdf:ID=&amp;quot;age&amp;quot;&amp;gt;, and then applied to any resource, including, but not limited to a Person resource.</description>
</item>
<item>
<title>Property Functions in ARQ</title>
<link>https://jena.apache.org/documentation/query/library-propfunc.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/library-propfunc.html</guid>
<description>SPARQL allows custom property functions to add functionality to the triple matching process. Property functions can be registered or dynamically loaded.
See also the free text search page.
See also the FILTER functions FILTER functions library.
Applications can also provide their own property functions.
Property Function Library The prefix apf is &amp;lt;http://jena.apache.org/ARQ/property#&amp;gt;. (The old prefix of &amp;lt;http://jena.hpl.hp.com/ARQ/property#&amp;gt; continues to work. Applications are encouraged to switch.)
Direct loading using a URI prefix of &amp;lt;java:org.</description>
</item>
<item>
<title>RDF Binary using Apache Thrift</title>
<link>https://jena.apache.org/documentation/io/rdf-binary.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/rdf-binary.html</guid>
<description>&amp;ldquo;RDF Binary&amp;rdquo; is a efficient format for RDF and RDF-related data using Apache Thrift or Google Protocol Buffers as the binary data encoding.
The W3C standard RDF syntaxes are text or XML based. These incur costs in parsing; the most human-readable formats also incur high costs to write, and have limited scalability due to the need to analyse the data for pretty printing rather than simply stream to output.
Binary formats are faster to process - they do not incur the parsing costs of text-base formats.</description>
</item>
<item>
<title>RDF Connection : SPARQL operations API</title>
<link>https://jena.apache.org/documentation/rdfconnection/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/rdfconnection/</guid>
<description>RDFConnection provides a unified set of operations for working on RDF with SPARQL operations. It provides SPARQL Query, SPARQL Update and the SPARQL Graph Store operations. The interface is uniform - the same interface applies to local data and to remote data using HTTP and the SPARQL protocols ( SPARQL protocol and SPARQL Graph Store Protocol).
Outline RDFConnection provides a number of different styles for working with RDF data in Java.</description>
</item>
<item>
<title>RDF/XML Handling in Jena</title>
<link>https://jena.apache.org/documentation/io/arp.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/arp.html</guid>
<description>This section details the Jena RDF/XML parser. ARP is the parsing subsystem in Jena for handling the RDF/XML syntax.
ARP Features Using ARP without Jena Using other SAX and DOM XML sources ARP Features Java based RDF parser. Compliant with RDF Syntax and RDF Test Cases Recommendations. Compliant with following standards and recommendations: xml:lang
xml:lang is fully supported, both in RDF/XML and any document embedding RDF/XML. Moreover, the language tags are checked against RFC1766, RFC3066, ISO639-1, ISO3166.</description>
</item>
<item>
<title>Reading and Writing RDF in Apache Jena</title>
<link>https://jena.apache.org/documentation/io/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/</guid>
<description>This page details the setup of RDF I/O technology (RIOT).
Formats Commands Reading RDF in Jena Writing RDF in Jena Working with RDF Streams Additional details on working with RDF/XML Formats The following RDF formats are supported by Jena. In addition, other syntaxes can be integrated into both the parser and writer registries.
Turtle RDF/XML N-Triples JSON-LD RDF/JSON TriG N-Quads TriX RDF Binary RDF/JSON is different from JSON-LD - it is a direct encoding of RDF triples in JSON.</description>
</item>
<item>
<title>Reading JSON-LD 1.1</title>
<link>https://jena.apache.org/documentation/io/json-ld-11.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/json-ld-11.html</guid>
<description>JSON-LD 1.1 is the default version of JSON-LD supported by Apache Jena. This page is out of date and left temporary only for information about using JSON-LD 1.1 in versions 4.2.x to 4.4.x.
This page details support for reading JSON-LD 1.1 using Titanium JSON-LD.
While Titanium is licensed under the Apache License, it has a dependency on the Eclipse Jakarta JSON Processing API, which is licensed under the Eclipse Public License 2.</description>
</item>
<item>
<title>Reading RDF in Apache Jena</title>
<link>https://jena.apache.org/documentation/io/rdf-input.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/rdf-input.html</guid>
<description>This page details the setup of RDF I/O technology (RIOT) for Apache Jena.
See Writing RDF for details of the RIOT Writer system.
API Determining the RDF syntax Example 1 : Using the RDFDataMgr Example 2 : Model usage Example 3 : Using RDFParser Logging The StreamManager and LocationMapper Configuring a StreamManager Configuring a LocationMapper Advanced examples Iterating over parser output Filtering the output of parsing Add a new language Full details of operations are given in the javadoc.</description>
</item>
<item>
<title>Reasoners and rule engines: Jena inference support</title>
<link>https://jena.apache.org/documentation/inference/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/inference/</guid>
<description>This section of the documentation describes the current support for inference available within Jena. It includes an outline of the general inference API, together with details of the specific rule engines and configurations for RDFS and OWL inference supplied with Jena.
Not all of the fine details of the API are covered here: refer to the Jena Javadoc to get the full details of the capabilities of the API. Note that this is a preliminary version of this document, some errors or inconsistencies are possible, feedback to the mailing lists is welcomed.</description>
</item>
<item>
<title>Reification HowTo</title>
<link>https://jena.apache.org/documentation/notes/reification.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/reification.html</guid>
<description>Introduction This document describes the Jena API support for reification. it. As always, consult the Javadoc for interface details.
Reification in RDF and Jena is the ability to treat a Statement as a Resource, and hence to make assertions about that statement. A statement may be reified as many different resources, allowing different manifestations (&amp;ldquo;statings&amp;rdquo;) of that statement to be treated differently if required.
RDF represents a reified statement as four statements with particular RDF properties and objects: the statement (S, P, O), reified by resource R, is represented by:</description>
</item>
<item>
<title>Reification styles (archive material)</title>
<link>https://jena.apache.org/documentation/notes/reification_previous.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/reification_previous.html</guid>
<description>Reification styles Prior to version 2.10.0 of Jena, there were 3 styles of reification, &amp;ldquo;standard&amp;rdquo;, &amp;ldquo;minimal&amp;rdquo; and &amp;ldquo;convenient&amp;rdquo;. As of 2.10.0 and later, only what was previously the &amp;ldquo;standard&amp;rdquo; style is supported.
By default and as you might expect, Jena models allow reification quads to be manifested as ReifiedStatements. Similarly, explicitly created ReifiedStatements are visible as statement quads.
Sometimes, this is not desirable. For example, in an application that reifies large numbers of statements in the same model as those statements, most of the results from listStatements() will be quadlets; this is inefficient and confusing.</description>
</item>
<item>
<title>Running Fuseki with UI</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-webapp.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-webapp.html</guid>
<description>Fuseki/UI can be run in a number of ways:
As a standalone server As a service run by the operation system, for example, started when the machine boots As a Web Application inside a container such as Apache Tomcat or Jetty. Fuseki is also packaged as a plain server &amp;ldquo;Fuseki Main&amp;rdquo; with no UI for use as a configurable SPARQL server, for building as a Docker container, and as a deployment and development standalone server.</description>
</item>
<item>
<title>SAX Input into Jena and ARP</title>
<link>https://jena.apache.org/documentation/io/arp_sax.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/arp_sax.html</guid>
<description>Normally, both ARP and Jena are used to read files either from the local machine or from the Web. A different use case, addressed here, is when the XML source is available in-memory in some way. In these cases, ARP and Jena can be used as a SAX event handler, turning SAX events into triples, or a DOM tree can be parsed into a Jena Model.
Contents Overview Sample Code Initializing SAX event source Error Handler Options XML Lang and Namespaces Using your own triple handler Using a DOM as input 1.</description>
</item>
<item>
<title>Schemagen Maven</title>
<link>https://jena.apache.org/documentation/tools/schemagen-maven.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tools/schemagen-maven.html</guid>
<description>Schemagen-maven: generating Java source files from OWL and RDFS ontologies via Maven The Apache Jena command line tool schemagen provides an automated way of creating Java source code constants from ontology files in an RDF-based project. This can be very convenient, as it provides both a level of robustness that the names of RDF classes, properties and individuals are being used correctly, and it can be used by IDE&amp;rsquo;s such as Eclipse to provide name-completion for constants from the ontology.</description>
</item>
<item>
<title>SDB - persistent triple stores using relational databases</title>
<link>https://jena.apache.org/documentation/archive/sdb/sdb_index.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/sdb_index.html</guid>
<description>SDB uses an SQL database for the storage and query of RDF data. Many databases are supported, both Open Source and proprietary.
An SDB store can be accessed and managed with the provided command line scripts and via the Jena API.
Use of SDB for new applications is not recommended. This component is &amp;ldquo;maintenance only&amp;rdquo;.
TDB is faster, more scalable and better supported than SDB.
Status As of June 2013 the Jena developers agreed to treat SDB as being only maintained where possible.</description>
</item>
<item>
<title>SDB Configuration</title>
<link>https://jena.apache.org/documentation/archive/sdb/configuration.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/configuration.html</guid>
<description>This page describes the configuration options available. These are options for query processing, not for the database layout and storage, which is controlled by store descriptions.
Contents Setting Options Current Options Queries over all Named Graphs Streaming over JDBC Annotated SQL Setting Options Options can be set globally, throughout the JVM, or on a per query execution basis. SDB uses the same mechanism as ARQ.</description>
</item>
<item>
<title>SDB Database Layouts</title>
<link>https://jena.apache.org/documentation/archive/sdb/database_layouts.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/database_layouts.html</guid>
<description>SDB does not have a single database layout. This page is an informal overview of the two main types (&amp;ldquo;layout2/hash&amp;rdquo; and &amp;ldquo;layout2/index&amp;rdquo;).
In SDB one store is one RDF dataset is one SQL database.
Databases of type layout2 have a triples table for the default graph, a quads table for the named graphs. In the triples and quads tables, the columns are integers referencing a nodes table.
In the hash form, the integers are 8-byte hashes of the node.</description>
</item>
<item>
<title>SDB Database Notes</title>
<link>https://jena.apache.org/documentation/archive/sdb/db_notes.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/db_notes.html</guid>
<description>DB2 Derby MS SQL MySQL PostgresQL DB2 Database creation The database should be created with code set UTF-8 so unicode is enabled (SDB creates tables CCSID UNICODE for full internationalization support).
Derby Loading Restriction Only one load operation can be active at any one time. Limitations on temporary tables in Derby mean the loader tables are not temporary and hence are shared by all connections.
MS SQL The collation sequence for the database must be one that is binary (BIN in the name).</description>
</item>
<item>
<title>SDB Databases Supported</title>
<link>https://jena.apache.org/documentation/archive/sdb/databases_supported.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/databases_supported.html</guid>
<description>Product Version Oracle 10g Including OracleXE Microsoft SQL Server 2005 Including MS SQL Express DB2 9 Including DB2 9 Express PostgreSQL v8.2 MySQL v5.0.22 Apache Derby v10.2.2.0 H2 1.0.71 HSQLDB 1.8.0 Support for a version implies support for later versions unless otherwise stated.
Microsoft SQL Server 2000 is also reported to work.</description>
</item>
<item>
<title>SDB Dataset Description</title>
<link>https://jena.apache.org/documentation/archive/sdb/dataset_description.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/dataset_description.html</guid>
<description>Assembler descriptions for RDF Datasets and individual models are built from Store Descriptions. A dataset assembler just points to the store to use; a model assembler points to the store and identifies the model within the store to use (or use the default model).
Datasets The example below creates an in-memory store implemented by HSQLDB.
PREFIX rdfs: &amp;lt;http://www.w3.org/2000/01/rdf-schema#&amp;gt; PREFIX rdf: &amp;lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#&amp;gt; PREFIX xsd: &amp;lt;http://www.w3.org/2001/XMLSchema#&amp;gt; PREFIX ja: &amp;lt;http://jena.hpl.hp.com/2005/11/Assembler#&amp;gt; PREFIX sdb: &amp;lt;http://jena.hpl.hp.com/2007/sdb#&amp;gt; sdb:DatasetStore rdfs:subClassOf ja:RDFDataset .</description>
</item>
<item>
<title>SDB FAQ</title>
<link>https://jena.apache.org/documentation/archive/sdb/faq.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/faq.html</guid>
<description>Tune your database Database performance depends on the database being tuned. Some databases default to &amp;ldquo;developer setup&amp;rdquo; which does not use much of the RAM but is only for functional testing.
Improving loading rates For a large bulk load into an existing store, dropping the indexes, doing the load and then recreating the indexes can be noticeably faster.
sdbconfig --drop sdbload file sdbconfig --index For a large bulk load into a new store, just format it, and not create the indexes, do the load and then recreating the indexes can be noticeably faster.</description>
</item>
<item>
<title>SDB Fuseki Integration</title>
<link>https://jena.apache.org/documentation/archive/sdb/fuseki_integration.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/fuseki_integration.html</guid>
<description>Fuseki is a server that implements the SPARQL protocol for HTTP. It can be used to give a SPARQL interface to an SDB installation.
The Fuseki server needs the SDB jar files on its classpath. The Fuseki server configuration file needs to contain two triples to integrate SDB:
[] rdf:type fuseki:Server ; fuseki:services ( &amp;lt;#service1&amp;gt; ) . ## Declare that sdb:DatasetStore is an implementation of ja:RDFDataset . sdb:DatasetStore rdfs:subClassOf ja:RDFDataset .</description>
</item>
<item>
<title>SDB Installation</title>
<link>https://jena.apache.org/documentation/archive/sdb/installation.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/installation.html</guid>
<description>A suitable database must be installed separately. Any database installation should be tuned according to the database documentation.
The SDB distribution is zip file of a directory hierarchy.
Unzip this. You may need to run chmod u+x on the scripts in the bin/ directory.
Write a sdb.ttl store description: there are examples in the Store/ directory.
A database must be created before the tests can be run. Microsoft SQL server and PostgreSQL need specific database options set when a database is created.</description>
</item>
<item>
<title>SDB JavaAPI</title>
<link>https://jena.apache.org/documentation/archive/sdb/javaapi.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/javaapi.html</guid>
<description>This page describes how to use SDB from Java.
Code examples are in src-examples/ in the SDB distribution.
Contents Concepts Obtaining the Store From a configuration file In Java code Database User and Password Connection Management Formatting or Emptying the Store Loading data Executing Queries Using the Jena Model API with SDB Concepts Store SDBFactory SDBConnection SDB loads and queries data based on the unit of a Store.</description>
</item>
<item>
<title>SDB Loading data</title>
<link>https://jena.apache.org/documentation/archive/sdb/loading_data.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/loading_data.html</guid>
<description>There are three ways to load data into SDB:
Use the command utility sdbload Use one of the Jena model.read operations Use the Jena model.add The last one of these requires the application to signal the beginning and end of batches.
Loading with Model.read A Jena Model obtained from SDB via:
SDBFactory.connectModel(store) will automatically bulk load data for each call of one of the Model.read operations.
Loading with Model.</description>
</item>
<item>
<title>SDB Loading performance</title>
<link>https://jena.apache.org/documentation/archive/sdb/loading_performance.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/loading_performance.html</guid>
<description>Introduction The Databases and Hardware Hardware Windows setup Linux setup The Dataset and Queries LUBM dbpedia Loading Results Uniprot 700m loading: Tuning Helps Introduction Performance reporting is an area prone to misinterpretation, and such reports should be liberally decorated with disclaimers. In our case there are an alarming number of variables: the hardware, the operating system, the database engine and its myriad parameters, the data itself, the queries, and planetary alignment.</description>
</item>
<item>
<title>SDB Query performance</title>
<link>https://jena.apache.org/documentation/archive/sdb/query_performance.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/query_performance.html</guid>
<description>This page compares the effect of SDB with RDB, Jena&amp;rsquo;s usual database layout. RDB was designed for supporting the fine-grained API calls as well as having some support for basic graph patterns. Therefore, the RDB design goals were not those of SDB.
RDB uses a denormalised database layout in order that all statement-level operations do not require additional joins. The SDB layout is normalised so that the triple table is narrower and uses integers for RDF nodes, then does do joins to get the node representation.</description>
</item>
<item>
<title>SDB Quickstart</title>
<link>https://jena.apache.org/documentation/archive/sdb/quickstart.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/quickstart.html</guid>
<description>SDB provides some command line tools to work with SDB triple stores. In the following it assumed that you have a store description set up for your database (sdb.ttl). See the store description format for details. The Store/ directory for some examples.
Setting up your environment $ export SDBROOT=/path/to/sdb $ export PATH=$SDBROOT/bin:$PATH $ export SDB_USER=YourDatabaseUserName $ export SDB_PASSWORD=YourDatabasePassword $ export SDB_JDBC=YourJDBCdriver Initialising the database Be aware that this will wipe existing data from the database.</description>
</item>
<item>
<title>SDB Store Description</title>
<link>https://jena.apache.org/documentation/archive/sdb/store_description.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/store_description.html</guid>
<description>Use of an SDB store requires a Store object which is described in two parts:
a connection to the database a description of the store configuration These can be built from a Jena assembler description.
Store objects themselves are lightweight so connections to an SDB database can be created on a per-request basis as required for use in J2EE application servers.
Contents Store Descriptions SDB Connections Example Vocabulary Store Connection Store Descriptions A store description identifies which storage layout is being used, the connection to use and the database type.</description>
</item>
<item>
<title>SDB/Commands</title>
<link>https://jena.apache.org/documentation/archive/sdb/commands.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/sdb/commands.html</guid>
<description>This page describes the command line programs that can be used to create an SDB store, load data into it and to issue queries.
Contents Scripts
Script set up Argument Structure Store Description
Modifying the Store Description Logging and Monitoring SDB Commands
Database creation Loading data Query Testing Other Scripts The directory bin/ contains shell scripts to run the commands from the command line.</description>
</item>
<item>
<title>Security in Fuseki2</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-security.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-security.html</guid>
<description>Fuseki2 webapp provides security by using Apache Shiro. This is controlled by the configuration file shiro.ini located at $FUSEKI_BASE/shiro.ini. If not found, the server initializes with a default configuration. This can then be replaced or edited as required. An existing file is never overwritten by the server.
In its default configuration, SPARQL endpoints are open to the public but administrative functions are limited to localhost. One can access it via http://localhost:.</description>
</item>
<item>
<title>Security in Fuseki2 server</title>
<link>https://jena.apache.org/documentation/fuseki2/fuseki-main-security.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/fuseki-main-security.html</guid>
<description>This page covers security for Fuseki Main.
See other documentation for the webapp packaging of Fuseki.
Serving RDF For any use of users-password information, and especially HTTP basic authentication, information is visible in the HTTP headers. When serving RDF and SPARQL requests, using HTTPS is necessary to avoid snooping. Digest authentication is also stronger over HTTPS because it protects against man-in-the-middle attacks.</description>
</item>
<item>
<title>SOH - SPARQL over HTTP</title>
<link>https://jena.apache.org/documentation/fuseki2/soh.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/fuseki2/soh.html</guid>
<description>SOH (SPARQL Over HTTP) is a set of command-line scripts for working with SPARQL 1.1. SOH is server-independent and will work with any compliant SPARQL 1.1 system offering HTTP access.
SOH is written in ruby.
Commands:
s-http – SPARQL 1.1 HTTP Protocol s-get, s-put, s-delete, s-post, s-head – abbreviation for s-http get ... etc. s-query – SPARQL 1.1 Query, both GET and POST of queries. s-update – SPARQL 1.1 Update s-update-form – SPARQL 1.</description>
</item>
<item>
<title>SPARQL S-Expressions (or &#34;SPARQL Syntax Expressions&#34;)</title>
<link>https://jena.apache.org/documentation/notes/sse.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/sse.html</guid>
<description>A way to write down data structures in an RDF-centric syntax.
But not an idea for another RDF serialization format.
Contents Need Design Intent Other Approaches RDF Lisp XML JSON Design Tokens SSE Comments SSE Escapes Structures Tagged Structures IRI resolution base prefix Nesting Links Building Java Objects SSE Factory Mapping to RDF SSE Files Longer Examples Query 1 Complete SPARQL Execution SSE Grammar Need The SPARQL algebra defines the semantics of a SPARQL graph pattern.</description>
</item>
<item>
<title>Spatial searches with SPARQL</title>
<link>https://jena.apache.org/documentation/query/spatial-query-doc.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/spatial-query-doc.html</guid>
<description>This module was first released with Jena 2.11.0. It was last released in Jena 3.12.0.
Jena provides a GeoSPARQL implementation.
This is an extension to Apache Jena ARQ, which combines SPARQL and simple spatial query. It gives applications the ability to perform simple spatial searches within SPARQL queries. Spatial indexes are additional information for accessing the RDF graph.
The spatial index can be either Apache Lucene for a same-machine spatial index, or Apache Solr for a large scale enterprise search application.</description>
</item>
<item>
<title>Spatial searches with SPARQL</title>
<link>https://jena.apache.org/documentation/query/spatial-query.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/spatial-query.html</guid>
<description> The Jena Spatial module has been retired. The last release of Jena with jena-spatial was Jena 3.12.0. See jena-spatial/README.md. The original documentation is here
</description>
</item>
<item>
<title>Support for Internationalised Resource Identifiers in Jena</title>
<link>https://jena.apache.org/documentation/notes/iri.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/iri.html</guid>
<description>The Jena IRI Library is an implementation of RFC 3987 (IRI) and RFC 3986 (URI), and a partial implementation of other related standards. It is incomplete.
Javadoc The IRI Library Javadoc (Public APIs)
The most important parts of the Javadoc are:
ViolationCodes Gives the relationships between the error codes and the specifications.
IRI Gives the main interface for IRIs.
IRIFactory Gives the main class for creating IRIs, including specifying which specifications you wish to be using, and with what degree of force.</description>
</item>
<item>
<title>Support for XSD Datatype and XQuery/Xpath Functions and Operations.</title>
<link>https://jena.apache.org/documentation/query/xsd-support.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/xsd-support.html</guid>
<description>ARQ supports the functions and operators from &amp;ldquo;XQuery 1.0 and XPath 2.0 Functions and Operators v3.1&amp;quot;.
ARQ supports all the XSD atomic datatypes.
The prefix fn is &amp;lt;http://www.w3.org/2005/xpath-functions#&amp;gt; (the XPath and XQuery function namespace).
The prefix math is &amp;lt;http://www.w3.org/2005/xpath-functions/math#&amp;gt;
To check the exact registrations for a specific version, see function/StandardFunctions.java in the source code for that version.
The supported datatypes (including those required by SPARQL 1.1), including full operator support, are the XSD atomic datatypes except for XML-related ones.</description>
</item>
<item>
<title>Support of RDF-star</title>
<link>https://jena.apache.org/documentation/rdf-star/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/rdf-star/</guid>
<description>RDF-star is an extension to RDF that provides a way for one triple to refer to another triple. RDF* is the name of the original work which is described in Olaf Hartig&amp;rsquo;s blog entry.
Example:
&amp;lt;&amp;lt;:johnfoaf:name&amp;#34;John Smith&amp;#34;&amp;gt;&amp;gt;dct:source&amp;lt;http://example/directory&amp;gt;.The part &amp;lt;&amp;lt; :john foaf:name &amp;quot;John Smith&amp;quot; &amp;gt;&amp;gt; is a quoted triple and refers to the triple with subject :john, property foaf:name and object &amp;quot;John Smith&amp;quot;.
Triple terms can be in the subject or object position.</description>
</item>
<item>
<title>Support Request</title>
<link>https://jena.apache.org/documentation/query/support_request.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/support_request.html</guid>
<description>Writing a Support Request A good support request or bug report is clear and concise. For ARQ, reduce the problem to a short dataset (20 triples should be enough; Turtle, N3 or N-triples preferred) and a query that illustrates the problem. State what you expected to happen as well as what did happen.
It also a good idea to check the documentation.
ARQ FAQ ARQ Documentation Parse Errors The SPARQL parser outputs a line and column number - it is usually correct in identifying the first point of a syntax error.</description>
</item>
<item>
<title>TDB</title>
<link>https://jena.apache.org/documentation/tdb/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/</guid>
<description>TDB is a component of Jena for RDF storage and query. It supports the full range of Jena APIs. TDB can be used as a high performance RDF store on a single machine. This documentation describes the latest version, unless otherwise noted.
This is the documentation for the current standard version of TDB. This is also called TDB1 to distinguish it from the next generation version TDB2
TDB1 and TDB2 databases are not compatible.</description>
</item>
<item>
<title>TDB - Store Parameters</title>
<link>https://jena.apache.org/documentation/tdb/store-parameters.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/store-parameters.html</guid>
<description>TDB (as of version Jena 3.0.0) supports configuration of the databases when they are first created and each time an application connects to an existing database. Databases using the default settings built-into TDB continue to work exactly as before.
Setting Store Parameters In TDB, there is exactly one internal object for each dataset in the JVM and this is shared between all application datasets for that location of persistent storage.</description>
</item>
<item>
<title>TDB Architecture</title>
<link>https://jena.apache.org/documentation/tdb/architecture.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/architecture.html</guid>
<description>This page gives an overview of the TDB architecture. It applies to TDB1 and TDB2 with differences noted.
Contents Terminology Design The Node Table Triple and Quad indexes Prefixes Table TDB B+Trees Transactions Inline values Query Processing Caching on 32 and 64 bit Java systems Terminology Terms like &amp;ldquo;table&amp;rdquo; and &amp;ldquo;index&amp;rdquo; are used in this description. They don&amp;rsquo;t directly correspond to concepts in SQL, For example, in SQL terms, there is no triple table; that can be seen as just having indexes for the table or, alternatively, there are 3 tables, each of which has a primary key and TDB manages the relationship between them.</description>
</item>
<item>
<title>TDB Assembler</title>
<link>https://jena.apache.org/documentation/tdb/assembler.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/assembler.html</guid>
<description>Assemblers are a general mechanism in Jena to describe objects to be built, often these objects are models and datasets. Assemblers are used heavily in Fuseki for dataset and model descriptions, for example.
SPARQL queries operate over an RDF dataset, which is an unnamed, default graph and zero or more named graphs.
Having the description in a file means that the data that the application is going to work on can be changed without changing the program code.</description>
</item>
<item>
<title>TDB Command-line Utilities</title>
<link>https://jena.apache.org/documentation/tdb/commands.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/commands.html</guid>
<description>Contents Installation Scripts Script set up - bash scripts Script set up - Windows batch files Command line script arguments Setting options from the command line TDB Commands Store description tdbloader TDB xloader tdbquery tdbdump tdbstats Installation From Apache Jena version 2.7.x onwards, TDB is now installed as part of a single integrated Jena package. There is no longer a need to install a separate TDB package to run the TDB command line tools, or to use TDB in your Java programs.</description>
</item>
<item>
<title>TDB Configuration</title>
<link>https://jena.apache.org/documentation/tdb/configuration.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/configuration.html</guid>
<description>There are a number of configuration options that affect the operation of TDB.
Contents Setting Options Setting from the command line Setting with Java System properties Query of the union of named graphs Logging Query Execution Dataset Caching File Access Mode TDB Configuration Symbols Advanced Store Configuration Setting Options Options can be set globally, through out the JVM, or on a per query execution basis. TDB uses the same mechanism as ARQ.</description>
</item>
<item>
<title>TDB Datasets</title>
<link>https://jena.apache.org/documentation/tdb/datasets.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/datasets.html</guid>
<description>An RDF Dataset is a collection of one, unnamed, default graph and zero, or more named graphs. In a SPARQL query, a query pattern is matched against the default graph unless the GRAPH keyword is applied to a pattern.
Dataset Storage One file location (directory) is used to store one RDF dataset. The unnamed graph of the dataset is held as a single graph while all the named graphs are held in a collection of quad indexes.</description>
</item>
<item>
<title>TDB Dynamic Datasets</title>
<link>https://jena.apache.org/documentation/tdb/dynamic_datasets.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/dynamic_datasets.html</guid>
<description>TDB version 0.8.5 and later
This feature allows a query to be made on a subset of all the named graphs in the TDB storage datasets. The SPARQL GRAPH pattern allows access to either a specific named graph or to all the named graph in a dataset. This feature means that only specified named graphs are visible to the query.
SPARQL has the concept of a dataset description. In a query string, the clauses for FROM and FROM NAMED specify the dataset.</description>
</item>
<item>
<title>TDB FAQs</title>
<link>https://jena.apache.org/documentation/tdb/faqs.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/faqs.html</guid>
<description>FAQs What are TDB1 and TDB2? Does TDB support Transactions? Can I share a TDB dataset between multiple applications? What is the Impossibly Large Object exception? What are the ObjectFile.read() and ObjectFileStorage.read() errors? What is the difference between tdbloader and tdbloader2? How large a Java heap size should I use for TDB? Does Fuseki/TDB have a memory leak? Should I use a SSD? Why do I get the exception Can&amp;rsquo;t open database at location /path/to/db as it is already locked by the process with PID 1234 when trying to open a TDB database?</description>
</item>
<item>
<title>TDB Java API</title>
<link>https://jena.apache.org/documentation/tdb/java_api.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/java_api.html</guid>
<description>All the operations of the Jena API including the SPARQL query and SPARQL Update are supported. The application obtains a model or RDF datasets from TDB then uses it as for any other model or dataset.
Contents Constructing a model or dataset Using a directory name Using an assembler file Bulkloader Concurrency Caching and synchronization TDB also supports transactions.
Constructing a model or dataset The class TDBFactory contains the static factory methods for creating and connecting to a TDB-backed graph or an RDF dataset.</description>
</item>
<item>
<title>TDB Optimizer</title>
<link>https://jena.apache.org/documentation/tdb/optimizer.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/optimizer.html</guid>
<description>Query execution in TDB involves both static and dynamic optimizations. Static optimizations are transformations of the SPARQL algebra performed before query execution begins; dynamic optimizations involve deciding the best execution approach during the execution phase and can take into account the actual data so far retrieved.
The optimizer has a number of strategies: a statistics based strategy, a fixed strategy and a strategy of no reordering.
For the preferred statistics strategy, the TDB optimizer uses information captured in a per-database statistics file.</description>
</item>
<item>
<title>TDB Quad Filter</title>
<link>https://jena.apache.org/documentation/tdb/quadfilter.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/quadfilter.html</guid>
<description>This page describes how to filter quads at the lowest level of TDB. It can be used to hide certain quads (triples in named graphs) or triples.
The code for the example on this page can be found in the TDB examples Filtering quads should be used with care. The performance of the tuple filter callback is critical.
See also Dynamic Datasets to select only certain specified named graphs for a query.</description>
</item>
<item>
<title>TDB Requirements</title>
<link>https://jena.apache.org/documentation/tdb/requirements.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/requirements.html</guid>
<description>TDB can run on 32 bit or 64 bit JVMs. It adapts to the underlying architecture by choosing different file access mechanisms. 64 bit Java is preferred for large scale and production deployments. On 64 bit Java, TDB uses memory mapped files.
On 32 bit platforms, TDB uses in-heap caching of file data. In practice, the JVM heap size should be set to at least 1Gbyte. While there is no inherent scaling limits on the size of the database but, in practice, only one large dataset can be handled per TDB instance.</description>
</item>
<item>
<title>TDB Transactions</title>
<link>https://jena.apache.org/documentation/tdb/tdb_transactions.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/tdb_transactions.html</guid>
<description>TDB provides ACID transaction support through the use of write-ahead-logging in TDB1 and copy-on-write MVCC structures in TDB2.
Use of transactions protects a TDB dataset against data corruption, unexpected process termination and system crashes.
Non-transactional use of TDB1 should be avoided; TDB2 only operates with transactions.
Contents Overview Limitations API for Transactions Read transactions Write transactions Multi-threaded use Bulk loading Multi JVM Overview TDB2 uses MVCC via a copy-on-write mechanism.</description>
</item>
<item>
<title>TDB Transactions</title>
<link>https://jena.apache.org/documentation/txn/transactions_tdb.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/txn/transactions_tdb.html</guid>
<description>API for Transactions TDB1 and TDB2 TDB1, the original native TDB database for Apache Jena, and TDB2 are related but different systems. Their transaction systems both provide Serializable transactions, the highest isolation level. with one active write transaction and multiple read transactions at the same time.
TDB2 does not have the transaction size limitations of TDB1.
TDB1 The transaction mechanism in TDB is based on write-ahead-logging. All changes made inside a write-transaction are written to journals, then propagated to the main database at a suitable moment.</description>
</item>
<item>
<title>TDB Value Canonicalization</title>
<link>https://jena.apache.org/documentation/tdb/value_canonicalization.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/value_canonicalization.html</guid>
<description>TDB canonicalizes certain XSD datatypes. The value of literals of these datatypes is stored, not the original lexical form. For example, &amp;quot;01&amp;quot;^^xsd:integer, &amp;quot;1&amp;quot;^^xsd:integer and &amp;quot;+001&amp;quot;^^xsd:integer are all the same value and are stored as the same RDF literal. In addition, derived types for integers are also understood by TDB. For example, &amp;quot;01&amp;quot;^^xsd:integer and &amp;quot;1&amp;quot;^^xsd:byte are the same value.
When RDF terms for these values are returned, the lexical form will be the canonical representation.</description>
</item>
<item>
<title>TDB with 64-bit and 32-bit JVMs</title>
<link>https://jena.apache.org/documentation/tdb/tdb_system.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/tdb_system.html</guid>
<description>TDB runs on both 32-bit and 64-bit Java Virtual Machines. The same file formats are used on both systems and database files can be transferred between architectures (no TDB system should be running for the database at the time of copy). The difference is that a different file access mechanism used.
The file access mechanism can be set explicitly, but this is not a good idea for production usage, only for experimentation - see the File Access mode option.</description>
</item>
<item>
<title>TDB xloader</title>
<link>https://jena.apache.org/documentation/tdb/tdb-xloader.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb/tdb-xloader.html</guid>
<description>TDB xloader (&amp;ldquo;x&amp;rdquo; for external) is a bulkloader for very large datasets. The goal is stability and reliability for long running loading, running on modest hardware and can be use to load a database on rotating disk or SSD.
xloader is not a replacement for regular TDB1 and TDB2 loaders. It is for very large datasets.
There are two scripts to load data using the xloader subsystem.
&amp;ldquo;tdb1.xloader&amp;rdquo;, which was called &amp;ldquo;tdbloader2&amp;rdquo;, has some improvements.</description>
</item>
<item>
<title>TDB2</title>
<link>https://jena.apache.org/documentation/tdb2/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb2/</guid>
<description>TDB2 is a component of Apache Jena for RDF storage and query. It supports the full range of Jena APIs. TDB2 can be used as a high performance RDF store on a single machine. TDB2 can be used with Apache Jena Fuseki.
TDB1 is the previous generation native storage system for Jena.
Compared to TDB1:
No size limits on transactions : bulk uploads into a live Fuseki can be 100&amp;rsquo;s of millions of triples.</description>
</item>
<item>
<title>TDB2 - Command Line Tools</title>
<link>https://jena.apache.org/documentation/tdb2/tdb2_cmds.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb2/tdb2_cmds.html</guid>
<description>TDB2 is not compatible with TDB1
Do not run TDB1 tools on a TDB2 database, nor run TDB2 tools on a TDB1 database.
These scripts are available jena binary distribution.
tdb2.tdbbackup tdb2.tdbdump tdb2.tdbcompact tdb2.tdbloader tdb2.tdbquery tdb2.tdbupdate On MS Windows, these commands are called tdb2_tdbquery etc.
Example usage:
tdb2.tdbloader --loc &amp;lt;DB location&amp;gt; file1 file2 ... Note:
tdbloader2 is a TDB1 command tool.
tdb2.tdbloader Basic usage: load files into a database at location &amp;ldquo;DB&amp;rdquo;:</description>
</item>
<item>
<title>TDB2 - Database Administration</title>
<link>https://jena.apache.org/documentation/tdb2/tdb2_admin.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb2/tdb2_admin.html</guid>
<description>TDB2 directory layout A TDB2 database is contained in a directory location DIR as:
DIR/ Backups/ Data-0001/ Data-0002/ tdb.lock where Data-NNNN are the compacted generations of the database. The highest number is the currently live database. The others are not used and not touched by the TDB2 subsystem. They can be deleted, moved elsewhere, or compressed as required. Each is a valid database in it own right.
Backups is the directory used to write backup files.</description>
</item>
<item>
<title>TDB2 - Migration from TDB1</title>
<link>https://jena.apache.org/documentation/tdb2/tdb2_migration.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb2/tdb2_migration.html</guid>
<description>Migrating Data TDB2 is not compatible with TDB1. Data must be reloaded from RDF again.
Migrating Code Simple migration of code is to use TDB2Factory in place of TDBFactory to create datasets. DatasetGraph objects are now created via DatabaseMgr.
Beware that many classes have the same name in TDB1 and TDB2 but are in different packages. The base package name for TDB2 is org.apache.jena.tdb2.
Example code: TDB2Factory
import org.apache.jena.tdb2.TDB2Factory; ... public static void main(String[] args) { Dataset ds = TDB2Factory.</description>
</item>
<item>
<title>TDB2 - Use with Fuseki2</title>
<link>https://jena.apache.org/documentation/tdb2/tdb2_fuseki.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/tdb2/tdb2_fuseki.html</guid>
<description>TDB2 is incorporated into Fuseki2, both in the full server, with UI, and embeddable Fuseki2 main server.
The TDB2 database can be in a configuration file, either a complete server configuration (see below) or as an entry in the FUSEKI_BASE/configuration/ area of the full server.
The command line start-up for Fuseki (both full and basic versions) uses the the --tdb2 flag to modify the --loc argument to work with a TDB2 dataset.</description>
</item>
<item>
<title>The core RDF API</title>
<link>https://jena.apache.org/documentation/rdf/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/rdf/</guid>
<description>This section provides some basic reference notes on the core Jena RDF API. For a more tutorial introduction, please see the tutorials.
Core concepts Graphs, models In Jena, all state information provided by a collection of RDF triples is contained in a data structure called a Model. The model denotes an RDF graph, so called because it contains a collection of RDF nodes, attached to each other by labelled relations. Each relationship goes only in one direction, so the triple:</description>
</item>
<item>
<title>The DatasetGraph hierarchy.</title>
<link>https://jena.apache.org/documentation/notes/datasetgraph.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/datasetgraph.html</guid>
<description>These notes were written February 2016.
DatasetGraph forms the basic of storage as RDFDataset. There is a class hierarchy to make implementation a matter of choosing the style of implementation and adding specific functionality.
The hierarchy of the significant classes is: (there are others adding special features)
DatasetGraph - the interface DatasetGraphBase DatasetGraphBaseFind DatasetGraphCollection DatasetGraphMapLink - ad hoc collection of graphs DatasetGraphOne DatasetGraphTriplesQuads DatasetGraphInMemory - fully transactional in-memory. DatasetGraphMap DatasetGraphQuads DatasetGraphTrackActive - transaction support DatasetGraphTransaction - This is the main TDB dataset.</description>
</item>
<item>
<title>The Jena StreamManager and LocationMapper</title>
<link>https://jena.apache.org/documentation/notes/stream-manager.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/stream-manager.html</guid>
<description>The StreamManager is a utility to find and read files into models. There is a standard global StreamManager and applications may also define specific ones by constructing additional StreamManagers.
The LocationMapper provides alternative locations for RDF data.
The Stream Manager Files are named by a string, according to the conventions of their storage system. Typically this is by URI. There are a number of storage system adapters provided:
File locator (with own current directory) URL locator (HTTP and FTP) Class loader locator Zip file locator The global stream manager has a file location, a URL locator and a class loader (tried in that order).</description>
</item>
<item>
<title>TOC test</title>
<link>https://jena.apache.org/documentation/ontology/toc-test.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/ontology/toc-test.html</guid>
<description>The title above will generate an h1 element from the CMS scripts
{% toc %}
I am the first h2 lorem fubarum
I am the second h2 lorem fubarum
I am the first h3 lorem fubarum
And I&amp;rsquo;m back to h2 lorem fubarum
TOC test The title above will generate an h1 element from the CMS scripts
I am the first h2 I am the second h2 I am the first h3 And I&#39;m back to h2 I am the first h2 lorem fubarum</description>
</item>
<item>
<title>TriX support in Apache Jena</title>
<link>https://jena.apache.org/documentation/io/trix.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/trix.html</guid>
<description>Jena supports TriX, a simple XML format for RDF, for both reading and writing RDF data.
The support is of the TriX core, without processing instructions.
Both the original HPlabs and W3C DTDs are supported for reading. Writing is according to the W3C DTD, that is using root element &amp;lt;trix&amp;gt;, rather than &amp;lt;TriX&amp;gt;.
Note: This format should not be confused with RDF/XML, the W3C standardised XML format for RDF.
TriX History TriX originated from work by Jeremy Carroll (then at HP Labs, Bristol) and Patrick Stickler (then at Nokia) and published as a tech report HPL-2004-56 There is also earlier work published in HPL-2003-268.</description>
</item>
<item>
<title>Tutorial - Manipulando SPARQL usando ARQ</title>
<link>https://jena.apache.org/documentation/query/manipulating_sparql_using_arq_pt.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/manipulating_sparql_using_arq_pt.html</guid>
<description>Quando você começa a trabalhar com SPARQL você rapidamente descobre que queries estáticas são restritivas. Talvez você queira mudar um valor, adicionar um filtro, alterar o limite, etc. Sendo do tipo impaciente, você começa a manipular a string da query e isso funciona. Mas o que dizer de little Bobby Tables? Além do mais, mesmo que você limpe ao máximo suas entradas, manipulação de strings é um processo tenso e erros de sintaxe esperam por você.</description>
</item>
<item>
<title>Tutorial - Manipulating SPARQL using ARQ</title>
<link>https://jena.apache.org/documentation/query/manipulating_sparql_using_arq.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/manipulating_sparql_using_arq.html</guid>
<description>When you&amp;rsquo;ve been working with SPARQL you quickly find that static queries are restrictive. Maybe you want to vary a value, perhaps add a filter, alter the limit, etc etc. Being an impatient sort you dive in to the query string, and it works. But what about little Bobby Tables? And, even if you sanitise your inputs, string manipulation is a fraught process and syntax errors await you. Although it might seem harder than string munging, the ARQ API is your friend in the long run.</description>
</item>
<item>
<title>Txn - A library for working with Transactions</title>
<link>https://jena.apache.org/documentation/txn/txn.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/txn/txn.html</guid>
<description>Txn provides a high level interface to Jena transactions. It is a library over the core functionality - applications do not have to use Txn to use transactions.
Features:
Java8 idioms Application exceptions cause transaction aborts. &amp;ldquo;Transaction continuation&amp;rdquo; - use any existing active transaction. Autocommit - ensure actions are inside a transaction even if none is active. Transactions The basic transactions API provides operations begin, commit, abort and end.</description>
</item>
<item>
<title>Typed literals how-to</title>
<link>https://jena.apache.org/documentation/notes/typed-literals.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/notes/typed-literals.html</guid>
<description>What are typed literals? In the original RDF specifications there were two types of literal values defined - plain literals (which are basically strings with an optional language tag) and XML literals (which are more or less plain literals plus a &amp;ldquo;well-formed-xml&amp;rdquo; flag).
Part of the remit for the 2001 RDF Core working group was to add to RDF support for typed values, i.e. things like numbers. These notes describe the support for typed literals in Jena2.</description>
</item>
<item>
<title>Using ARP Without Jena</title>
<link>https://jena.apache.org/documentation/io/arp_standalone.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/arp_standalone.html</guid>
<description>ARP can be used both as a Jena subsystem, or as a standalone RDF/XML parser. This document gives a quick guide to using ARP standalone.
Contents Overview Sample Code ARP Event Handling Configuring ARP Interrupting ARP Using Other SAX Sources Memory usage Overview To load an RDF file:
Create an ARP instance. Set parse options, particularly error detection control, using getOptions or setOptionsWith. Set its handlers, by calling the getHandlers or setHandlersWith methods, and then.</description>
</item>
<item>
<title>Working with RDF Streams in Apache Jena</title>
<link>https://jena.apache.org/documentation/io/streaming-io.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/streaming-io.html</guid>
<description>Jena has operations useful in processing RDF in a streaming fashion. Streaming can be used for manipulating RDF at scale. Jena provides high performance readers and writers for all standard RDF formats, and it can be extended with custom formats.
The RDF Binary provides the highest input parsing performance. N-Triples/N-Quads provide the highest input parsing performance using W3C Standards.
Files ending in .gz are assumed to be gzip-compressed. Input and output to such files takes this into account, including looking for the other file extension.</description>
</item>
<item>
<title>Writing RDF in Apache Jena</title>
<link>https://jena.apache.org/documentation/io/rdf-output.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/rdf-output.html</guid>
<description>This page describes the RIOT (RDF I/O technology) output capabilities.
See Reading RDF for details of the RIOT Reader system.
API RDFFormat RDFFormats and Jena syntax names Formats Normal Printing Pretty Printed Languages Streamed Block Formats Line printed formats Turtle and Trig format options N-Triples and N-Quads JSON-LD RDF Binary RDF/XML Examples Notes See Advanced RDF/XML Output for details of the Jena RDF/XML writer.
API There are two ways to write RDF data using Apache Jena RIOT, either via the RDFDataMgr</description>
</item>
</channel>
</rss>