Construindo Operações CRUD da Semantic Web Usando PHP

Criar, ler, atualizar e excluir em SQL e SPARQL

As operações Criar, Ler, Atualizar e Excluir (CRUD) são as operações de banco de dados mais básicas, mas também são as mais cruciais. As operações CRUD são geralmente realizadas usando Linguagem de Consulta Estruturada (SQL) em sistemas de bancos de dados relacionais. À medida que a Web está se tornando cada vez mais orientada a dados, há uma necessidade de alternar de operações CRUD baseadas em SQL para operações CRUD baseadas na Semantic Web. Aprenda como usar PHP para executar operações CRUD através da Semantic Web.

Daniel J Lewis, Technology Evangelist/Computer Scientist, OpenLink Software

Daniel LewisDaniel Lewis é um aluno de pós-graduação na Universidade de Bristol. Sua principal área de pesquisa é aprendizado de máquina e mineração de dados. Seus interesses incluem todos os tipos de sistemas inteligentes e também é um defensor de desenvolvimento de software livre e para várias plataformas. Fora da área de computação, ele gosta de passar seu tempo com sua namorada e ler sobre religião, filosofia e psicologia sobre os quais ele escreve em seu blog.



25/Nov/2008

Acrônimos Usados Frequentemente

  • API— Interface de Programação de Aplicativos
  • CRUD— Criar, Ler, Atualizar, Excluir
  • HTTP— Protocolo de Transporte de Hipertexto
  • MVC— Model-View-Controller
  • OOP— Programação Orientada a Objetos
  • RDF— Resource Description Framework
  • SPARQL— Simple Protocol and RDF Query Language
  • SQL— Linguagem de Consulta Estruturada
  • UI— Interface com o Usuário
  • W3C— World Wide Web Consortium

Ao desenvolver um aplicativo da Web, é prática padrão criar uma estrutura de banco de dados na qual código do lado do servidor é colocado para as camadas de lógica e UI. Para conectar ao banco de dados, o código do lado do servidor precisa realizar alguma criação, atualização, exclusão e — o mais importante — leitura básica dos registros. Como os bancos de dados por trás de aplicativos da Web geralmente são bancos de dados relacionais, essas operações CRUD são realizadas usando a bem conhecida linguagem SQL. No entanto, à medida que o desenvolvimento da Web está ocorrendo cada vez mais através de programação orientada a objetos (OOP), o modelo está sendo alterado.

A Resource Description Framework (RDF) é uma maneira perfeita para descrever objetos enquanto o significado desses dados é mantido. Simple Protocol and RDF Query Language (SPARQL — pronunciado como "sparkle") é a linguagem geralmente usada para consulta nesses dados, já que correspondem sintaticamente a estrutura da própria RDF. RDF e SPARQL são tecnologias no que foi apelidado de pilha de Semantic Web.

Para abraçar integralmente a ideia de Semantic Web, você pode aplicar técnicas tradicionais de desenvolvimento da Web para dados RDF usando SPARQL. Este artigo mostra como usar um padrão de design Model-View-Controller (MVC) simplificado, a linguagem de script do lado do servidor PHP e SPARQL para conectar a RDF — em vez de usar SQL em um sistema de banco de dados relacional.

Operações CRUS de SQL e SPARQL

Pré-requisitos

Este artigo supõe um entendimento básico de desenvolvimento de aplicativo SQL, PHP e da Web. Um entendimento da Semantic Web também é útil. Para executar os comandos create, update e delete nos dados baseados na Semantic Web, você precisa de um armazém de dados da Semantic Web que suporta a especificação de SPARQL/Update.

Vale a pena dar uma olhada nas semelhanças e diferenças entre as operações CRUD quando desenvolvidas em SQL e SPARQL. A Lista 1 mostra o código SQL para uma operação read .

Lista 1. SQL para a Operação read
SELECT realname, dob, location
FROM UserTable 
WHERE realname = "John Smith";

Compare esse código baseado em SQL ao código baseado em SPARQL mostrado na Lista 2. São duas operações read , pois são as mais fáceis de entender, implementar e explicar. Isso é verdadeiro para SQL e SPARQL.

Lista 2. SPARQL para a Operação read
PREFIX foaf:
<http://xmlns.com/foaf/0.1/> 
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT ?uri ?name ?dob ?location
FROM
<http://www.example.org/graph>
WHERE
{ ?uri
rdf:type foaf:Person ;
foaf:name "John Smith" ;
foaf:birthday
?dob ;
foaf:location ?location .
} ;

