You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@jena.apache.org by bu...@apache.org on 2013/01/22 20:23:13 UTC
svn commit: r847573 - in /websites/staging/jena/trunk/content: ./
documentation/query/manipulating_sparql_using_arq_pt.html
tutorials/index.html tutorials/sparql_pt.html
Author: buildbot
Date: Tue Jan 22 19:23:12 2013
New Revision: 847573
Log:
Staging update by buildbot for jena
Added:
websites/staging/jena/trunk/content/documentation/query/manipulating_sparql_using_arq_pt.html
Modified:
websites/staging/jena/trunk/content/ (props changed)
websites/staging/jena/trunk/content/tutorials/index.html
websites/staging/jena/trunk/content/tutorials/sparql_pt.html
Propchange: websites/staging/jena/trunk/content/
------------------------------------------------------------------------------
--- cms:source-revision (original)
+++ cms:source-revision Tue Jan 22 19:23:12 2013
@@ -1 +1 @@
-1435555
+1437111
Added: websites/staging/jena/trunk/content/documentation/query/manipulating_sparql_using_arq_pt.html
==============================================================================
--- websites/staging/jena/trunk/content/documentation/query/manipulating_sparql_using_arq_pt.html (added)
+++ websites/staging/jena/trunk/content/documentation/query/manipulating_sparql_using_arq_pt.html Tue Jan 22 19:23:12 2013
@@ -0,0 +1,344 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+<head>
+<!--
+
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements. See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License. You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE- 2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+ <link href="/css/jena.css" rel="stylesheet" type="text/css">
+
+ <title>Apache Jena - Tutorial - Manipulando SPARQL usando ARQ</title>
+ <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+ <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js" type="text/javascript"></script>
+ <script src="/js/jena-navigation.js" type="text/javascript"></script>
+</head>
+
+<body>
+ <div id="header">
+ <div id="logoblock">
+ <img alt="Apache Jena" src="/images/jena-logo/jena-logo-small.png"/>
+ </div>
+
+ <div id="titleblock">
+ <h1 class="title">Apache Jena</h1>
+ <div id="topmenu" class="tabbar round-10">
+ <ul>
+ <li class="round-top-8"><a class="round-top-8" href="/index.html" id="home_menu">Home</a></li>
+ <li class="round-top-8"><a class="round-top-8" href="/help_and_support/index.html">Support</a></li>
+ <li class="round-top-8"><a class="round-top-8" href="/getting_started/index.html">Getting started</a></li>
+ <li class="round-top-8"><a class="round-top-8" href="/tutorials/index.html">Tutorials</a></li>
+ <li class="round-top-8"><a class="round-top-8" href="/documentation/index.html">Documentation</a></li>
+ </ul>
+ </div>
+ </div>
+ </div>
+
+ <div id="navigation" class="clear">
+ <h1 id="quick-links">Quick links</h1>
+<ul>
+<li><a href="/index.html">Home</a></li>
+<li><a href="/download/index.html">Downloads</a></li>
+<li><a href="/help_and_support/index.html">Help and support</a></li>
+<li><a href="/help_and_support/bugs_and_suggestions.html">Report a bug</a></li>
+<li><a href="/about_jena/roadmap.html">Roadmap</a></li>
+<li><a href="/getting_involved/index.html">Getting involved</a></li>
+<li><a href="/documentation/">Documentation</a></li>
+</ul>
+<h1 id="about-jena">About Jena</h1>
+<ul>
+<li><a href="/index.html">Home</a></li>
+<li><a href="/about_jena/about.html">About Jena</a></li>
+<li><a href="/about_jena/architecture.html">Architecture</a></li>
+<li><a href="/about_jena/roadmap.html">Roadmap</a></li>
+<li><a href="/about_jena/team.html">Project team</a></li>
+<li><a href="/about_jena/contributions.html">Related projects</a></li>
+</ul>
+<h1 id="download">Download</h1>
+<ul>
+<li><a href="/download/index.html">Downloading Jena</a></li>
+<li><a href="/download/maven.html">Using Maven</a></li>
+<li><a href="/download/osgi.html">Using OSGi</a></li>
+</ul>
+<h1 id="help-and-support">Help and support</h1>
+<ul>
+<li><a href="/help_and_support/index.html">Getting help</a></li>
+<li><a href="/help_and_support/bugs_and_suggestions.html">Bugs and suggestions</a></li>
+</ul>
+<h1 id="getting-started">Getting Started</h1>
+<ul>
+<li><a href="/getting_started/index.html">A first Jena project</a></li>
+<li><a href="/getting_started/rdf_api.html">RDF API overview</a></li>
+<li><a href="/getting_started/sparql.html">Querying RDF with SPARQL</a></li>
+<li><a href="/getting_started/fuseki.html">Serving RDF over HTTP</a></li>
+<li><a href="/getting_started/tell_me_how.html">Tell me how to ...</a></li>
+</ul>
+<h1 id="tutorials">Tutorials</h1>
+<ul>
+<li><a href="/tutorials/index.html">Tutorials index</a></li>
+<li><a href="/tutorials/rdf_api.html">RDF tutorial</a></li>
+<li><a href="/tutorials/sparql.html">SPARQL queries</a></li>
+<li><a href="/tutorials/using_jena_with_eclipse.html">Using Jena with Eclipse</a></li>
+</ul>
+<h1 id="documentation">Documentation</h1>
+<ul>
+<li><a href="/documentation/index.html">Overview</a></li>
+<li><a href="/documentation/javadoc/">Javadoc</a></li>
+<li><a href="/documentation/rdf/index.html">RDF</a></li>
+<li><a href="/documentation/io/index.html">I/O</a></li>
+<li><a href="/documentation/query/index.html">SPARQL (ARQ)</a><ul>
+<li><a href="/documentation/query/app_api.html">Application API</a></li>
+<li><a href="/documentation/query/cmds.html">Command line utilities</a></li>
+</ul>
+</li>
+<li><a href="/documentation/tdb/index.html">TDB</a><ul>
+<li><a href="/documentation/tdb/tdb_transactions.html">API for Transactions</a></li>
+<li><a href="/documentation/tdb/assembler.html">Dataset Assembler</a></li>
+</ul>
+</li>
+<li><a href="/documentation/serving_data/index.html">Fuseki: Serving Data</a></li>
+<li><a href="/documentation/ontology/index.html">Ontology</a></li>
+<li><a href="/documentation/inference/index.html">Inference</a></li>
+<li><a href="/documentation/assembler/index.html">Assembler</a><ul>
+<li><a href="/documentation/assembler/assembler-howto.html">Assembler how-to</a></li>
+<li><a href="/documentation/assembler/inside-assemblers.html">Inside assemblers</a></li>
+</ul>
+</li>
+<li><a href="/documentation/sdb/index.html">SDB</a></li>
+<li><a href="/documentation/larq/index.html">LARQ: Free Text Search</a></li>
+<li><a href="/documentation/notes/index.html">Notes</a><ul>
+<li><a href="/documentation/notes/concurrency-howto.html">Concurrency how-to</a></li>
+<li><a href="/documentation/notes/event-handler-howto.html">Event handler how-to</a></li>
+<li><a href="/documentation/notes/file-manager.html">File manager how-to</a></li>
+<li><a href="/documentation/notes/model-factory.html">Model factory how-to</a></li>
+<li><a href="/documentation/notes/rdf-frames.html">RDF frames</a></li>
+<li><a href="/documentation/notes/reification.html">Reification how-to</a></li>
+<li><a href="/documentation/notes/typed-literals.html">Typed literals how-to</a></li>
+<li><a href="/documentation/notes/iri.html">Support for IRI's</a></li>
+<li><a href="/documentation/notes/sse.html">SSE</a></li>
+</ul>
+</li>
+<li><a href="/documentation/tools/index.html">Tools</a><ul>
+<li><a href="/documentation/tools/schemagen.html">schemagen</a></li>
+<li><a href="/documentation/tools/eyeball-getting-started.html">eyeball</a></li>
+</ul>
+</li>
+</ul>
+<h1 id="getting-involved">Getting Involved</h1>
+<ul>
+<li><a href="/getting_involved/index.html">Contributing to Jena</a></li>
+</ul>
+<h1 id="asf-links">ASF links</h1>
+<ul>
+<li><a href="http://www.apache.org">Apache Software Foundation</a></li>
+<li><a href="http://www.apache.org/licenses/LICENSE-2.0">License</a></li>
+<li><a href="http://www.apache.org/foundation/thanks.html">Thanks</a></li>
+<li><a href="http://www.apache.org/foundation/sponsorship.html">Become a Sponsor</a></li>
+<li><a href="http://www.apache.org/security/">Security</a></li>
+</ul>
+ </div>
+
+ <div id="content">
+ <h1 class="title">Tutorial - Manipulando SPARQL usando ARQ</h1>
+ <p>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ê. Muito embora possa parecer mais difÃcil do que string munging,
+a API ARQ é sua amiga na longa jornada. </p>
+<p><em>Originalmente publicado em <a href="http://researchrevealed.ilrt.bris.ac.uk/?p=35">Research Revealed project
+blog</a></em></p>
+<h2 id="inserindo-valores-comandos-simples-prontos">Inserindo valores (comandos simples prontos)</h2>
+<p>Vamos começar com algo simples. Suponha que nós queiramos restringir a query a seguir a uma pessoa (person) em particular:</p>
+<div class="codehilite"><pre> <span class="nb">select</span> <span class="o">*</span> <span class="p">{</span> <span class="p">?</span><span class="n">person</span> <span class="sr"><http://xmlns.com/foaf/0.1/name></span> <span class="p">?</span><span class="n">name</span> <span class="p">}</span>
+</pre></div>
+
+
+<p><code>String#replaceAll</code> deveria funcionar, mas existe um jeito mais seguro.
+<code>QueryExecutionFactory</code> em muitos casos, permite que você alimente uma <code>QuerySolution</code>
+com a qual você pode prefixar valores.</p>
+<div class="codehilite"><pre> <span class="n">QuerySolutionMap</span> <span class="n">initialBinding</span> <span class="o">=</span> <span class="k">new</span> <span class="n">QuerySolutionMap</span><span class="p">();</span>
+ <span class="n">initialBinding</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="s">"name"</span><span class="p">,</span> <span class="n">personResource</span><span class="p">);</span>
+ <span class="n">qe</span> <span class="o">=</span> <span class="n">QueryExecutionFactory</span><span class="o">.</span><span class="n">create</span><span class="p">(</span><span class="n">query</span><span class="p">,</span> <span class="n">dataset</span><span class="p">,</span> <span class="n">initialBinding</span><span class="p">);</span>
+</pre></div>
+
+
+<p>Isto geralmente é muito mais simples do que a string equivalente desde que você não tenha usar aspas para
+citações. (Esteja ciente de que isto não funciona para
+<code>sparqlService</code>, o que é uma pena. Seria legal gastar algum tempo consertando isto.)</p>
+<h2 id="fazendo-uma-query-a-partir-do-zero">Fazendo uma Query a partir do zero</h2>
+<p>As limitações previamente mencionadas se devem ao fato de que prefixação na verdade não muda a query em nada,
+apenas a execução daquela query. Então, como nós realmente alteramos queries?</p>
+<p>ARQ provê duas maneiras de se trabalhar com queries: no nÃvel de sintaxe (<code>Query</code>
+and <code>Element</code>), ou no nÃvel algébrico (<code>Op</code>). A distinção entre eles fica claro com os filtros:</p>
+<div class="codehilite"><pre> <span class="n">SELECT</span> <span class="p">?</span><span class="n">s</span> <span class="p">{</span> <span class="p">?</span><span class="n">s</span> <span class="sr"><http://example.com/val></span> <span class="p">?</span><span class="n">val</span> <span class="o">.</span> <span class="n">FILTER</span> <span class="p">(</span> <span class="p">?</span><span class="n">val</span> <span class="o"><</span> <span class="mi">20</span> <span class="p">)</span> <span class="p">}</span>
+</pre></div>
+
+
+<p>Se você trabalha no nÃvel de sintaxe, você irá descobrir que isso (em pseudo código) se parece com : </p>
+<div class="codehilite"><pre> <span class="p">(</span><span class="n">GROUP</span> <span class="p">(</span><span class="n">PATTERN</span> <span class="p">(</span> <span class="p">?</span><span class="n">s</span> <span class="sr"><http://example.com/val></span> <span class="p">?</span><span class="n">val</span> <span class="p">))</span> <span class="p">(</span><span class="n">FILTER</span> <span class="p">(</span> <span class="o"><</span> <span class="p">?</span><span class="n">val</span> <span class="mi">20</span> <span class="p">)</span> <span class="p">))</span>
+</pre></div>
+
+
+<p>Isto é, existe um grupo contendo um padrão triplo e um filtro, do mesmo jeito que você vê na query.
+A álgebra é diferente e nós podemos vê-la usando <code>arq.qparse --print op</code></p>
+<div class="codehilite"><pre> <span class="nv">$</span> <span class="nv">java</span> <span class="n">arq</span><span class="o">.</span><span class="n">qparse</span> <span class="o">--</span><span class="k">print</span> <span class="n">op</span> <span class="s">'SELECT ?s { ?s <http://example.com/val> ?val . FILTER ( ?val < 20 ) }'</span>
+ <span class="p">(</span><span class="n">base</span> <span class="sr"><file:///...></span>
+ <span class="p">(</span><span class="n">project</span> <span class="p">(?</span><span class="n">s</span><span class="p">)</span>
+ <span class="p">(</span><span class="n">filter</span> <span class="p">(</span><span class="o"><</span> <span class="p">?</span><span class="n">val</span> <span class="mi">20</span><span class="p">)</span>
+ <span class="p">(</span><span class="n">bgp</span> <span class="p">(</span><span class="n">triple</span> <span class="p">?</span><span class="n">s</span> <span class="sr"><http://example.com/val></span> <span class="p">?</span><span class="n">val</span><span class="p">)))))</span>
+</pre></div>
+
+
+<p>Aqui o filtro contém o padrão, ao invés de se situar próximo a ele. Esta forma torna claro que a expressão
+está filtrando o padrão.</p>
+<p>Vamos criar esta query do zero usando ARQ. Nós começamos com algumas partes comuns: a tripla a ser comparada
+e a expressão a ser filtrada.</p>
+<div class="codehilite"><pre> <span class="sr">//</span> <span class="p">?</span><span class="n">s</span> <span class="p">?</span><span class="n">p</span> <span class="p">?</span><span class="n">o</span> <span class="o">.</span>
+ <span class="n">Triple</span> <span class="n">pattern</span> <span class="o">=</span>
+ <span class="n">Triple</span><span class="o">.</span><span class="n">create</span><span class="p">(</span><span class="n">Var</span><span class="o">.</span><span class="n">alloc</span><span class="p">(</span><span class="s">"s"</span><span class="p">),</span> <span class="n">Var</span><span class="o">.</span><span class="n">alloc</span><span class="p">(</span><span class="s">"p"</span><span class="p">),</span> <span class="n">Var</span><span class="o">.</span><span class="n">alloc</span><span class="p">(</span><span class="s">"o"</span><span class="p">));</span>
+ <span class="sr">//</span> <span class="p">(</span> <span class="p">?</span><span class="n">s</span> <span class="o"><</span> <span class="mi">20</span> <span class="p">)</span>
+ <span class="n">Expr</span> <span class="n">e</span> <span class="o">=</span> <span class="k">new</span> <span class="n">E_LessThan</span><span class="p">(</span><span class="k">new</span> <span class="n">ExprVar</span><span class="p">(</span><span class="s">"s"</span><span class="p">),</span> <span class="k">new</span> <span class="n">NodeValueInteger</span><span class="p">(</span><span class="mi">20</span><span class="p">));</span>
+</pre></div>
+
+
+<p><code>Triple</code> deveria ser familiar de Jena. <code>Var</code> é uma extensão de <code>Node</code>
+para variáveis. <code>Expr</code> é a interface raÃz para expressões, aquelas coisas que aparecem em <code>FILTER</code> and <code>LET</code>.</p>
+<p>Primeiro, o caminho da sintaxe:</p>
+<div class="codehilite"><pre> <span class="n">ElementTriplesBlock</span> <span class="n">block</span> <span class="o">=</span> <span class="k">new</span> <span class="n">ElementTriplesBlock</span><span class="p">();</span> <span class="sr">//</span> <span class="n">Make</span> <span class="n">a</span> <span class="n">BGP</span>
+ <span class="n">block</span><span class="o">.</span><span class="n">addTriple</span><span class="p">(</span><span class="n">pattern</span><span class="p">);</span> <span class="sr">//</span> <span class="n">Add</span> <span class="k">our</span> <span class="n">pattern</span> <span class="n">match</span>
+ <span class="n">ElementFilter</span> <span class="n">filter</span> <span class="o">=</span> <span class="k">new</span> <span class="n">ElementFilter</span><span class="p">(</span><span class="n">e</span><span class="p">);</span> <span class="sr">//</span> <span class="n">Make</span> <span class="n">a</span> <span class="n">filter</span> <span class="n">matching</span> <span class="n">the</span> <span class="n">expression</span>
+ <span class="n">ElementGroup</span> <span class="n">body</span> <span class="o">=</span> <span class="k">new</span> <span class="n">ElementGroup</span><span class="p">();</span> <span class="sr">//</span> <span class="n">Group</span> <span class="k">our</span> <span class="n">pattern</span> <span class="n">match</span> <span class="ow">and</span> <span class="n">filter</span>
+ <span class="n">body</span><span class="o">.</span><span class="n">addElement</span><span class="p">(</span><span class="n">block</span><span class="p">);</span>
+ <span class="n">body</span><span class="o">.</span><span class="n">addElement</span><span class="p">(</span><span class="n">filter</span><span class="p">);</span>
+
+ <span class="n">Query</span> <span class="sx">q = </span><span class="n">QueryFactory</span><span class="o">.</span><span class="n">make</span><span class="p">();</span>
+ <span class="sx">q.setQueryPattern(body); // Set the body of the query to our group</span>
+<span class="sx"> q.</span><span class="n">setQuerySelectType</span><span class="p">();</span> <span class="sr">//</span> <span class="n">Make</span> <span class="n">it</span> <span class="n">a</span> <span class="nb">select</span> <span class="n">query</span>
+ <span class="n">q</span><span class="o">.</span><span class="n">addResultVar</span><span class="p">(</span><span class="s">"s"</span><span class="p">);</span> <span class="sr">//</span> <span class="n">Select</span> <span class="p">?</span><span class="n">s</span>
+</pre></div>
+
+
+<p>Agora a álgebra:</p>
+<div class="codehilite"><pre> <span class="n">Op</span> <span class="n">op</span><span class="p">;</span>
+ <span class="n">BasicPattern</span> <span class="n">pat</span> <span class="o">=</span> <span class="k">new</span> <span class="n">BasicPattern</span><span class="p">();</span> <span class="sr">//</span> <span class="n">Make</span> <span class="n">a</span> <span class="n">pattern</span>
+ <span class="n">pat</span><span class="o">.</span><span class="n">add</span><span class="p">(</span><span class="n">pattern</span><span class="p">);</span> <span class="sr">//</span> <span class="n">Add</span> <span class="k">our</span> <span class="n">pattern</span> <span class="n">match</span>
+ <span class="n">op</span> <span class="o">=</span> <span class="k">new</span> <span class="n">OpBGP</span><span class="p">(</span><span class="n">pat</span><span class="p">);</span> <span class="sr">//</span> <span class="n">Make</span> <span class="n">a</span> <span class="n">BGP</span> <span class="n">from</span> <span class="n">this</span> <span class="n">pattern</span>
+ <span class="n">op</span> <span class="o">=</span> <span class="n">OpFilter</span><span class="o">.</span><span class="n">filter</span><span class="p">(</span><span class="n">e</span><span class="p">,</span> <span class="n">op</span><span class="p">);</span> <span class="sr">//</span> <span class="n">Filter</span> <span class="n">that</span> <span class="n">pattern</span> <span class="n">with</span> <span class="k">our</span> <span class="n">expression</span>
+ <span class="n">op</span> <span class="o">=</span> <span class="k">new</span> <span class="n">OpProject</span><span class="p">(</span><span class="n">op</span><span class="p">,</span> <span class="n">Arrays</span><span class="o">.</span><span class="n">asList</span><span class="p">(</span><span class="n">Var</span><span class="o">.</span><span class="n">alloc</span><span class="p">(</span><span class="s">"s"</span><span class="p">)));</span> <span class="sr">//</span> <span class="n">Reduce</span> <span class="n">to</span> <span class="n">just</span> <span class="p">?</span><span class="n">s</span>
+ <span class="n">Query</span> <span class="sx">q = </span><span class="n">OpAsQuery</span><span class="o">.</span><span class="n">asQuery</span><span class="p">(</span><span class="n">op</span><span class="p">);</span> <span class="sr">//</span> <span class="n">Convert</span> <span class="n">to</span> <span class="n">a</span> <span class="n">query</span>
+ <span class="n">q</span><span class="o">.</span><span class="n">setQuerySelectType</span><span class="p">();</span> <span class="sr">//</span> <span class="n">Make</span> <span class="n">is</span> <span class="n">a</span> <span class="nb">select</span> <span class="n">query</span>
+</pre></div>
+
+
+<p>Note que o tipo da query (<code>SELECT, CONSTRUCT, DESCRIBE, ASK</code>)não é parte da álgebra,
+e que nós temos que configurar isso na query (embora SELECT seja o padrão). <code>FROM</code> e <code>FROM NAMED</code>
+estão igualmente ausentes.</p>
+<h2 id="navegando-e-aprendendo-visitors">Navegando e Aprendendo: Visitors</h2>
+<p>Você também pode olhar para a álgebra e a sintaxe usando vistors. Comece estendendo <code>OpVisitorBase</code>
+(<code>ElementVisitorBase</code>) que apaga a interface de modo que você pode se concentrar nas partes de interesse,
+então dê um passo a frente e use <code>OpWalker.walk(Op, OpVisitor)</code>
+(<code>ElementWalker.walk(Element, ElementVisitor)</code>). Isso funciona no esquema âbottom upâ (de baixo para cima).</p>
+<p>Para algumas alterações, como manipulação de padrões triplos no local, visitors irão trabalhar bem.
+ Eles provêm um jeito simples de manipular as partes certas da query e você pode alterar as BGPs backing
+ padrões tanto na álgebra quanto na sintaxe. Entretanto, mutações (mutation) não estão consistentemente
+ disponÃveis, não conte com elas. </p>
+<h2 id="transformando-a-algebra">Transformando a Ãlgebra</h2>
+<p>A primeira vista, não há vantagens óbvias em usar a álgebra. O real poder fica claro com o uso de
+transformers (transformações), que lhe permitem reorganizar uma álgebra completamente. ARQ faz amplo
+uso de transformers para simplificar e aperfeiçoar execuções de query.<br />
+</p>
+<p>Em Research Revealed (Pesquisa revelada, em tradução livre), eu escrevi algum código para pegar certo
+número de constraints (constantes) e produzir uma query. Havia várias formas de se fazer isto, mas o
+jeito que eu achei foi gerar ops de cada constraint e juntar o resultado.<br />
+</p>
+<div class="codehilite"><pre> <span class="k">for</span> <span class="p">(</span><span class="n">Constraint</span> <span class="n">con:</span> <span class="n">cons</span><span class="p">)</span> <span class="p">{</span>
+ <span class="n">op</span> <span class="o">=</span> <span class="n">OpJoin</span><span class="o">.</span><span class="n">create</span><span class="p">(</span><span class="n">op</span><span class="p">,</span> <span class="n">consToOp</span><span class="p">(</span><span class="n">cons</span><span class="p">));</span> <span class="sr">//</span> <span class="nb">join</span>
+ <span class="p">}</span>
+</pre></div>
+
+
+<p>O resultado foi uma bagunça incrivelmente correta, que é remotamente compreensÃvel em apenas três condições:</p>
+<div class="codehilite"><pre> <span class="p">(</span><span class="nb">join</span>
+ <span class="p">(</span><span class="nb">join</span>
+ <span class="p">(</span><span class="n">filter</span> <span class="p">(</span><span class="o"><</span> <span class="p">?</span><span class="n">o0</span> <span class="mi">20</span><span class="p">)</span> <span class="p">(</span><span class="n">bgp</span> <span class="p">(</span><span class="n">triple</span> <span class="p">?</span><span class="n">s</span> <span class="sr"><urn:ex:prop0></span> <span class="p">?</span><span class="n">o0</span><span class="p">)))</span>
+ <span class="p">(</span><span class="n">filter</span> <span class="p">(</span><span class="o"><</span> <span class="p">?</span><span class="n">o1</span> <span class="mi">20</span><span class="p">)</span> <span class="p">(</span><span class="n">bgp</span> <span class="p">(</span><span class="n">triple</span> <span class="p">?</span><span class="n">s</span> <span class="sr"><urn:ex:prop1></span> <span class="p">?</span><span class="n">o1</span><span class="p">))))</span>
+ <span class="p">(</span><span class="n">filter</span> <span class="p">(</span><span class="o"><</span> <span class="p">?</span><span class="n">o2</span> <span class="mi">20</span><span class="p">)</span> <span class="p">(</span><span class="n">bgp</span> <span class="p">(</span><span class="n">triple</span> <span class="p">?</span><span class="n">s</span> <span class="sr"><urn:ex:prop2></span> <span class="p">?</span><span class="n">o2</span><span class="p">))))</span>
+</pre></div>
+
+
+<p>Cada uma das constraints é um filtro e um bgp. Isso pode ser muito mais compreensÃvel removendo os
+ filtros e juntando (merging) os padrões triplos. Nós podemos fazer isso usando <code>Transform</code>:</p>
+<div class="codehilite"><pre> <span class="n">class</span> <span class="n">QueryCleaner</span> <span class="n">extends</span> <span class="n">TransformBase</span>
+ <span class="p">{</span>
+ <span class="nv">@Override</span>
+ <span class="n">public</span> <span class="n">Op</span> <span class="n">transform</span><span class="p">(</span><span class="n">OpJoin</span> <span class="nb">join</span><span class="p">,</span> <span class="n">Op</span> <span class="n">left</span><span class="p">,</span> <span class="n">Op</span> <span class="n">right</span><span class="p">)</span> <span class="p">{</span>
+ <span class="sr">//</span> <span class="n">Bail</span> <span class="k">if</span> <span class="ow">not</span> <span class="n">of</span> <span class="n">the</span> <span class="n">right</span> <span class="n">form</span>
+ <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="n">left</span> <span class="n">instanceof</span> <span class="n">OpFilter</span> <span class="o">&&</span> <span class="n">right</span> <span class="n">instanceof</span> <span class="n">OpFilter</span><span class="p">))</span> <span class="k">return</span> <span class="nb">join</span><span class="p">;</span>
+ <span class="n">OpFilter</span> <span class="n">leftF</span> <span class="o">=</span> <span class="p">(</span><span class="n">OpFilter</span><span class="p">)</span> <span class="n">left</span><span class="p">;</span>
+ <span class="n">OpFilter</span> <span class="n">rightF</span> <span class="o">=</span> <span class="p">(</span><span class="n">OpFilter</span><span class="p">)</span> <span class="n">right</span><span class="p">;</span>
+
+ <span class="sr">//</span> <span class="n">Add</span> <span class="n">all</span> <span class="n">of</span> <span class="n">the</span> <span class="n">triple</span> <span class="n">matches</span> <span class="n">to</span> <span class="n">the</span> <span class="n">LHS</span> <span class="n">BGP</span>
+ <span class="p">((</span><span class="n">OpBGP</span><span class="p">)</span> <span class="n">leftF</span><span class="o">.</span><span class="n">getSubOp</span><span class="p">())</span><span class="o">.</span><span class="n">getPattern</span><span class="p">()</span><span class="o">.</span><span class="n">addAll</span><span class="p">(((</span><span class="n">OpBGP</span><span class="p">)</span> <span class="n">rightF</span><span class="o">.</span><span class="n">getSubOp</span><span class="p">())</span><span class="o">.</span><span class="n">getPattern</span><span class="p">());</span>
+ <span class="sr">//</span> <span class="n">Add</span> <span class="n">the</span> <span class="n">RHS</span> <span class="n">filter</span> <span class="n">to</span> <span class="n">the</span> <span class="n">LHS</span>
+ <span class="n">leftF</span><span class="o">.</span><span class="n">getExprs</span><span class="p">()</span><span class="o">.</span><span class="n">addAll</span><span class="p">(</span><span class="n">rightF</span><span class="o">.</span><span class="n">getExprs</span><span class="p">());</span>
+ <span class="k">return</span> <span class="n">leftF</span><span class="p">;</span>
+ <span class="p">}</span>
+ <span class="p">}</span>
+ <span class="o">...</span>
+ <span class="n">op</span> <span class="o">=</span> <span class="n">Transformer</span><span class="o">.</span><span class="n">transform</span><span class="p">(</span><span class="k">new</span> <span class="n">QueryCleaner</span><span class="p">(),</span> <span class="n">op</span><span class="p">);</span> <span class="sr">//</span> <span class="n">clean</span> <span class="n">query</span>
+</pre></div>
+
+
+<p>O código abaixo procura pelos joins do formulário:</p>
+<div class="codehilite"><pre> <span class="p">(</span><span class="nb">join</span>
+ <span class="p">(</span><span class="n">filter</span> <span class="p">(</span><span class="n">exp1</span><span class="p">)</span> <span class="p">(</span><span class="n">bgp1</span><span class="p">))</span>
+ <span class="p">(</span><span class="n">filter</span> <span class="p">(</span><span class="n">exp2</span><span class="p">)</span> <span class="p">(</span><span class="n">bgp2</span><span class="p">)))</span>
+</pre></div>
+
+
+<p>E substitui ele com:</p>
+<div class="codehilite"><pre> <span class="p">(</span><span class="n">filter</span> <span class="p">(</span><span class="n">exp1</span> <span class="o">&&</span> <span class="n">exp2</span><span class="p">)</span> <span class="p">(</span><span class="n">bgp1</span> <span class="o">&&</span> <span class="n">bgp2</span><span class="p">))</span>
+</pre></div>
+
+
+<p>Enquanto nós percorremos a query original, todos os joins são removidos e o resultado final é:</p>
+<div class="codehilite"><pre> <span class="p">(</span><span class="n">filter</span> <span class="p">(</span><span class="n">exprlist</span> <span class="p">(</span><span class="o"><</span> <span class="p">?</span><span class="n">o0</span> <span class="mi">20</span><span class="p">)</span> <span class="p">(</span><span class="o"><</span> <span class="p">?</span><span class="n">o1</span> <span class="mi">20</span><span class="p">)</span> <span class="p">(</span><span class="o"><</span> <span class="p">?</span><span class="n">o2</span> <span class="mi">20</span><span class="p">))</span>
+ <span class="p">(</span><span class="n">bgp</span>
+ <span class="p">(</span><span class="n">triple</span> <span class="p">?</span><span class="n">s</span> <span class="sr"><urn:ex:prop0></span> <span class="p">?</span><span class="n">o0</span><span class="p">)</span>
+ <span class="p">(</span><span class="n">triple</span> <span class="p">?</span><span class="n">s</span> <span class="sr"><urn:ex:prop1></span> <span class="p">?</span><span class="n">o1</span><span class="p">)</span>
+ <span class="p">(</span><span class="n">triple</span> <span class="p">?</span><span class="n">s</span> <span class="sr"><urn:ex:prop2></span> <span class="p">?</span><span class="n">o2</span><span class="p">)</span>
+ <span class="p">))</span>
+</pre></div>
+
+
+<p>Isto completa esta breve introdução. Existe muito mais em ARQ, claro, mas esperamos que você tenha tido um gostinho do que ele pode fazer.</p>
+ </div>
+
+ <div id="footer">
+ <div class="copyright">
+ <p>
+ Copyright © 2011–2013 The Apache Software Foundation, Licensed under
+ the <a href="http://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0</a>.
+ <br />
+ Apache Jena, Jena, the Apache Jena project logo,
+ Apache and the Apache feather logos are trademarks of The Apache Software Foundation.
+ </p>
+ </div>
+ </div>
+
+</body>
+</html>
Modified: websites/staging/jena/trunk/content/tutorials/index.html
==============================================================================
--- websites/staging/jena/trunk/content/tutorials/index.html (original)
+++ websites/staging/jena/trunk/content/tutorials/index.html Tue Jan 22 19:23:12 2013
@@ -176,6 +176,7 @@ pouvez les voir en suivant ces liens:</p
<ul>
<li><a href="rdf_api_pt.html">Uma introdução à API RDF</a></li>
<li><a href="sparql_pt.html">Tutorial SPARQL</a></li>
+<li><a href="/documentation/query/manipulating_sparql_using_arq_pt.html">Manipulando SPARQL usando ARQ</a></li>
</ul>
</div>
Modified: websites/staging/jena/trunk/content/tutorials/sparql_pt.html
==============================================================================
--- websites/staging/jena/trunk/content/tutorials/sparql_pt.html (original)
+++ websites/staging/jena/trunk/content/tutorials/sparql_pt.html Tue Jan 22 19:23:12 2013
@@ -156,9 +156,9 @@
<p>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.</p>
<p>Se você estiver procurando uma pequena introdução a SPARQL e Jena, experimente
<a href="http://www.ibm.com/developerworks/xml/library/j-sparql/">Search RDF data with SPARQL</a>. Se você quer executar consultas SPARQL e já sabe como ele funciona, então você deveria ler a <a href="http://jena.apache.org/documentation/query/index.html">ARQ Documentation</a>.</p>
-<p>SPARQL is a
-<a href="http://www.w3.org/TR/sparql11-query/">query language</a> e um
-<a href="http://www.w3.org/TR/rdf-sparql-protocol/">protocol</a> para acesso a
+<p>SPARQL é uma
+<a href="http://www.w3.org/TR/sparql11-query/">linguagem de consulta</a> e um
+<a href="http://www.w3.org/TR/rdf-sparql-protocol/">protocolo</a> para acesso a
RDF elaborado pelo
<a href="http://www.w3.org/2001/sw/DataAccess/">W3C RDF Data Access Working Group</a>. </p>
<p>Como uma linguagem de consulta, SPARQL é orientada a dados de forma que só consulta as informações presentes nos modelos, não há inferência propriamente dita nesta linguagem de consulta. Por acaso, os modelos de Jena são âinteligentesâ quanto a isso, e nos dá a impressão de que certas triplas são criadas sob demanda, incluindo raciocÃnio OWL. SPARQL nada mais faz do que pegar a descrição do que a aplicação quer, na forma de uma consulta, e retornar a informação, na forma de um conjunto de ligações ou grafo RDF.</p>