Free rdf software for linux

RDF::Notation3 is a RDF Notation3 parser.

SYNOPSIS

$rdf = RDF::Notation3::Triples->new();
$rdf->parse_file($path);
$triples = $rdf->get_triples;

$rdf = RDF::Notation3::XML->new();
$rdf->parse_file($path);
$string = $rdf->get_string;

$handler = SAXHandler->new();
$rdf = RDF::Notation3::SAX->new(Handler => $handler);
$rdf->parse_file($path);

$rdf = RDF::Notation3::RDFCore->new();
$storage = RDF::Core::Storage::Memory->new();
$rdf->set_storage($storage);
$model = $rdf->parse_file($path);
$n3 = $rdf->get_n3($model);

$rdf = RDF::Notation3::RDFStore->new();
$rdf->set_options({ Name => test, Split => 20 });
$model = $rdf->parse_file($path);

This module is an RDF/N3 parser; it can parse N3 files or strings and provide results in whatever format (as far as there are subclasses supporting your desired format available).
RDF::Notation3 is a base class providing the parsing logic only. This class is never used directly.

Instead, derived classes such as RDF::Notation3::Triples or Notation3::XML are used. The subclasses control how results of parsing are processed and can provide additional methods to access the results then. RDF::Notation3 doesnt tend to create sophisticated in-memory or persistent RDF structures of its own; it should more likely serve as a parser for other Perl RDF modules (such as RDF::Core) focused on how to store and access RDF models.

RDFParser project is a PHP class that loads and parses RDF and RSS files. These are XML files that are used by many Websites to syndicate headlines.
The class provides an interface to the loaded file and makes it simple to generate lists/ tables of the source sites headlines.
Enhancements:
- The old PHP3 code has been completely replaced with new a new PHP4/5 compliant parser.
- The new code uses PHPs built-in SAX parser (rather than regular expressions), which means it is much faster than the old code; even a large RSS file like freshmeats is parsed in under two hundredths of a second (2800XP/PHP 4.4.0/ Apache 2.0.55).
- The new code is also more flexible with regard to parsing slightly non-standard RSS/RDF files.

Redland RDF library is a set of free software packages that provide support for the Resource Description Framework (RDF).
Main features:
- Modular, object based libraries written in C.
- APIs for manipulating the RDF graph, triples, URIs and Literals.
- Triple sequences for efficient streaming.
- Parsers and Serializers for reading and writing RDF as RDF/XML, N-Triples and Turtle Terse RDF Triple Language syntaxes via the Raptor RDF Parser Toolkit.
- Storage for graphs in memory, with Sleepycat/Berkeley DB, MySQL 3/4, AKT Triplestore, SQLite, files or URIs.
- Querying with RDQL and SPARQL using the Rasqal RDF Query Library.
- Redland contexts for managing data aggregation and recording provenance.
- Language Bindings in C#, Java, Obj-C, Perl, PHP, Python, Ruby and Tcl via the Redland Bindings package.
- Command line utility programs rdfproc (RDF), rapper (parsing) and roqet (query).
- Portable, fast and with no known memory leaks.
Enhancements:
- The code was updated to use Rasqal RDF query library 0.9.14 and Raptor RDF parser/serializer library 1.4.15.
- A new transaction API was added, implemented with MySQL for consistent changes to the graph.
- A new query results formatter class was added.
- Many other bugs were fixed.

RDF::Sesame::Repository is a repository on a Sesame server.

This class is the workhorse of RDF::Sesame. Adding triples, removing triples and querying the repository are all done through instances of this class. Only SELECT queries are supported at this point, but it should be fairly straightforward to add CONSTRUCT functionality. If you do it, send me a patch.

METHODS

construct ( %opts )
Evaluates a construct query and returns the RDF serialization of the resulting RDF graph. A minimal invocation looks something like:
my $q = qq(
CONSTRUCT {Parent} ex:hasChild {Child}
FROM {Child} ex:hasParent {Parent}
USING NAMESPACE
ex =
);
my $rdf = $repo->construct(
query => $q,
format => turtle,
);

If an error occurs during the construction, an exception is thrown. This is different from some RDF::Sesame methods which return undef.
format

Required: Yes

Indicates the RDF serialization format that the Sesame server should return. Acceptable values are rdfxml, turtle and ntriples.
language

Default: SeRQL

Specifies the language in which the construct query is written. This is only included for forwards-compatibility since the only query language supported by Sesame is SeRQL.

output

Default: undef

Indicates where the RDF serialization should be placed. The default value of undef means that the serialization should simply be returned as the value of the construct method.

If the value is a filehandle, the serialization is written to that filehandle. The filehandle must already be open for writing. Otherwise, the value is taken to be a filename which is opened for writing (clobbering existing contents) and the serialization is written to the file.

query

Required : Yes

The text of the construct query.

extract ( %opts )

