hardf
0.5.0
hardf ist eine PHP 7.1+-Bibliothek, mit der Sie Linked Data (RDF) verarbeiten können. Es bietet:
Sowohl der Parser als auch der Serializer unterstützen Streaming .
Diese Bibliothek ist eine Portierung von N3.js auf PHP
Wir verwenden die dreifache Darstellung in PHP, portiert aus der NodeJS N3.js-Bibliothek. Weitere Informationen finden Sie unter https://github.com/rdfjs/N3.js/tree/v0.10.0#triple-representation
Wir haben uns bewusst auf die Leistung konzentriert und nicht auf die Entwicklerfreundlichkeit. Wir haben diese dreifache Darstellung daher mithilfe assoziativer Arrays anstelle von PHP-Objekten implementiert. Somit ist dasselbe, was für N3.js gilt, jetzt ein Array. Z.B:
<?php
$ triple = [
' subject ' => ' http://example.org/cartoons#Tom ' ,
' predicate ' => ' http://www.w3.org/1999/02/22-rdf-syntax-ns#type ' ,
' object ' => ' http://example.org/cartoons#Cat ' ,
' graph ' => ' http://example.org/mycartoon ' , #optional
];Codieren Sie Literale wie folgt (ähnlich wie N3.js)
' "Tom"@en-gb ' // lowercase language
'" 1 "^^http: //www.w3.org/2001/XMLSchema#integer' // no angular brackets <> Installieren Sie diese Bibliothek mit Composer:
composer require pietercolpaert/ hardf use pietercolpaert hardf TriGWriter ;Eine Klasse, die instanziiert werden sollte und TriG oder Turtle schreiben kann
Beispielanwendung:
$ writer = new TriGWriter ([
" prefixes " => [
" schema " => " http://schema.org/ " ,
" dct " => " http://purl.org/dc/terms/ " ,
" geo " => " http://www.w3.org/2003/01/geo/wgs84_pos# " ,
" rdf " => " http://www.w3.org/1999/02/22-rdf-syntax-ns# " ,
" rdfs " => " http://www.w3.org/2000/01/rdf-schema# "
],
" format " => " n-quads " //Other possible values: n-quads, trig or turtle
]);
$ writer -> addPrefix ( " ex " , " http://example.org/ " );
$ writer -> addTriple ( " schema:Person " , " dct:title " , "" Person " @en " , " http://example.org/#test " );
$ writer -> addTriple ( " schema:Person " , " schema:label " , "" Person " @en " , " http://example.org/#test " );
$ writer -> addTriple ( " ex:1 " , " dct:title " , "" Person1 " @en " , " http://example.org/#test " );
$ writer -> addTriple ( " ex:1 " , " http://www.w3.org/1999/02/22-rdf-syntax-ns#type " , " schema:Person " , " http://example.org/#test " );
$ writer -> addTriple ( " ex:2 " , " dct:title " , "" Person2 " @en " , " http://example.org/#test " );
$ writer -> addTriple ( " schema:Person " , " dct:title " , "" Person " @en " , " http://example.org/#test2 " );
echo $ writer -> end (); //The method names should speak for themselves:
$ writer = new TriGWriter ([ " prefixes " : [ /* ... */ ]]);
$ writer -> addTriple ( $ subject , $ predicate , $ object , $ graphl );
$ writer -> addTriples ( $ triples );
$ writer -> addPrefix ( $ prefix , $ iri );
$ writer -> addPrefixes ( $ prefixes );
//Creates blank node($predicate and/or $object are optional)
$ writer -> blank ( $ predicate , $ object );
//Creates rdf:list with $elements
$ list = $ writer -> addList ( $ elements );
//Returns the current output it is already able to create and clear the internal memory use (useful for streaming)
$ out .= $ writer -> read ();
//Alternatively, you can listen for new chunks through a callback:
$ writer -> setReadCallback ( function ( $ output ) { echo $ output });
//Call this at the end. The return value will be the full triple output, or the rest of the output such as closing dots and brackets, unless a callback was set.
$ out .= $ writer -> end ();
//OR
$ writer -> end ();Neben TriG analysiert die TriGParser-Klasse auch Turtle, N-Triples, N-Quads und die W3C Team Submission N3
$ parser = new TriGParser ( $ options , $ tripleCallback , $ prefixCallback );
$ parser -> setTripleCallback ( $ function );
$ parser -> setPrefixCallback ( $ function );
$ parser -> parse ( $ input , $ tripleCallback , $ prefixCallback );
$ parser -> parseChunk ( $ input );
$ parser -> end ();Rückgabewerte verwenden und diese an einen Writer übergeben:
use pietercolpaert hardf TriGParser ;
use pietercolpaert hardf TriGWriter ;
$ parser = new TriGParser ([ " format " => " n-quads " ]); //also parser n-triples, n3, turtle and trig. Format is optional
$ writer = new TriGWriter ();
$ triples = $ parser -> parse ( " <A> <B> <C> <G> . " );
$ writer -> addTriples ( $ triples );
echo $ writer -> end ();Rückrufe verwenden und diese an einen Autor übergeben:
$ parser = new TriGParser ();
$ writer = new TriGWriter ([ " format " => " trig " ]);
$ parser -> parse ( " <http://A> <https://B> <http://C> <http://G> . <A2> <https://B2> <http://C2> <http://G3> . " , function ( $ e , $ triple ) use ( $ writer ) {
if (! isset ( $ e ) && isset ( $ triple )) {
$ writer -> addTriple ( $ triple );
echo $ writer -> read (); //write out what we have so far
} else if (! isset ( $ triple )) // flags the end of the file
echo $ writer -> end (); //write the end
else
echo " Error occured: " . $ e ;
});Wenn Sie eine große Datei analysieren müssen, müssen Sie nur Teile analysieren und diese bereits verarbeiten. Das können Sie wie folgt machen:
$ writer = new TriGWriter ([ " format " => " n-quads " ]);
$ tripleCallback = function ( $ error , $ triple ) use ( $ writer ) {
if ( isset ( $ error ))
throw $ error ;
else if ( isset ( $ triple )) {
$ writer -> write ();
echo $ writer -> read ();
else if ( isset ( $ error )) {
throw $ error ;
} else {
echo $ writer -> end ();
}
};
$ prefixCallback = function ( $ prefix , $ iri ) use (& $ writer ) {
$ writer -> addPrefix ( $ prefix , $ iri );
};
$ parser = new TriGParser ([ " format " => " trig " ], $ tripleCallback , $ prefixCallback );
$ parser -> parseChunk ( $ chunk );
$ parser -> parseChunk ( $ chunk );
$ parser -> parseChunk ( $ chunk );
$ parser -> end (); //Needs to be called format Eingabeformat (Groß-/Kleinschreibung wird nicht beachtet)turtle - Schildkrötetrig - TriGtriple , z. B. triple , ntriples , N-Triples – N-Triplesquad , z. B. quad , nquads , N-Quads – N-Quadsn3 , zB n3 - N3blankNodePrefix (standardmäßig b0_ ) Präfix, das bei leeren Knotennamen erzwungen wird, z. B. TriGWriter(["blankNodePrefix" => 'foo']) analysiert _:bar als _:foobar .documentIRI legt den Basis-URI fest, der zum Auflösen relativer URIs verwendet wird (gilt nicht, wenn format n-Triples oder n-Quads angibt)lexer ermöglicht die Verwendung einer eigenen Lexer-Klasse. Ein Lexer muss die folgenden öffentlichen Methoden bereitstellen:tokenize(string $input, bool $finalize = true): array<array{'subject': string, 'predicate': string, 'object': string, 'graph': string}>tokenizeChunk(string $input): array<array{'subject': string, 'predicate': string, 'object': string, 'graph': string}>end(): array<array{'subject': string, 'predicate': string, 'object': string, 'graph': string}>explicitQuantifiers - [...] Einige Turtle- und N3-Dokumente verwenden möglicherweise die IRI-Syntax relativ zur Basis-IRI (siehe hier und hier), z
<> <someProperty> "some value" .
Um solche Dokumente richtig zu analysieren, muss der Dokumentenbasis-IRI bekannt sein. Andernfalls könnten wir leere IRIs erhalten (z. B. für den Betreff im obigen Beispiel).
Manchmal ist der Basis-IRI im Dokument kodiert, z
@base <http://some.base/iri/> .
<> <someProperty> "some value" .
aber manchmal fehlt es. In einem solchen Fall verlangt die Turtle-Spezifikation, dass wir Abschnitt 5.1.1 des RFC3986 befolgen, der besagt, dass, wenn der Basis-IRI nicht im Dokument gekapselt ist, davon ausgegangen werden sollte, dass es sich um den Dokumentenabruf-URI handelt (z. B. die URL, von der Sie das Dokument heruntergeladen haben). von oder ein in eine URL umgewandelter Dateipfad). Leider kann dies vom hardf -Parser nicht erraten werden und muss von Ihnen mithilfe der Option zur Erstellung documentIRI Parsers bereitgestellt werden, z
parser = new TriGParser ([ " documentIRI " => " http://some.base/iri/ " ]); Um es kurz subject/predicate/object on line X can not be parsed without knowing the the document base IRI.(...) documentIRI Sie in Zeile
use pietercolpaert hardf Util ;Eine statische Klasse mit einigen hilfreichen Funktionen zur Handhabung unserer spezifischen Dreifachdarstellung. Es hilft Ihnen, Literale und IRIs zu erstellen und auszuwerten und Präfixe zu erweitern.
$ bool = isIRI ( $ term );
$ bool = isLiteral ( $ term );
$ bool = isBlank ( $ term );
$ bool = isDefaultGraph ( $ term );
$ bool = inDefaultGraph ( $ triple );
$ value = getLiteralValue ( $ literal );
$ literalType = getLiteralType ( $ literal );
$ lang = getLiteralLanguage ( $ literal );
$ bool = isPrefixedName ( $ term );
$ expanded = expandPrefixedName ( $ prefixedName , $ prefixes );
$ iri = createIRI ( $ iri );
$ literalObject = createLiteral ( $ value , $ modifier = null );Weitere Informationen finden Sie in der Dokumentation unter https://github.com/RubenVerborgh/N3.js#utility.
Als Beispielimplementierung bieten wir auch zwei einfache Tools in bin/ an: einen Validator und einen Übersetzer. Versuchen Sie zum Beispiel:
curl -H " accept: application/trig " http://fragments.dbpedia.org/2015/en | php bin/validator.php trig
curl -H " accept: application/trig " http://fragments.dbpedia.org/2015/en | php bin/convert.php trig n-triplesWir haben die Leistung zweier Turtle-Dateien verglichen und sie mit der EasyRDF-Bibliothek in PHP, der N3.js-Bibliothek für NodeJS und mit hardf analysiert. Das waren die Ergebnisse:
| #triples | Rahmen | Zeit (ms) | Speicher (MB) |
|---|---|---|---|
| 1.866 | hardf ohne Opcache | 27.6 | 0,722 |
| 1.866 | hardf mit Opcache | 24.5 | 0,380 |
| 1.866 | EasyRDF ohne Opcache | 5.166,5 | 2.772 |
| 1.866 | EasyRDF mit Opcache | 5.176,2 | 2.421 |
| 1.866 | ARC2 mit Opcache | 71.9 | 1.966 |
| 1.866 | N3.js | 24.0 | 28.xxx |
| 3.896.560 | hardf ohne Opcache | 40.017,7 | 0,722 |
| 3.896.560 | hardf mit Opcache | 33.155,3 | 0,380 |
| 3.896.560 | N3.js | 7.004,0 | 59.xxx |
| 3.896.560 | ARC2 mit Opcache | 203.152,6 | 3.570.808 |
Das Urheberrecht der hardf -Bibliothek liegt bei Ruben Verborgh und Pieter Colpaert und sie wird unter der MIT-Lizenz veröffentlicht.
Beiträge sind willkommen und Fehlerberichte oder Pull-Requests sind immer hilfreich. Wenn Sie planen, eine größere Funktion zu implementieren, besprechen Sie dies am besten zunächst, indem Sie ein Problem einreichen.
