Motivations (chronologically)

• implement database access code for Lilly.
• implement Patient Recruitment demo for HCLS.
• test bed for SPARQL extensions (e.g. MINUS).
• be useful to me.
• demonstrate feasibiliy of SPARQL to SQL transformations.
• command line tool for SPARQL lectures.

Utility

General purpose SPARQL engine.

SPARQL --username eric --password ********
  -d http://www.w3.org/2000/09/dbwg/details?group=38539
  -d http://cgi.w3.org/member-bin/list_mgnt.pl?list=public-semweb-lifesci
  -e 'SELECT ?mem { { ?w <http://xmlns.com/foaf/0.1/mbox> ?mem }
              MINUS { ?l <http://cgi.w3.org/member-bin/list_mgnt_xml.pl#member> ?mem } }' 

Utility cont...

works as a general tool, like cwm.

default interaction is through trig

{ # default graph }
<namedGraph1 { ... }
<namedGraph2 { ... }

and a UTF-8 variant of result sets

Didactic utiliy

a couple cute tricks:

• built in tutorial
• built in data

~/checkouts/swobjects/bin/SPARQL --help
Usage: SPARQL [opts] queryURI mapURI*                           
Usage: SPARQL [opts] -e query mapURI*                           

get started with: SPARQL --Help tutorial
...
SPARQL --Help tutorial
Tutorial
...
SPARQL -a -DG foo -G foo2 -e "SELECT ?g {GRAPH ?g {?s ?p <http://usefulinc.com/ns/doap#Project>}}"
+--------+
| ?g     |
|  <foo> |
| <foo2> |
+--------+

Code

binaries:

• SPARQL — SPARQL client, query transformer, pim manager
• SPARQL_server — SPARQL server (quelle surprise)

source:

• test-driven
• C++ (templates, exceptions, stl)
• boost

Lessons Learned

• SPARQL is easy.
• CLI is hard.
• GRDDL is hard.
• relative URLs are tedious.
• C++ needs standard network libraries.

Next Steps

• finish GRDDL.
• swig interface to python, jave, etc.
• SQL parser and tests.
• harden CLI for pim simplicity.
• SPARQL_server overhaul.

Databases as RDF

trivial to dump RDB as RDF

test: is the graph query coherent (do generated node identifiers merge)?

ETL needs

?who mydb:fn ?name

?who foaf:name ?name

What's up in RDB2RDF

The charter says to map RDBs to RDF/OWL.

• RDF Schema:
  • Table->Type maps
  • Column->preciate maps
• DDL to create a triples table:
  • create a triples view.
  • spec mapping
    triples to RDF.
• Normative RDF representation:
  • specify RDF view.
  • map to interface view
    via CONSTRUCT.

RDB2RDF Standards Goal

clear algebra for:

• production of stem graph (see eswc submission)
• SPARQL->SQL (also in eswc submission)
• SQL results->SPARQL results

example

Emp:id=1 emp:id 1 .             
Emp:id=1 emp:manager Emp:id=4 .	
Emp:id=1 emp:section "sales" .  
Emp:id=4 emp:id 4 .	        
                        	
Emp:id=4 emp:manager "exec" .   
	

_:t1 task.employee Emp:id=1 .
_:t1 task.lead Emp:id=2 .    
_:t1 task.name "widgets" .   
_:t2 task.employee Emp:id=4 .
_:t2 task.lead Emp:id=5 .    
_:t2 task.name "widgets".    
	

SELECT ?sec ?name
 WHERE { GRAPH<HQ>    { ?flunky emp:section ?sec OPTIONAL { ?flunky emp:manager ?boss } }
         GRAPH<Sales> { _:t task:employee ?flunky; task:lead ?boss; task:name ?task } }
      

Interface Graph

• start with StemGraph
• SPARQL CONSTRUCT and Interface Graph
• push IFaceGraph queries to SQL using magic sets
• (DDL approach puts magic sets in SQL instead)

CONSTRUCT usefull elsewhere

Performance

• SPARQL views approach queries conventional stores directly.
• no multi-source virtual views.
• parsing costs low (LALR1)
• transformation costs roughly linear over query + small hash-table (log n) factor
• performance consistent with that of conventional store

HCLS Requirements

• SPARQL 1.0 CONSTRUCT
• term rewriting

requirements feedback through:

• wiki scratch space.
• submitted to RDB2RDF group in detail.

tech space