blob: 12af179ba2c075765847a0af72bbaf99015f9c08 [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>Tutorials on Apache Jena</title>
<link>https://jena.apache.org/tutorials.html</link>
<description>Recent content in Tutorials on Apache Jena</description>
<generator>Hugo -- gohugo.io</generator>
<language>en</language><atom:link href="https://jena.apache.org/tutorials/index.xml" rel="self" type="application/rss+xml" />
<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>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>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>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 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;quot;John Smith&amp;quot; } 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 um 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>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;quot;John Smith&amp;quot; } 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>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 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>
</channel>
</rss>