Extract an RDF representation of all the triples in the repository. The only required option is "format" which specifies the serialization format of the resulting RDF. The minimal method invocation looks like

my $rdf = $repo->extract( format => turtle )

where $rdf is a reference to a scalar containing the serialization of all the triples in the repository. The streaming results returned by Sesame are handled appropriately so that memory usage in minimized. If the output is sent to a file (see "output"), only one "chunk" is held in memory at a time (subject to caching by your OS). The serialization may also be compressed (or otherwise processed) as its being streamed from the server (see "compress").

Error handling is done differently in this method than in other methods in RDF::Sesame. Namely, if an error occurs, an exception is thrown (rather than returning undef and setting errstr(). Eventually, Id like all methods to behave this way.

RDFStore::Parser::SiRPAC is a Perl module that implements a streaming RDF Parser as a direct implementation of XML::Parser::Expat.

SYNOPSIS

use RDFStore::Parser::SiRPAC;
use RDFStore::NodeFactory;
my $p=new RDFStore::Parser::SiRPAC(
ErrorContext => 2,
Handlers => {
Init => sub { print "INITn"; },
Final => sub { print "FINALn"; },
Assert => sub { print "STATEMENT - @_n"; }
},
NodeFactory => new RDFStore::NodeFactory() );

$p->parsefile(http://www.gils.net/bsr-gils.rdfs);
$p->parsefile(http://www.gils.net/rdf/bsr-gils.rdfs);
$p->parsefile(/some/where/my.rdf);
$p->parsefile(file:/some/where/my.rdf);
$p->parse(*STDIN); #parse stream but with *blocking* Expat (see below example for n-blocking parsing using XML::Parse::ExpatNB)

use RDFStore::Parser::SiRPAC;
use RDFStore::NodeFactory;
my $pstore=new RDFStore::Parser::SiRPAC(
ErrorContext => 2,
Style => RDFStore::Parser::Styles::RDFStore::Model,
NodeFactory => new RDFStore::NodeFactory(),
store => {
persistent => 1,
seevalues => 1,
options => { Name => /tmp/test }
}
);
my $rdfstore_model = $pstore->parsefile(http://www.gils.net/bsr-gils.rdfs);

#using the expat no-blocking feature (generally for large XML streams) - see XML::Parse::Expat(3)
my $rdfstore_stream_model = $pstore->parsestream(*STDIN);

This module implements a Resource Description Framework (RDF) streaming parser completely in Perl using the XML::Parser::Expat(3) module. The actual RDF parsing happens using an instance of XML::Parser::Expat with Namespaces option enabled and start/stop and char handlers set. The RDF specific code is based on the modified version of SiRPAC of Sergey Melnik in Java; a lot of changes and adaptations have been done to actually run it under Perl. Expat options may be provided when the RDFStore::Parser::SiRPAC object is created. These options are then passed on to the Expat object on each parse call.

Exactly like XML::Parser(3) the behavior of the parser is controlled either by the Style entry elsewhere in this document and/or the Handlers entry elsewhere in this document options, or by the setHandlers entry elsewhere in this document method. These all provide mechanisms for RDFStore::Parser::SiRPAC to set the handlers needed by Expat. If neither Style nor Handlers are specified, then parsing just checks the RDF document syntax against the W3C RDF Raccomandation . When underlying handlers get called, they receive as their first parameter the Expat object, not the Parser object.

To see some examples about how to use it look at the sections below and in the samples and utils directory coming with this software distribution.
E.g. With RDFStore::Parser::SiRPAC you can easily write an rdfingest.pl script to do something like this:

fetch -o - -q http://dmoz.org/rdf/content.rdf.u8.gz |
gunzip - |
sed -f dmoz.content.sed | rdfingest.pl -

RDQLPlus provides a Java RDQL tool, featuring zoomable query results.
It can work with existing RDF files, Jena2 RDF databases, and a native Java database called Mckoi.
Main features:
- INSERT and DELETE statements into/from RDF graphs ("Models")
- CREATE and DROP entire models in RDF storage locations ("Stores")
- DUMP and LOAD models in RDF/XML, N-TRIPLES, and N3 format
- Copy RDF graphs (or sub-graphs) from one model to another
- Query and work with inference models (using one of Jenas reasoners) given an ontology and an instance model
- Output query results in text form
Version restrictions:
- Some filesystem store files arent recognized, even though theyre listed with the STORES command. If youre having this problem, just rename the file to something simpler, like "myfile.rdf".
- After creating and DROPping an inference model, models that it depends on may not be DROPpable until re-starting RDQLPlus. When you try to DROP such a model, you will be told it was succesfully dropped. But listing MODELs will reveal it is still there.
- You absolutely need version 1.10 of GraphViz to run RDQLPlus. Older versions can create unexpected output, which causes ZVTM to throw a NullPointerException at times.
- On-line help via the HELP command doesnt provide much detail yet. The RIDIQL Reference does.