Seu primeiro pensamento ao comparar as duas listagens provavelmente será que a versão SPARQL claramente possui muito mais linhas do que a versão SQL. Isso é verdade, mas não engane pensando que SQL é necessariamente mais simples e mais limpa. SPARQL, dependendo do mecanismo no qual a executa, pode ser totalmente distribuída por algo conhecido como o efeito de dados vinculados. Além disso, permite que você tenha esquemas dinâmicos de sua perspectiva orientada a objetos intervinculados, em contraste à perspectiva estritamente relacional de SQL. Se você fosse dividir tabelas de bancos de dados relacionais nesse mesmo número de ilhas de dados, você teria realmente muito mais linhas de SQL em comparação a SPARQL — sem mencionar que SQL estaria cheia daqueles inconvenientes descritores JOIN .

As duas primeiras linhas de SPARQL são as declarações PREFIX . De acordo com a teoria da Semantic Web, tudo — seja um objeto ou uma origem de gráfico de dados (também um objeto) — tem um Identificador Uniforme de Recursos (URI). As linhas PREFIX estão simplesmente aplicando um rótulo temporário para alguns URIs — nesse caso, os esquemas Amigo de um Amigo e RDF. O benefício aqui é que você pode usar as declarações PREFIX posteriormente na consulta em vez de precisar usar os URIs integrais.

A próxima linha do código SPARQL descreve o pedido de consulta. É basicamente a mesma coisa que a instrução SQL, exceto pelo pedido adicional do URI. Anote o uso de pontos de interrogação (? ) para indicar que o termo é uma variável.

A instrução FROM descreve onde captar os dados. É igual em SQL e SPARQL, exceto que em SPARQL, o nome da origem de dados é um URI, em vez de uma string que denota um local físico em seu computador ou rede.

As instruções WHERE são bem diferentes umas das outras, pois com SPARQL, você deve especificar quais esquemas usar para buscar dados. Mais uma vez, se você tiver tentado fazer isso usando métodos tradicionais, seria necessário um SQL mais do que simples: seria necessário usar PHP, a linguagem de programação Java™ ou alguma outra linguagem do lado do servidor para fazer a verificação entre as origens de dados. É razoavelmente claro o que as linhas de SPARQL fazem, o que inclui assegurar que os dados que estão sendo recuperados são somente do tipo Person. SPARQL busca um nome e um local enquanto realiza alguma correspondência de padrão para localizar o John Smith certo.

Criar

As operações CRUD em SPARQL estão geralmente um pouco mais envolvidas em mistério do que a operação read . No entanto, elas podem ser executadas. Para iniciar a operação create , insira um novo registro ou objeto na tabela ou gráfico.

Lista 3. SQL para a Operação create
INSERT 
INTO UserTable (realname, dob, location) 
VALUES ("John Smith", "1985-01-01", "Bristol, UK");

Agora, compare o código baseado em SQL na Lista 3 ao código baseado em SPARQL na Lista 4 para a mesma operação create .

Lista 4. SPARQL para a Operação create
PREFIX foaf:
<http://xmlns.com/foaf/0.1/> 
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
INSERT 
INTO GRAPH <http://www.example.com/graph> 
(?realname, ?dob, ?location) 
{
<http://www.example.org/graph/johnsmith#me> rdf:Type 
foaf:Person ;  
foaf:name "John Smith" ;  
foaf:birthday 
<1985-01-01T00:00:00> ; 
foaf:location "Bristol, UK" 
}

Mais uma vez, observe que as linhas PREFIX funcionam exatamente como na operação read com SPARQL. INSERT INTO funciona de forma semelhante para SQL, mas, novamente, é baseado em URI em vez de baseado em string, tabela e nome, o que permite que a operação seja realizada em HTTP. Você também deve especificar o esquema novamente. Aqui, é ligeiramente mais fácil entender do que na operação read , já que você pode ter praticamente qualquer tipo de propriedade, desde que seja compatível com o esquema. Esse é um benefício e uma beleza do formalismo distribuído dinamicamente dos objetos extensíveis que RDF fornece.

Excluir

