Class::RDF - Perl extension for mapping objects to RDF and back


  use Class::RDF;

  # connect to an existing database
  Class::RDF->set_db( "dbi:mysql:rdf", "user", "pass" );

  # or use a temporary database

  # define xml namespace aliases, export some as perl namespaces.
      rdf => "",
      rdfs => "",
      foaf => "",
  Class::RDF::NS->export( 'rdf', 'rdfs', 'foaf' );

  # eat RDF from the world
  my @objects = Class::RDF->parse( xml => $some_rdf_xml );
  @objects = Class::RDF->parse( uri => $a_uri_pointing_to_some_rdf_xml );

  # build our own RDF objects
  my $obj = Class::RDF::Object->new( $new_uri );
  $obj->rdf::type( foaf->Person );
  $obj->foaf::name( "Larry Wall" );

  # search for RDF objects in the database
  my @people = Class::RDF::Object->search( rdf->type => foaf->Person );
  for my $person (@people) {
      print $person->foaf::OnlineAccount->foaf::nick, "\n";

  my $rdf_xml = Class::RDF->serialize( @people );


  Class::RDF is a perl object layer over an RDF triplestore. 
  It is based on Class::DBI, the perl object / RDBMS package.
  Thus it works with mysql, postgresql, sqlite etc.
  Look in the sql/ directory distributed with this module for database schemas.

  It provides an 'rdf-y' shortcut syntax for addressing object properties.
  It also contains a triples-matching RDF API.




        Class::RDF->set_db( "dbi:mysql:rdfdb", "user", "pass );

Specify the DBI connect string, username, and password of your RDF store. This method just wraps the set_db() method inherited from Class::DBI. If you want a simple temporary data store, use is_transient() instead.


        Class::RDF->is_transient( DIR => "/tmp" );

Specify a temporary data store for Class::RDF. Class::RDF uses File::Temp to create an SQLite data store in a temporary file that is removed when your program exits. Optional arguments to is_transient() are passed to File::Temp->new as is, potentially overriding Class::RDF's defaults. See File::Temp for more details.



Define an alias for an XML namespace. This needs to be done once per program, and is probably accompanied by a Class::RDF::NS->export('short_name').

This should be superseded by a loaded RDF model of namespaces and aliases which comes with the distribution and lives in the database.


        my @objects = Class::RDF->parse( xml => $some_xml );
        my @objects = Class::RDF->parse( uri => $uri_of_some_xml );

Parses the xml either passed in as a string or available at a URI, directly into the triplestore and returns the objects represented by the graph.


        my $xml = Class::RDF->serialise( @objects );

Take a number of Class::RDF::Object objects, and serialise them as RDF/XML.


Class::RDF::Object is the base class for RDF perl objects. It is designed to be subclassed:

        package Person; use base 'Class::RDF::Object';

Create a Class::RDF::Object derived object, then RDF predicate - object pairs can be set on it with a perlish syntax.

RDF resources - that is http:// , mailto: etc URIs, are automatically turned into Class::RDF::Objects when they are requested. To observe them as URIs they have to be referenced as $object->uri->value. RDF literals - ordinary strings - appear as regular properties.

        my $person = Person->new({foaf->mbox => '',
                                  foaf->nick => 'zool'});
        print $person->uri->value;
        print $person->foaf::nick;
        print $person->foaf::mbox->uri->value;


new ( [uri], [{ properties}], [context],[ baseuri] )

        my $obj = Class::RDF::Object->new({ rdf->type => foaf->Person, 
                                            foaf->nick => 'zool'});
        # creates a stored object with blank node uri

        my $obj = Class::RDF::Object->new($uri);
        # creates (or retrieves) a stored object with a uri

        my $obj = Class::RDF::Object->new($uri,$context_uri);
        # creates (or retrieves) a stored object with a uri with a context

search ( predicate => object )

        my @found = $object->search( rdf->type => foaf->Person );
        my $found = $object->search( foaf->mbox );

Search for objects with predicate - object matching pairs. Can also supply a predicate without a corresponding object.


        my $uri = $object->uri;
        print $uri->value;

Returns the uri of the object.


Class::RDF also provides the equivalent of a triples-matching API to the RDF store.

        my @statements = Class::RDF::Statement->search(subject => $uri);
        my @statements = Class::RDF::Statement->search(predicate => foaf->nick,
                                                       object => 'zool');
        my @statements = Class::RDF::Statement->search(context => $uri);

        my @triples = map {$_->triples} @statements;
        # three Class::RDF::Node objects


        my $node = Class::RDF::Node->new($uri); # create or retrieve
        my $exists = Class::RDF::Node->find($uri);


  Class::DBI(3pm), RDF::Simple(3pm) - an RDF aggregator built on Class::RDF




Schuyler D. Erle <>

jo walsh <>


Copyright (C) 2004 by Schuyler Erle & Jo Walsh

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.8.3 or, at your option, any later version of Perl 5 you may have available.