Studiu comparativ privind procesarea RDF sub .NET framework

1. Studiu comparativ privind procesarea RDF sub .NET Framework
SemWeb este o librarie pentru Semantic Web si RDF, scrisă in C# pentru platforma .NET 1.1/2.0. Ea
poate fi folosită pentru a scrie și a citi RDF(XML sau N3), pentru a stoca conținutul RDF într-un mediu
persistent (memorie, MySQL, SQLite, SQL Server, PostgreSQL), pentru a interoga mediul persistent
utilizând limbajul SPARQL sau pentru crea interogări SPARQL pentru diferite resurse de pe web.
Caracteristici
 API ușor de utilizat cu o interoperabilitate completă.
 Scriere și citire RDF/XML. Cititorul lucrează cu fluxuri astfel încât nu este necesară încărcarea
întregului document în memorie.
 Respectă standardul W3C.
 Suport pentru Notation 3 – scriere și citire Ntriple, Turtle și o marea parte a Notation 3. Se
folosesc fluxuri care operează la aproximativ 20.000 de declarații pe secundă.
 Validarea URI-ulor și a literalilor XSD când se execută citirea (sau când se cere acest lucru) și
parsarea tipurilor xsd:dateTime, xsd:date, xsd:time în instanțe ale tipului XsdDateTime.
 Posibilitatea de a genera fișiere în formatul GraphViz.
 Posibilitate de stocare în baze de date pentru SQL Server, MySQL, Sqlite și PostgreSQL. În
MySQL se pot stoca cel puțin un miliard de înregistrări.
 Se poate folosi ca mediu de stocare și sistemul de fișiere.
 Mediile de stocare persistente suportă o operație Select extinsă pentru a putea interoga mai
multe lucruri deodată, fiind mai rapidă decât decât operații Select individuale.
 Raționare RDFS și raționare bazată pe reguli.
 Interogări SPARQL peste orice sursă de date cu transformări în SQL de câte ori este posibil.
Există un client pentru surse de date SPARQL și un protocol SPARQL pentru ASP.NET.
 Interogări pe surse de date Stores ce conțin instanțe ale obiectelor de tipul SelectableSource.
 Librăria este extensibilă pentru a implementa un nou sistem de stocare.
Un program SemWeb simplu:
// This example creates a few RDF statements and adds
// them to a MemoryStore. Then it writes out the
// statements in RDF/XML format to the console. Note
// that the implicit string-to-Entity and string-to-
// Literal conversion operators are being used.
using System;
using SemWeb;
public class Example {
const string RDF = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
public static void Main() {
MemoryStore store = new MemoryStore();
1

2. Entity computer = new Entity("http://example.org/robot");
Entity says = "http://example.org/says";
Entity wants = "http://example.org/wants";
Entity desire = new BNode();
Entity description = new Entity("http://example.org/description");
store.Add(new Statement(computer, says, (Literal)"Hello world from
me, the robot!"));
store.Add(new Statement(computer, wants, desire));
store.Add(new Statement(desire, description, (Literal)"to have a
heart like humans"));
store.Add(new Statement(desire, RDF+"type",
(Entity)"http://example.org/Desire"));
using (RdfWriter writer = new RdfXmlWriter(Console.Out)) {
writer.Namespaces.AddNamespace("http://example.org/", "ex");
writer.Write(store);
}
}
}
Rezultatul acestui program este următorul:
<?xml version="1.0"?>
<rdf:RDF xmlns:ex="http://example.org/"
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
<rdf:Description rdf:about="http://example.org/robot">
<ex:says>Hello world from me, the robot!</ex:says>
<ex:wants>
<ex:Desire>
<ex:description>to have a heart like
humans</ex:description>
</ex:Desire>
</ex:wants>
</rdf:Description>
</rdf:RDF>
Citire RDF
Pentru a putea citi RDF, se folosește clasa MemoryStore. cu ajutorul metodei Import, se pot
încărca în memorie fișiere RDF/XML, N-Triple, Turtle, Notation 3. Se pot încărca resurse de
pe web specificând URI-ul lor, folosind metoda LoadFromUri, care determină formatul
fișiserului (XML sau N3) în funcție de tipul MIME trimis de către server.
Exemple:
MemoryStore store = new MemoryStore();
store.Import(new RdfXmlReader("myRDFdata.rdf"));
store.Import(new N3Reader("myN3data.n3"));
store.Import(RdfReader.LoadFromUri(new
Uri("http://www.microsoft.com/news.rdf")));
2

3. Declarația SELECT
Numele „SELECT” este derivat din sintaxa SQL, unde este folosit pentru a extrage rânduri
după un anumit criteriu. În libăria SemWeb, declarația SELECT este folosită pentru a extrage
resurse potrivit unor filtre. La fel ca în SQL, când nici un filtru este prezent, toate resursele
sunt extrase.
Exemple:
store.Select(sink); // selecteză toate afirmațiile
store.Select(new Statement(null, null, null), sink); // la fel ca mai sus
store.Select(Statement.All, sink); // la fel ca mai sus, doar mai scurt
store.Select(new Statement(subj, null, null), sink); // orice afirmație cu
subiectul ”subj”
store.Select(new Statement(subj, pred, null), sink); // orice afirmație cu
subiectul ”subj” și predicatul ”pred”
store.Select(new Statement(subj, pred, obj), sink); // doar afirmația cu
subiectul ”subj”, predicatul ”pred” și valoarea ”obj”.
Folosirea bazelor de date
În afară de MemoryStore, librăria SemWeb asigură și 4 sisteme de stocare persistente bazate
pe SQL: MySQL, PostgreSQL, SQL Server și SqlLite.
Viziune asupra performațelor
Stocarea în MySQL este de mai multe ori mai rapidă decât stocarea SQLite, cel puțin pentru
adăugarea afirmațiilor în mediul persistent. Cu SQLite este mai uşor de lucrat și poate fi
folosit pentru baze de date mici de până la 100.000 de declarații. Folosind metoda de import
pentru MySQL, se pot încărca peste zece milioane de declarații în cel mult 45 minute pe
sisteme modeste, adică aproximativ 4500 declarații pe secundă. SQLite încarcă datele la o
viteză de 1400 declarații pe secundă. Viteza depinde foarte mult de structura de date care va
fi încărcată.
Selectarea folosind filtre
Pentru orice sursă de declarații în afară de MemoryStore, la fiecare cerere pentru o
declarație apare o prelucrare complicată pentru a extrage datele din baza de date. Se
preferă ca în loc de câte o intrucțiune SELECT trimisă către baza de date de fiecare dată, să
se creeze on intrucțiune pentru un filtru mult mai complicat.
3

4. SPARQL
Librăria SemWeb oferă suport pentru interogări SPARQL pentru surse de date care suportă
limbajul de interogare SPARQL și pentru a executa interogări peste diferite endpont-uri
SPARQL.
LinqToRdf
Librăria SemWeb este folosită pentru a implementa LinqToRdf, ceea ce oferă o platformă
pentru lucrul cu OWL și SPARQL.
Greengrass
Un alt framework C# care oferă un API de nivel înalt este Greengrass, ce permite parsarea,
stocarea și manipularea tripelor RDF. Oferă suport pentru serializarea și deserializarea
tipurilor din Common Language Runtime în format RDF, OWL sau alte vocabulare RDF.
ROWLEX
Rowlex este o librărie .NET care poate fi folosită pentru a crea și parcurge fișiere RDF într-un
mod simplu. Ascunde nivelul triplelor RDF și ridică nivelul de programare la clasele OWL si
proprietățile lor.
4