blob: 55460f71b48c4ad5b0816d5b8d38a68fac921cab [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>Home on Apache Jena</title>
<link>https://jena.apache.org/</link>
<description>Recent content in Home on Apache Jena</description>
<generator>Hugo -- gohugo.io</generator>
<language>en</language><atom:link href="https://jena.apache.org/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>Alternativas num padrão</title>
<link>https://jena.apache.org/tutorials/sparql_union_pt.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_union_pt.html</guid>
<description>Outra forma de lidar com dado semiestruturado é consultar uma de um número de possibilidades. Essa sessão cobre O padrão UNION, onde uma de um número de possibilidades é testado.
UNION - duas maneiras para o mesmo dado Ambos os vocabulários de vcard e de FOAF possuem propriedades para nome de pessoas. Em vcard, é vcard:FN, o nome formatado, e em FOAF, é foaf:name. Nesta sessão, vamos olhar um pequeno conjunto de dados onde o nome das pessoas podem ser dados por ambos os vocabulários de FOAF e vcard.</description>
</item>
<item>
<title>An Introduction to RDF and the Jena RDF API</title>
<link>https://jena.apache.org/tutorials/rdf_api.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/rdf_api.html</guid>
<description>Preface This is a tutorial introduction to both W3C&amp;rsquo;s Resource Description Framework (RDF) and Jena, a Java API for RDF. It is written for the programmer who is unfamiliar with RDF and who learns best by prototyping, or, for other reasons, wishes to move quickly to implementation. Some familiarity with both XML and Java is assumed.
Implementing too quickly, without first understanding the RDF data model, leads to frustration and disappointment.</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 an operating system service, as a Java web application (WAR file), and as a standalone server.
Fuseki comes 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 an 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. During Jena initialization, there can be visibility of uninitialized data in class static members.
The standard initialization sequence is
Core -&amp;gt; RIOT -&amp;gt; ARQ -&amp;gt; TDB -&amp;gt; other (including jena text)
The sequence from 0 to level 500 is the Jena platform initialization.</description>
</item>
<item>
<title>Apache Jena project team members</title>
<link>https://jena.apache.org/about_jena/team.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/about_jena/team.html</guid>
<description>In first name alphabetical order:
Aaron Coburn (acoburn) C Adam Soroka (ajs6f) CP Andy Seaborne (andy) CP VP Bruno Kinoshita (kinow) CP Chris Dollin (chrisdollin) CP Chris Tomlinson (codeferret) CP Claude Warren (claude) CP Damian Steer (damian) CP Dave Reynolds (der) CP Ian Dickinson (ijd) CP Lorenz Buehmann (lbuehmann) C Osma Suominen (osma) CP Paolo Castagna (castagna) CP Rob Vesse (rvesse) CP Stephen Allen (sallen) CP Ying Jiang (jpz6311whu) C Emeritus and Mentors:</description>
</item>
<item>
<title>Apache Jena Releases</title>
<link>https://jena.apache.org/download/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/download/</guid>
<description>Apache Jena is packaged as downloads which contain the most commonly used portions of the systems:
apache-jena – contains the APIs, SPARQL engine, the TDB native RDF database and command line tools apache-jena-fuseki – the Jena SPARQL server Jena5 requires Java 17.
Jena jars are available from Maven.
You may verify the authenticity of artifacts below by using the PGP KEYS file.
Apache Jena Release Source release: this forms the official release of Apache Jena.</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 Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0. 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.
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.
Command line The command shex introduces ShEx operations; it takes a sub-command argument.
To validate:
shex validate --schema SCHEMA.shex --map MAP.</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,
API GPI RDFConnection RDFLink QueryExecution QueryExec UpdateExecution UpdateExec ResultSet RowSet ModelStore GSP ModelStore DSP Jena provides a single interface, RDFConnection for working with local and remote RDF data using these protocols in a unified way.</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 - Custom Service Executors</title>
<link>https://jena.apache.org/documentation/query/custom_service_executors.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/custom_service_executors.html</guid>
<description>Since Jena 4.2.0, ARQ features a plugin system for custom service executors. The relevant classes are located in the package org.apache.jena.sparql.service and are summarized as follows:
ServiceExecutorRegistry: A registry that holds a list of service executors. When Jena starts up, it configures a default registry to handle SERVICE requests against HTTP SPARQL endpoints and registers it with the global ARQ context accessible under ARQ.getContext().
ServiceExecutorFactory: This is the main interface for custom SERVICE handler implementations:</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 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.
Applications should be aware that there are risks in exposing a script engine with full computational capabilities through SPARQL.</description>
</item>
<item>
<title>ARQ - Lateral Join</title>
<link>https://jena.apache.org/documentation/query/lateral-join.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/lateral-join.html</guid>
<description>Lateral joins using the keyword LATERAL were introduced in Apache Jena 4.7.0.
A LATERAL join is like a foreach loop, looping on the results from the left-hand side (LHS), the pattern before the LATERAL keyword, and executing the right-hand side (RHS) query pattern once for each row, with the variables from the input LHS in-scope during each RHS evaluation.
A regular join only executes the RHS once, and the variables from the LHS are used for the join condition after evaluation of the left and right sub-patterns.</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;rdquo;.
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 – 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>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>Citing Jena</title>
<link>https://jena.apache.org/about_jena/citing.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/about_jena/citing.html</guid>
<description>The name of the project is “Apache Jena”. That should appear as the first use in a paper and in a reference. After that &amp;ldquo;Jena&amp;rdquo; can be used. It is also a trademark of the Apache Software Foundation. This is also the industry practice.
The reference should indicate the website https://jena.apache.org/ (https is preferable). If relevant to reproducibility, or discussing performance, the release version number MUST also be included. The date of access would also be helpful to the reader.</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. Applications can write and register their own functions.</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>Frequently asked questions</title>
<link>https://jena.apache.org/help_and_support/faq.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/help_and_support/faq.html</guid>
<description></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:
Dataset ds = .</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.apache.jena.fuseki.Config Configuration NCSA request Log This log is in NCSA extended/combined log format.
Many web log analysers can process this format.</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. A 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. It is an experimental feature that will evolve based on feedback and use cases.
The interface for modules is FusekiModule; if automatcally loaded, the interface is FusekiAutoModule which extends FusekiModule.</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 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 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 provided 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>Getting help with Jena</title>
<link>https://jena.apache.org/help_and_support/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/help_and_support/</guid>
<description>We are always happy to help you get your Jena project going. Jena has been around for many years, there are many archives of past questions, tutorials and articles on the web. A quick search may well answer your question directly! If not, please feel free to post a question to the user support list (details below).
Email support lists The main user support list is users@jena.apache.org. To join this list, please send an email to: users-subscribe@jena.</description>
</item>
<item>
<title>Getting involved in Apache Jena</title>
<link>https://jena.apache.org/getting_involved/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/getting_involved/</guid>
<description>We welcome your contribution towards making Jena a better platform for semantic web and linked data applications. We appreciate feature suggestions, bug reports and patches for code or documentation.
If you need help using Jena, please see our getting help page.
How to contribute You can help us sending your suggestions, feature requests and bug reports (as well as patches) using Jena&amp;rsquo;s GitHub Issues.
You can discuss your contribution on the dev@jena.</description>
</item>
<item>
<title>Getting started with Apache Jena</title>
<link>https://jena.apache.org/getting_started/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/getting_started/</guid>
<description>Apache Jena (or Jena in short) is a free and open source Java framework for building semantic web and Linked Data applications. The framework is composed of different APIs interacting together to process RDF data. If you are new here, you might want to get started by following one of the tutorials. You can also browse the documentation if you are interested in a particular topic.
Tutorials RDF API tutorial - you will learn the essence of the semantic web and the graph representation behind RDF.</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.
API use A new instance of the class is obtained by a call to DatasetFactory.createTxnMem():
Dataset ds = DatasetFactory.createTxnMem() ; This can then be used by the application for reading:</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 architecture overview</title>
<link>https://jena.apache.org/about_jena/architecture.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/about_jena/architecture.html</guid>
<description>There&amp;rsquo;s quite a lot of code inside Jena, and it can be daunting for new Jena users to find their way around. On this page we&amp;rsquo;ll summarise the key features and interfaces in Jena, as a general overview and guide to the more detailed documentation.
At its core, Jena stores information as RDF triples in directed graphs, and allows your code to add, remove, manipulate, store and publish that information. We tend to think of Jena as a number of major subsystems with clearly defined interfaces between them.</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 Bulk retrieval and caching with SERVICE clauses 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;rdquo;. 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.hpl.hp.com/Eyeball\#.</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.2.13 3.10.0 7.4.0 not supported 6.4.2 3.15.0 - 3.17.0 7.7.x not supported 6.8.6 4.0.0 - 4.6.1 8.</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 Fuseki JavaDoc Fuseki2 Webapp Fuseki2 Main ARQ(SPARQL) RDF Connection TDB Text search SHACL ShEx RDF Patch GeoSPARQL Query Builder Service Enhancer Security Permissions 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 will be removed in Jena5.
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. One against which the security evaluator is running access checks.</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;rdquo;) and the authorization (answers the question: &amp;ldquo;what can you do?&amp;rdquo;), 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>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() .addVar( &amp;#34;*&amp;#34; ) .</description>
</item>
<item>
<title>Jena RDF XML</title>
<link>https://jena.apache.org/documentation/io/rdfxml-io.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/rdfxml-io.html</guid>
<description>RDF/XML Input RDF/XML Output RDF/XML Input The RIOT RDF/XML parser is called RRX.
The ARP RDF/XML parser is stil available but wil be rmoved from Apache Jena.
Legacy ARP RDF/XML input RDF/XML Output Two forms for output are provided:
The default output Lang.RDFXML, historically called &amp;ldquo;RDF/XML-ABBREV&amp;rdquo;, which also has a format name RDFFormat.RDFXML_PRETTY. It produces readable output. It requires working memory to analyse the data to be written and it is not streaming.</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>Legacy Documentation : may not be up-to-date
The original ARQ parser will be removed from Jena. * 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.
Other content related to Jena RDF/XML How-To includes:
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 RDF/XML Input How-To (ARP)</title>
<link>https://jena.apache.org/documentation/io/rdfxml-input.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/rdfxml-input.html</guid>
<description>Legacy Documentation : not up-to-date
The original ARP parser will be removed from Jena.
The current RDF/XML parser is RRX.
This is a guide to the RDF/XML legacy ARP input subsystem of Jena.
The ARP RDF/XML parser is designed for use with RIOT and to have the same handling of errors, IRI resolution, and treatment of base IRIs as other RIOT readers.
The ARP0 parser is the original standalone parser.</description>
</item>
<item>
<title>Jena RDF/XML Output How-To</title>
<link>https://jena.apache.org/documentation/io/rdfxml-output.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/rdfxml-output.html</guid>
<description>Advanced RDF/XML Output Two forms for output are provided: pretty printed RDF/XML (&amp;ldquo;RDF/XML-ABBREV&amp;rdquo;) or plain RDF/XML
While some of the code is shared, these two writers are really very different, resulting in different but equivalent RDF output. &amp;ldquo;RDF/XML-ABBREV&amp;rdquo; is slower, but should produce more readable XML.
Properties to Control RDF/XML Output Property NameDescriptionValue classLegal Values xmlbase The value to be included for an xml:base attribute on the root element in the file.</description>
</item>
<item>
<title>Jena Roadmap</title>
<link>https://jena.apache.org/about_jena/roadmap.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/about_jena/roadmap.html</guid>
<description>You can view a list of the open issues on Github.
Pull requests, patches and other contributions welcome!</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 Security Advisories</title>
<link>https://jena.apache.org/about_jena/security-advisories.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/about_jena/security-advisories.html</guid>
<description>The Jena project has issued a number of security advisories during the lifetime of the project. On this page you&amp;rsquo;ll find details of our security issue process, as a listing of our past CVEs and relevant Dependency CVEs.
Process Jena follows the standard ASF Security for Committers policy for reporting and addressing security issues.
If you think you have identified a Security issue in our project please refer to that policy for how to report it, and the process that the Jena Project Management Committee (PMC) will follow in addressing the issue.</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>Jena tutorials</title>
<link>https://jena.apache.org/tutorials/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/</guid>
<description>The following tutorials take a step-by-step approach to explaining aspects of RDF and linked-data applications programming in Jena. For a more task-oriented description, please see the getting started guide.
RDF core API tutorial SPARQL tutorial Using Jena with Eclipse Manipulating SPARQL using ARQ Jena tutorials in other languages Quelques uns des tutoriels de Jena sont aussi disponibles en français. Vous pouvez les voir en suivant ces liens:
Une introduction à RDF Requêtes SPARQL utilisant l&amp;rsquo;API Java ARQ Les entrées/sorties RDF Une introduction à SPARQL Os tutoriais a seguir explicam aspectos de RDF e da programação em Jena de aplicações linked-data.</description>
</item>
<item>
<title>Jena-related projects and tools</title>
<link>https://jena.apache.org/about_jena/contributions.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/about_jena/contributions.html</guid>
<description>This page lists various projects and tools related to Jena - classes, packages, libraries, applications, or ontologies that enhance Jena or are built on top of it. These projects are not part of the Jena project itself, but may be useful to Jena users.
This list is provided for information purposes only, and is not meant as an endorsement of the mentioned projects by the Jena team.
If you wish your contribution to appear on this page, please raise a GitHub issue with the details to be published.</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>Producing Result Sets</title>
<link>https://jena.apache.org/tutorials/sparql_results.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_results.html</guid>
<description>SPARQL has four result forms:
SELECT – Return a table of results. CONSTRUCT – Return an RDF graph, based on a template in the query. DESCRIBE – Return an RDF graph, based on what the query processor is configured to return. ASK – Ask a boolean query. The SELECT form directly returns a table of solutions as a result set, while DESCRIBE and CONSTRUCT use the outcome of matching to build RDF graphs.</description>
</item>
<item>
<title>Produzindo resultados</title>
<link>https://jena.apache.org/tutorials/sparql_results_pt.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_results_pt.html</guid>
<description>SPARQL tem quatro formas de se obter resultados:
SELECT – Retorna uma tabela de resultados. CONSTRUCT – Retorna um grafo RDF, baseado num template da consulta. DESCRIBE – Retorna um grafo RDF, baseado no quê o processador está configurado para retornar. ASK – Faz uma consulta booleana. A forma SELECT, diretamente, retorna uma tabela de soluções como conjunto de resultados, enquanto que DESCRIBE e CONSTRUCT o resultado da consulta para montar um grafo RDF.</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. It provides support for try-resource and functional code passing styles, as well the more basic sequence of methods calls.</description>
</item>
<item>
<title>RDF Patch</title>
<link>https://jena.apache.org/documentation/rdf-patch/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/rdf-patch/</guid>
<description>This page describes RDF Patch. An RDF Patch is a set of changes to an RDF dataset. The change are for triples, quads and prefixes.
Changes to triples involving blank nodes are handled by using their system identifier which uniquely identifies a blank node. Unlike RDF syntaxes, blank nodes are not generated afresh each time the document is parsed.
Example This example ensures certain prefixes are in the dataset and adds some basic triples for a new subclass of &amp;lt;http://example/SUPER_CLASS&amp;gt;.</description>
</item>
<item>
<title>RDF/XML Input in Jena</title>
<link>https://jena.apache.org/documentation/io/arp/arp.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/arp/arp.html</guid>
<description>Legacy Documentation : not up-to-date
The original ARP parser will be removed from Jena
The current RDF/XML parser is RRX.
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</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 Formats The following RDF formats are supported by Jena. In addition, other syntaxes can be integrated into both the parser and writer registries.
Turtle JSON-LD N-Triples N-Quads TriG RDF/XML TriX RDF/JSON 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>Reification API support will be removed in Jena5.
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.</description>
</item>
<item>
<title>Reification styles (archive material)</title>
<link>https://jena.apache.org/documentation/archive/reification_previous.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/archive/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>Reporting bugs and making suggestions</title>
<link>https://jena.apache.org/help_and_support/bugs_and_suggestions.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/help_and_support/bugs_and_suggestions.html</guid>
<description>Please report bugs using Jena&amp;rsquo;s GitHub Issues. General suggestions or requests for changes can also be discussed on the user list or Jena&amp;rsquo;s GitHub Discussions but are less likely to be accidentally forgotten if you log them in a GitHub Issue.
For any security issues please refer to our Security Advisories page for how those should be reported and handled.
Patches and other code contributions are made via git pull requests.</description>
</item>
<item>
<title>Reviewing Contributions</title>
<link>https://jena.apache.org/getting_involved/reviewing_contributions.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/getting_involved/reviewing_contributions.html</guid>
<description>This page details how to review contributions submitted for Apache Jena, it is intended primarily for Jena committers but is also useful in helping contributors understand what we expect from a contribution.
Patch Guidelines When reviewing contributed patches to Jena the committers are going to be considered the following:
Does the pull request includes tests? Does the pull request includes documentation? Does it have Apache copyright headers? Are there any @author tags?</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/arp_sax.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/arp/arp_sax.html</guid>
<description>Legacy Documentation : not up-to-date
The original ARQ parser will be removed from Jena
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.</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>The Apache Jena SDB module has been retired and no longer supported. The last release of Jena with this module is Jena 3.17.0.
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.</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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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.
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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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.</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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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.</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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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).</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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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.</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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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:</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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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.</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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
This page describes how to use SDB from Java.
Code examples are in src-examples/ in the SDB distribution.
Concepts Store SDBFactory SDBConnection SDB loads and queries data based on the unit of a Store. The Store object has all the information for formatting, loading and accessing an SDB database.</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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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:</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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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.</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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
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.</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>The Apache Jena SDB module has been retired and is no longer supported. The last release of Jena with this module was Apache Jena 3.17.0.
This page describes the command line programs that can be used to create an SDB store, load data into it and to issue queries.
Scripts The directory bin/ contains shell scripts to run the commands from the command line. The scripts are bash scripts which also run over Cygwin.</description>
</item>
<item>
<title>Search Results</title>
<link>https://jena.apache.org/search/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/search/</guid>
<description></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>Service Enhancer</title>
<link>https://jena.apache.org/documentation/query/service_enhancer.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/query/service_enhancer.html</guid>
<description>The service enhancer (SE) plugin extends the functionality of the SERVICE clause with:
Bulk requests Correlated joins also known as lateral joins A streaming cache for SERVICE requests results which can also cope with bulk requests and correlated joins. Furthermore, queries that only differ in limit and offset will result in cache hits for overlapping ranges. At present, the plugin only ships with an in-memory cache provider. As a fundamental principle, a request making use of cache and bulk should return the exact same result as if those settings were omitted.</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 page</title>
<link>https://jena.apache.org/tutorials/sparql_page.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_page.html</guid>
<description>PAGE This section covers &amp;hellip;
Next: @@</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.
Need The SPARQL algebra defines the semantics of a SPARQL graph pattern. Every SPARQL query string (the syntax) is mapped to a SPARQL algebra expression.
It is convenient to be able to print out such algebra expressions for discussion between people and for debugging. Further, if algebra expressions can be read back in as well, testing of specific parts of an implementation is also easier.</description>
</item>
<item>
<title>SPARQL Tutorial</title>
<link>https://jena.apache.org/tutorials/sparql.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql.html</guid>
<description>The objective of this SPARQL tutorial is to give a fast course in SPARQL. The tutorial covers the major features of the query language through examples but does not aim to be complete.
If you are looking for a short introduction to SPARQL and Jena try Search RDF data with SPARQL. If you are looking to execute SPARQL queries in code and already known SPARQL then you likely want to read the ARQ Documentation instead.</description>
</item>
<item>
<title>SPARQL Tutorial - A First SPARQL Query</title>
<link>https://jena.apache.org/tutorials/sparql_query1.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_query1.html</guid>
<description>In this section, we look at a simple first query and show how to execute it with Jena.
A &amp;ldquo;hello world&amp;rdquo; of queries The file &amp;ldquo;q1.rq&amp;rdquo; contains the following query:
SELECT ?x WHERE { ?x &amp;lt;http://www.w3.org/2001/vcard-rdf/3.0#FN&amp;gt; &amp;#34;John Smith&amp;#34; } executing that query with the command line query application;
--------------------------------- | x | ================================= | &amp;lt;http://somewhere/JohnSmith/&amp;gt; | --------------------------------- This works by matching the triple pattern in the WHERE clause against the triples in the RDF graph.</description>
</item>
<item>
<title>SPARQL Tutorial - Alternatives in a Pattern</title>
<link>https://jena.apache.org/tutorials/sparql_union.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_union.html</guid>
<description>Another way of dealing with the semi-structured data is to query for one of a number of possibilities. This section covers UNION patterns, where one of a number of possibilities is tried.
UNION - two ways to the same data Both the vCard vocabulary and the FOAF vocabulary have properties for people&amp;rsquo;s names. In vCard, it is vCard:FN, the &amp;ldquo;formatted name&amp;rdquo;, and in FOAF, it is foaf:name. In this section, we will look at a small set of data where the names of people can be given by either the FOAF or the vCard vocabulary.</description>
</item>
<item>
<title>SPARQL Tutorial - Basic Patterns</title>
<link>https://jena.apache.org/tutorials/sparql_basic_patterns.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_basic_patterns.html</guid>
<description>This section covers basic patterns and solutions, the main building blocks of SPARQL queries.
Solutions Query solutions are a set of pairs of a variable name with a value. A SELECT query directly exposes the solutions (after order/limit/offset are applied) as the result set - other query forms use the solutions to make a graph. The solution is the way the pattern matched - which values the variables must take for a pattern to match.</description>
</item>
<item>
<title>SPARQL Tutorial - Data Formats</title>
<link>https://jena.apache.org/tutorials/sparql_data.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_data.html</guid>
<description>First, we need to be clear about what data is being queried. SPARQL queries RDF graphs. An RDF graph is a set of triples (Jena calls RDF graphs &amp;ldquo;models&amp;rdquo; and triples &amp;ldquo;statements&amp;rdquo; because that is what they were called at the time the Jena API was first designed).
It is important to realize that it is the triples that matter, not the serialization. The serialization is just a way to write the triples down.</description>
</item>
<item>
<title>SPARQL Tutorial - Datasets</title>
<link>https://jena.apache.org/tutorials/sparql_datasets.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_datasets.html</guid>
<description>This section covers RDF Datasets - an RDF Dataset is the unit that is queried by a SPARQL query. It consists of a default graph, and a number of named graphs.
Querying datasets The graph matching operation (basic patterns, OPTIONALs, and UNIONs) work on one RDF graph. This starts out being the default graph of the dataset but it can be changed by the GRAPH keyword.
GRAPH uri { ... pattern .</description>
</item>
<item>
<title>SPARQL Tutorial - Datasets</title>
<link>https://jena.apache.org/tutorials/sparql_datasets_pt.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_datasets_pt.html</guid>
<description>Essa sessão cobre datasets RDF – um dataset RDF é a unidade consultada por uma consulta SPARQL. Ele consiste de um grafo padrão, e certo número de grafos nomeados.
Consultando datasets As operações de casamento de grafos (padrões básicos, OPTIONALs, e UNIONs) funcionam em um grafo RDF. Isso começa por ser o grafo padrão do conjunto de dados, mas pode ser alterado pela palavra-chave GRAPH. GRAPH uri { &amp;hellip; padrão &amp;hellip; }</description>
</item>
<item>
<title>SPARQL Tutorial - Filters</title>
<link>https://jena.apache.org/tutorials/sparql_filters.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_filters.html</guid>
<description>Graph matching allows patterns in the graph to be found. This section describes how the values in a solution can be restricted. There are many comparisons available - we just cover two cases here.
String Matching SPARQL provides an operation to test strings, based on regular expressions. This includes the ability to ask SQL &amp;ldquo;LIKE&amp;rdquo; style tests, although the syntax of the regular expression is different from SQL.
The syntax is:</description>
</item>
<item>
<title>SPARQL Tutorial - Optional Information</title>
<link>https://jena.apache.org/tutorials/sparql_optionals.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_optionals.html</guid>
<description>RDF is semi-structured data so SPARQL has a the ability to query for data but not to fail query when that data does not exist. The query is using an optional part to extend the information found in a query solution but to return the non-optional information anyway.
OPTIONALs This query (q-opt1.rq) gets the name of a person and also their age if that piece of information is available.
PREFIX info: &amp;lt;http://somewhere/peopleInfo#&amp;gt; PREFIX vcard: &amp;lt;http://www.</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;rdquo;.
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; :john foaf: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;.</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.
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>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. See the downloads page for details on getting the latest Jena release.
Scripts From the location The directory bin/ contains shell scripts to run the commands from the command line.</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.
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.
There is a global context, which is give to each query execution as it is created. Modifications to the global context after the query execution is created are not seen by the query execution.</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.
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. Models and datasets should be closed after use.</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.
Overview TDB2 uses MVCC via a copy-on-write mechanism. Update transactions can be of any size.
The TDB1 transaction mechanism 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 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 tdb2.tdbstats 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 --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>Tutorial SPARQL</title>
<link>https://jena.apache.org/tutorials/sparql_pt.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_pt.html</guid>
<description>O objetivo deste tutorial é dar um curso rápido sobre SPARQL. Esse tutorial cobre os principais aspectos desta linguagem de consulta através de exemplos, mas não tem como objetivo ser completo.
Se você estiver procurando uma pequena introdução a SPARQL e Jena, experimente Search RDF data with SPARQL. Se você quer executar consultas SPARQL e já sabe como ele funciona, então você deveria ler a ARQ Documentation.
SPARQL é uma linguagem de consulta e um protocolo para acesso a RDF elaborado pelo W3C RDF Data Access Working Group.</description>
</item>
<item>
<title>Tutorial SPARQL - A primeira consulta SPARQL</title>
<link>https://jena.apache.org/tutorials/sparql_query1_pt.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_query1_pt.html</guid>
<description>Nesta sessão, vamos olhar para a primeira consulta simples e mostrar como executá-la em Jena.
O &amp;ldquo;hello world&amp;rdquo; de consultas O arquivo &amp;ldquo;q1.rq&amp;rdquo; contem a seguinte consulta:
SELECT ?x WHERE { ?x &amp;lt;http://www.w3.org/2001/vcard-rdf/3.0#FN&amp;gt; &amp;#34;John Smith&amp;#34; } executando esta consulta com a aplicação de consultas em linhas de comando:
--------------------------------- | x | ================================= | &amp;lt;http://somewhere/JohnSmith/&amp;gt; | --------------------------------- Isso funciona casando o padrão da tripla na clausula WHERE contra as triplas no grafo RDF.</description>
</item>
<item>
<title>Tutorial SPARQL - Formato de Dados</title>
<link>https://jena.apache.org/tutorials/sparql_data_pt.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_data_pt.html</guid>
<description>Primeiro, nós precisamos esclarecer quais dados estão sendo consultados. SPARQL consulta grafos RDF. Um grafo RDF é um conjunto de triplas (Jena chama os grafos de modelos e as triplas de sentenças porque assim eram chamadas quando a API foi elaborada inicialmente).
É importante perceber que o que importa são as triplas, e não a serialização. A serialização é apenas uma maneira de escrever as triplas. RDF/XML é uma recomendação da W3C, mas isso pode dificultar a visão das triplas porque há múltiplas formas de codificar o mesmo grafo.</description>
</item>
<item>
<title>Tutorial SPARQL - Informações Opcionais</title>
<link>https://jena.apache.org/tutorials/sparql_optionals_pt.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_optionals_pt.html</guid>
<description>RDF é dado semi-estruturado então SPARQL tem a habilidade de consultá-lo, mas não para falhar quando o dado não existe. A consulta usa uma parte opcional para extender a informação encontrada na solução de uma consulta, mas para retornar a informação não opcional de qualquer maneira.
OPICIONAIS Essa consulta (q-opt1.rq) pega o nome da pessoa e também sua idade se essa informação estiver disponível.
PREFIX info: &amp;lt;http://somewhere/peopleInfo#&amp;gt; PREFIX vcard: &amp;lt;http://www.w3.org/2001/vcard-rdf/3.0#&amp;gt; SELECT ?</description>
</item>
<item>
<title>Tutorial SPARQL – Filtros</title>
<link>https://jena.apache.org/tutorials/sparql_filters_pt.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_filters_pt.html</guid>
<description>Casamento em Grafos permite que sejam encontrados padrões no grafo. Essa seção descreve como os valores numa solução podem ser restritas. Há muitas comparações disponíveis – vamos apenas cobrir dois casos destes.
Casamento de Strings SPARQL fornece uma operação para testar strings, baseada em expressões regulares. Isso inclui a habilidade de testes como SQL &amp;ldquo;LIKE&amp;rdquo;, no entanto, a sintaxe de expressões regulares é diferente de SQL.
A sintaxe é:
FILTER regex(?</description>
</item>
<item>
<title>Tutorial SPARQL – Padrões Básicos</title>
<link>https://jena.apache.org/tutorials/sparql_basic_patterns_pt.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/sparql_basic_patterns_pt.html</guid>
<description>Esta sessão cobre os padrões básicos e as soluções, os principais blocos das consultas SPARQL.
Soluções Soluções são um conjunto de pares de variáveis com um valor. Uma consulta SELECT expõe diretamente as soluções (depois de ordenar/limitar/deslocar) como o conjunto resultado – outras formas de consulta usam as soluções para fazer um grafo. Solução é a maneira como o padrão é casado – em que os valores das variáveis são utilizados para casar com o padrão.</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.
A write transaction looks like:</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>Uma Introdução a RDF e à API RDF de Jena</title>
<link>https://jena.apache.org/tutorials/rdf_api_pt.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/rdf_api_pt.html</guid>
<description>Prefácio Este é um tutorial introdutório ao framework de descrição de recursos (RDF) e Jena, uma API Java para RDF. Ele é escrito para programadores que não estão familiarizados com RDF e que aprendem melhor através de prototipagem, ou, por outros motivos, desejam avançar rapidamente para a implementação. Familiaridade com XML e Java é assumido.
Avançar direto para a implementação, sem conhecer inicialmente o modelo de dados de RDF, levará à frustração e ao desapontamento.</description>
</item>
<item>
<title>Usando o Jena com o Eclipse</title>
<link>https://jena.apache.org/tutorials/using_jena_with_eclipse_pt.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/using_jena_with_eclipse_pt.html</guid>
<description>Este tutorial mostrará como importar o projeto do Jena no Eclipse. A versão do Eclipse utilizada foi 4.7.0, e do Java foi 1.8.0_121. O sistema operacional não deve ser um problema, entã os ũnicos requisitos são Eclipse, Java 1.8.x, e git para baixar o código-fonte do Jena.
Configurando seu ambiente O primeiro passo é instalar o Java JDK 1.8.x. As instruções para a instalação variam dependendo do sistema operacional, e não serão abordadas neste tutorial.</description>
</item>
<item>
<title>Using ARP Without Jena</title>
<link>https://jena.apache.org/documentation/io/arp/arp_standalone.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/documentation/io/arp/arp_standalone.html</guid>
<description>Legacy Documentation : not up-to-date
The original ARQ parser will be removed from Jena.
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.
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>Using Jena with Apache Maven</title>
<link>https://jena.apache.org/download/maven.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/download/maven.html</guid>
<description>Apache Maven is a tool to help Java projects manage their dependencies on library code, such as Jena. By declaring a dependency on the core of Jena in your project&amp;rsquo;s pom.xml file, you will get the consistent set of library files that Jena depends on automatically added too.
This page assumes you have Maven installed on your computer. If this is not the case, please read and follow these instructions.</description>
</item>
<item>
<title>Using Jena with Eclipse</title>
<link>https://jena.apache.org/tutorials/using_jena_with_eclipse.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/tutorials/using_jena_with_eclipse.html</guid>
<description>This tutorial will guide you to set up Jena on your Eclipse. At the time of writing, the latest version of Eclipse is 4.7.0. The version of Java used for this tutorial was Java 1.8.0_121. The operational system should not be a problem, so the only requirements are Eclipse, Java 1.8.x, and git to checkout the Jena source code.
Setting up your environment The first thing you will need to install is a Java JDK 1.</description>
</item>
<item>
<title>Welcome to Apache Jena</title>
<link>https://jena.apache.org/about_jena/</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/about_jena/</guid>
<description>Welcome to the Apache Jena project! Jena is a Java framework for building Semantic Web applications. Jena provides a collection of tools and Java libraries to help you to develop semantic web and linked-data apps, tools and servers.
The Jena Framework includes:
an API for reading, processing and writing RDF data in XML, N-triples and Turtle formats; an ontology API for handling OWL and RDFS ontologies; a rule-based inference engine for reasoning with RDF and OWL data sources; stores to allow large numbers of RDF triples to be efficiently stored on disk; a query engine compliant with the latest SPARQL specification servers to allow RDF data to be published to other applications using a variety of protocols, including SPARQL In April 2012, Jena graduated from the Apache incubator process and was approved as a top-level Apache project.</description>
</item>
<item>
<title>What is Jena?</title>
<link>https://jena.apache.org/about_jena/about.html</link>
<pubDate>Mon, 01 Jan 0001 00:00:00 +0000</pubDate>
<guid>https://jena.apache.org/about_jena/about.html</guid>
<description>Jena is a Java framework for building Semantic Web applications. It provides an extensive Java libraries for helping developers develop code that handles RDF, RDFS, RDFa, OWL and SPARQL in line with published W3C recommendations. Jena includes a rule-based inference engine to perform reasoning based on OWL and RDFS ontologies, and a variety of storage strategies to store RDF triples in memory or on disk.
History Jena was originally developed by researchers in HP Labs, starting in Bristol, UK, in 2000.</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 API There are two ways to write RDF data using Apache Jena RIOT, either via the RDFDataMgr</description>
</item>
</channel>
</rss>