Se você criar, em algum ponto, provavelmente, irá querer excluir. Por exemplo, os usuários podem querer excluir a conta de seu site (obviamente uma infelicidade de eles quererem sair, mas podem ter razões válidas). A Lista 5 fornece o código SQL para uma operação delete típica.

Lista 5. SQL para a Operação delete
DELETE FROM UserTable WHERE realname = "John Smith"

Agora, compare o código baseado em SQL na Lista 5 ao código baseado em SPARQL na Lista 6.

Lista 6. SPARQL para a Operação delete
DELETE 
FROM GRAPH <http://www.example.com/graph>
{<http://www.example.org/graph/johnsmith#me> ?predicate ?object }

A diferença fundamental entre o código SQL e SPARQL é que SQL exclui uma linha de uma tabela, enquanto que SPARQL exclui "todos os triplos" relacionados ao objeto "John Smith" denotado por http://www.example.org/graph/johnsmith#me. Essa diferença é o resultado da natureza baseada em gráfico do modelo RDF.

Atualizar

Muitos aplicativos da Web permitem que usuários atualizem suas informações. A operação UPDATE é o que torna isso possível. As Listagens 7 e 8 demonstram como codificar isso em SQL e SPARQL.

Lista 7. SQL para a Operação update
UPDATE UserTable
SET location = "Weston-super-Mare, UK"
WHERE realname = "Joanne Smith"

Agora, compare o código baseado em SQL na Lista 7 ao código baseado em SPARQL na Lista 8 para a operação update .

Lista 8. SPARQL para a Operação update
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
MODIFY <http://www.example.org/graph> 
DELETE {?uri foaf:location ?location} 
INSERT {?uri foaf:location "Weston-super-Mare, UK"}
WHERE { ?uri foaf:name "Joanne Smith" }
WHERE { ?uri foaf:name "Joanne Smith" }

UPDATE com SPARQL pode parecer incrivelmente simples, mas é completamente válido quando você entende que você não está atualizando uma linha de tabela relacional — você está atualizando um relacionamento muito específico em um gráfico. A maneira mais fácil de se fazer isso sem atingir diversos locais é excluindo e inserindo. A palavra-chave MODIFY é usada para estabelecer a conexão com o gráfico correto.


Conectando a Sistemas de Banco de Dados SQL e SPARQL

Para executar as instruções SQL e SPARQL, você deve conectar ao sistema de alguma forma. Diferentes sistemas, obviamente, têm diferentes métodos de conexão. Um método comum é conectar a um banco de dados genérico usando drivers Open Database Connectivity (ODBC), que frequentemente estão incluídos nas versões atuais dos sistemas Mac OS X e Linux® e são instáveis em outros sistemas operacionais, como o Windows®. ODBC fornece, essencialmente, uma API simples genérica para conectar a um banco de dados SQL de sua opção. O que é interessante é que ODBC também funciona com alguns armazéns de dados da Semantic Web, como o OpenLink Virtuoso. No entanto, a maioria dos outros armazéns de dados da Semantic Web requerem algum procedimento de conexão customizada ou um sistema de conexão genérica customizado, como RDF2Go (na época desta composição, RDF2Go era somente para a tecnologia Java) que funciona com diversos sistemas, como Seseme e Jena. Uma alternativa a ser considerada se seus dados forem ser expostos através de HTTP é um método de conexão SPARQL através de HTTP, o que torna seus dados prontos para "Dados Vinculados" e podem ser completamente distribuídos. Como a gama de métodos de conexão para SQL e SPARQL varia, não é viável cobrir todos em detalhes aqui.


SQL e SPARQL através de PHP

Após selecionar um método de conexão, a próxima etapa tradicional é estabelecer operações comuns em PHP. Para um sistema customizado, isso geralmente é feito usando strings SQL com variáveis PHP injetadas e transmitidas a ele através de parâmetros de função. A função conectará, então, ao banco de dados e executará essa transação. A proposta aqui é fazer exatamente o mesmo para uma conexão SPARQL-RDF que seria feito para uma conexão SQL-RDBMS.

Portanto, dê uma olhada em outra comparação de código — desta vez usando a linguagem PHP — começando com read, em seguida, indo para create, delete e update, como com as comparações de código acima. Use uma função de execução de consulta hipotética chamada query_execute, que aceita uma representação de string da instrução SQL/SPARQL.

Ler

A primeira é a operação read simples. Variáveis podem ser injetadas na consulta usando concatenação de strings em PHP.

Lista 9. SQL para a Operação read
function readUserInfo($realname) {
    $sqlstatement = "SELECT realname, dob, location FROM UserTable WHERE
    realname = \"" + realname + "\";";
    return query_execute($sqlstatement);
    }

Agora, compare o código PHP baseado em SQL na Lista 9 ao código PHP baseado em SPARQL na Lista 10 para a modesta operação read .

Lista 10. SPARQL para a Operação read
function readUserInfo($realname) {
    $sqlstatement = "PREFIX foaf:
    <http://xmlns.com/foaf/0.1/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT ?uri ?name ?dob ?location 
FROM <http://www.example.org/graph>
WHERE 
{ ?uri rdf:type foaf:Person ; 
foaf:name \"" + $realname + "\" ; 
foaf:birthday ?dob ;
foaf:location ?location .
} ;";
    return query_execute($sparqlstatement);
}

Como pode ver, a função acima foi desenvolvida de forma que o nome e os parâmetros da função sejam idênticos, o que significa que você poderia começar a usar a versão SPARQL imediatamente. Além disso, se você estiver usando um sistema ODBC, não será necessário se preocupar sobre mudanças dos tipos de retorno.

Criar

O que está acima é o que está abaixo, e o que está abaixo é o que está acima. Os métodos PHP a seguir injetam variáveis em uma string para executar uma consulta dinâmica. A Lista 11 mostra como fazer isso com uma operação create .

Lista 11. SQL para a Operação create
function createUserInfo($realname, $dob,
    $location) {
    $sqlstatement = "INSERT INTO UserTable (realname, dob,
    location) VALUES (\"" + $realname + "\", \"" + $dob + "\", \"" +
    $location + "\");";
return query_execute($sqlstatement);
}

Agora compare o código PHP baseado em SQL na Lista 11 ao código PHP baseado em SPARQL na Lista 12 para a operação create

Lista 12. SPARQL para a Operação create
function createUserInfo($uri, $realname,
    $dob, $location) {
    $sparqlstatement = "PREFIX foaf:
    <http://xmlns.com/foaf/0.1/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
INSERT INTO GRAPH <http://www.example.com/graph>
    (?realname, ?dob, ?location) 
    { 
    " + $uri + " rdf:Type
    foaf:Person ;
    foaf:name \"" + $realname + "\" ;
    foaf:birthday
        <" + $dob + ">> ;
        foaf:location \"" + $location +
"\}"
return query_execute($sparqlstatement);
    }

Por questão de simplificação, a versão SPARQL desta função inclui um parâmetro URI, apesar de ser simples o suficiente realizar alguma concatenação de string adicional para tornar a declaração da função idêntica à de SQL.

Excluir

Use injeção através de concatenação em PHP para executar a operação delete . Observe que, conforme mencionado na seção anterior, variáveis diferentes passam nas versões SQL e SPARQL. A Lista 13 mostra o código SQL para a operação delete .

Lista 13. SQL para a Operação delete
function deleteUserInfo($realname) {
    $sqlstatement = "DELETE FROM UserTable WHERE realname = \"" + John Smith + "\"";
        return query_execute($sqlstatement); 
}

Agora, compare o código PHP baseado em SQL na Lista 13 ao código PHP baseado em SPARQL na Lista 14 para a operação delete .

Lista 14. SPARQL para a Operação delete
function deleteUserInfo($uri) {
    $sparqlstatement = "DELETE FROM GRAPH
    <http://www.example.com/graph> {<" + $uri +
    "> ?predicate ?object }";
    return query_execute($sparqlstatement); }

Mais uma vez, por questão de simplificação, a versão SPARQL da função aceita um URI, em vez de o nome real. Você poderia usar a instrução DELETE SPARQL com uma cláusula WHERE para localizar os dados por nome em vez de URI, o que possibilitaria que você tivesse um cabeçalho de função idêntica ao da versão SQL.

Atualizar

Atualizar um registro é bem simples em SQL e SPARQL através de PHP. Esteja apenas ciente das diferentes estruturas que os bancos de dados relacionais e RDF fornecem. A Lista 15 mostra o código SQL para a operação update .

Lista 15. SQL para a Operação update
function deleteUserInfo($uri) {
    $sparqlstatement = "DELETE FROM GRAPH
    <http://www.example.com/graph> {<" + $uri +
    "> ?predicate ?object }";
    return query_execute($sparqlstatement); }

Agora compare o código PHP baseado em SQL na Lista 15 ao código PHP baseado em SPARQL na Lista 16 para a operação update .

Lista 16. SPARQL para a Operação update
function updateUserInfo($realname,
    $location) { 
    $sparqlstatement = " PREFIX foaf: <http://xmlns.com/foaf/0.1/>
MODIFY <http://www.example.org/graph>
DELETE {?uri foaf:location ?location} 
INSERT {?uri foaf:location \"" + $location + "\"}
WHERE { 
    ?uri foaf:name \"" + $realname + "\"
    }
        ";
        return query_execute($sparqlstatement);
    }

As declarações de função nas versões SQL e SPARQL são idênticas. Como resultado, trocar de SQL para SPARQL é simples.

Apesar de ser bem simples ir de uma origem de dados com um terminal SQL para uma origem de dados com um terminal SPARQL, há duas áreas importantes das quais precisa estar ciente: níveis de abstração e as semelhanças e diferenças entre SQL e SPARQL. Você quer evitar esse sentimento contido que vem de pensar que uma linguagem é praticamente idêntica à outra. Portanto, é melhor entender as limitações de uma linguagem enquanto, ao mesmo tempo, explora os recursos da linguagem — principalmente, as diversas representações simplificadas e gráficas da sintaxe fornecidas por diferentes linguagens.


Níveis de Abstração

O código de exemplo neste artigo está fortemente acoplado à estrutura do banco de dados. Em teoria, há somente um determinado nível de acoplamento fraco que SQL e RDBMS podem suportar antes de a reorganização da estrutura da tabela ocorrer. No entanto, esse não é o caso com SPARQL e RDF. Com SPARQL, seu acoplamento com dados pode ser muito abstrato devido à natureza distribuída, mas intervinculada de RDF. A capacidade de reutilização dos exemplos neste artigo poderia ser potencialmente aprimorada aumentando a abstração dos mesmos. No entanto, para nossos propósitos, funções simples acopladas de perto são usadas para exemplificar as semelhantes e diferenças entre SPARQL e SQL.

Como pode ver no código de exemplo, há diversas semelhanças entre SQL e SPARQL. As diferenças surgem quando se entende a natureza gráfica orientada a objetos baseada na Web de RDF e como isso filtra na linguagem SPARQL. Como uma regra geral simplificada, é possível imaginar a estrutura tripla em RDF e SPARQL como a representação básica, em ordem, da chave primária exclusiva de uma linha (o assunto), do nome do atributo/coluna (o predicado ou relacionamento) e dos dados da célula baseados na linha e coluna (o objeto). Além disso, SPARQL pode tirar total proveito de comunicação HTTP e, portanto, dados podem ser (mas não precisam ser) distribuídos por intranets, extranets e a Internet mais ampla.


Por que Ir de SQL para SPARQL?

Há muitas razões para ir de SQL para SPARQL. Os detalhes vão além do escopo deste artigo, mas você poderia ser motivado pelos seguintes pontos:

  • Você deseja uma solução de dados mais distribuída.
  • Você deseja expor seus dados na Web para que as pessoas os usem e vinculem-se a eles.
  • Você pode achar os relacionamentos Node-Arc-Node (triplos) mais fáceis de entender do que modelos de bancos de dados relacionais.
  • Você pode querer entender seus dados de maneira puramente orientada a objetos para trabalhar com um paradigma OOP (PHP V5 e posterior suportam OOP).
  • Você deseja construir agentes genéricos que podem se conectar às origens de dados na Web.

É claro que também há razões porque você pode não querer se distanciar de SQL e são, provavelmente, razões perfeitamente válidas. SPARQL é um método adicional de consulta, não necessariamente uma substituição imediata de SQL. O mesmo se passa com dados relacionais e dados baseados na Semantic Web. Não são substituições. Em vez disso, é melhor pensar em termos de fundir técnicas mais novas e mais antigas para produzir um sistema híbrido que pode tratar e ser tratado por sistemas de legado mais antigos e os sistemas atuais e futuros.

Recursos

Aprender

Obter produtos e tecnologias

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre
ArticleID=382612
ArticleTitle=Construindo Operações CRUD da Semantic Web Usando PHP
publish-date=11252008