ARC is an open source collection of lightweight PHP scripts optimized for RDF development on hosted Web servers. It currently consists of a non-validating RDF/XML parser, an N-Triples Serializer, and a "Simple Model" class providing common methods for working with resource descriptions. The three main classes are stand-alone, single-file scripts, thus facilitating the bundling with existing PHP-based applications. By partly using arrays instead of objects, ARC offers speed improvements compared to toolkits that follow approaches completely based on PHP objects.
The RDF/XML Parser class can be used to parse a passed string, to load and parse data from the local machine, or to load and parse data from the Web. The built-in Web reader does not follow HTTP redirects yet, but it accepts several parameters to e.g. work with proxies, send custom HTTP headers, or limit the number of lines to 1 ARC stands for appmosphere RDF classes. The classes and documentation are available online at http://www.appmosphere.com/en-arc parse. Additionally, the class can be configured to retrieve content-negotiated RDF/XML (via an HTTP Accept header) , or to keep the raw RDF/XML data and/or response headers of the remote server in memory. The code snippet below shows a usage example.
/* class inclusion */ include_once("ARC_rdfxml_parser.php"); /* class configuration (optional) */ $args=array( "encoding"=>"auto",/* auto-detect UTF-8 etc */ "proxy_host"=>"192.168.27.1", "proxy_port"=>8080, "user_agent"=>"myParser v1.0" ); /* instantiation */ $parser=new ARC_rdfxml_parser($args); /* parsing a file from the Web */ $url="http://www.example.com/data.rdf"; $result=$parser->parse_web_file($url); if(is_array($result)){
echo count($result)." triples found"; } else{
echo "couldn't parse ".$url.": ".$result; } The parser does not check the parsed code for complete RDF-validity, only XML errors and some very basic RDF/XML syntax [2] errors are detected. The result of the parsing process is either an error message or an array of triples.
The serializer class generates an N-Triples [3] string from an array of triples. The structure of the passed triple array has to conform to the following ARC triple array structure:
Each entry is an associative array with keys s, p, and o: - s (a subject node array) - p (a predicate URI string) - o (an object node array)
An object node array may contain additional key-value pairs: - type ("uri", or "bnode", or "literal") - uri (if type is "uri") - bnode_id (if type is "bnode") - val (if type is "literal") - dt (datatype URI if available and type is "literal") - lang (language code if available and type is "literal") The serializer provides only a small number of configuration options. It is possible to set the linebreak and the space characters as illustrated below.
/* class inclusion */ include_once("ARC_ntriples_serializer.php"); /* class configuration (optional) */ $args=array("linebreak"=>"\n", "spacer"=>"\t"); /* instantiation */ $ser=new ARC_ntriples_serializer($args); /* displaying the N-Triples code */ echo $ser->get_ntriples($triples);
ARC's Simple Model class indexes a triple array and offers methods to e.g. return a list of resources, find resources based on a provided identifier, parse RDF lists, or extract property values. A detailed usage example is given in section 3.
By combining the RDF/XML Parser (or an adjusted triple array queried from a basic RDF triple store) with the Simple Model class, it is easily possible to generate HTML views from RDF. Figure 1 shows a resource description summary which could be created by passing two Simple Model instances (one with vocabulary information, and one with data about individuals) to an HTML rendering script. The latter is not included in ARC but the PHP code snippets below Fig. 1 exemplify how data can be pre-processed by ARC in order to retrieve grouped property values and label information. /* abbreviations */ $rdfs="http://www.w3.org/2000/01/rdf-schema#"; $foaf="http://xmlns.com/foaf/0.1/"; /* vocabulary model */ $v_triples=$parser->parse_web_file($foaf); $model_args=array( "triples"=>$v_triples, "ns_abbrs"=>array($foaf=>"foaf", $rdfs=>"rdfs") ); $v_model=new ARC_simple_model($model_args); /* data model */ $d_url="http://www.example.com/my_foaf.rdf"; $d_triples=$parser->parse_web_file($d_url); $model_args["triples"]=$d_triples; $d_model=new ARC_simple_model($model_args);
ARC: appmosphere RDF Classes for PHP Developers 5 PHP code to find a foaf:Person resource in a foaf:PersonalProfileDocument: /* find PPD in data model */ $ppd_qname="foaf:PersonalProfileDocument"; if(!$ppds=$d_model->get_resources($ppd_qname)){ return false; } $ppd=$ppds[0]; /* get person identifier via primaryTopic */ if(!$id=$d_model->rpv2($ppd, "foaf:primaryTopic")){ return false; } $person=$d_model->get_resource($id); PHP code to display labeled property values: } } }
} /* name value */ $name_val=$d_model->rpv($person, "foaf:name"); if(!$name_val){
/* try alternative naming properties */ /* mbox values */ $cur_vals=array(); if($cur_props=$person["props"]["foaf:mbox"]){ foreach($cur_props as $cur_prop){
$cur_vals[]=$cur_prop["val"]; /* mbox label (use vocabulary model) */ if($terms=$v_model->get_resources("foaf:mbox")){ $term=$terms[0];/* an rdf:Property instance */ $cur_label=$v_model->rpv($term, "rdfs:label"); /* display */ echo '<h2>'.$name_val.'</h2>'; echo ($cur_label) ? $cur_label : "mbox"; echo "- ".join("<br />- ", $cur_vals); 2 "rpv" is an alias for the method "get_resource_prop_val" which retrieves a single property value for a given resource. Further use cases include reading, importing, and displaying of RSS 1.0 feeds, or any other RDF/XML-compatible data. At the moment, ARC is best suited for rapid RDF development or as a small addition to existing codebases, but the classes have already been successfully tested in larger projects (e.g. the new SemanticWeb.org portal) as well.
RAP is currently the only other toolkit written completely in PHP (which is a prerequisite to be deployable to cheap hosted Web server environments) that conforms to the revised RDF specifications [4]. The performance tests done for this paper are limited to comparing the RDF/XML parsers. A third option (w.r.t. to parsing RDF) is Morten Frederiksen's SimpleRdfParser [5], a wrapper class for RAP that uses arrays instead of RAP's internal objects; it was tested as well. The Redland Application Framework [6] also provides bindings for PHP [7]. However, the PHP bindings can neither be installed on average hosted Web servers nor on the Windows machine that was used for the performance tests3. Redland was not included in the benchmarks. It would have been an interesting reference, though.
The tests were run on a desktop PC (Pentium IV 1.8 GHz, Windows 2000), using PHP 4.3.6, and the xdebug extension [8] for profiling. The long execution times in the benchmark results are caused by having to disable Zend optimizer while using the profiling extension. Switching back from xdebug to the Zend optimizer accelerates the parsers by a factor of 4.
ARC (v0.2.0), SimpleRdfParser, and RAP (v0.9.1) were tested with 3 different files: 1. An RSS 1.0 news feed (338 triples) 2. The W3C RDF test cases manifest file4 (2160 triples) 3. A large FOAF file (8601 triples) RDF files beyond this size are usually stored in a database, these tests cover common in-memory parsing tasks only. As the SimpleRdfParser can't load files directly, each test passes the RDF/XML code as a single string variable to the parser. 3 Installing the bindings was not possible with the existing PHP engine. It would have been neccessary to re-compile the PHP sources. 4 http://www.w3.org/2000/10/rdf-tests/rdfcore/Manifest.rdf The benchmark results6 show that using the SimpleRdfParser is about two to four times faster than building a complete in-memory model via RAP. ARC is about twice as fast as the SimpleRdfParser. The difference between using PHP objects vs. arrays becomes more obvious with a growing number of triples in a model. While the SimpleRdfParser is 1.5 times faster than RAP when parsing the smallest RDF file, it is 3.7 times faster at parsing the 2160 triples, and about 5 times faster when processing the large file.
These tests don't consider that RAP is not only parsing but also building indexes and validating the parsed code. But it could still make sense to examine the xdebug results in more detail in order to see if RAP may be partly made faster. ARC's speed could for example be improved by working around PHP's automatic type conversion mechanism (e.g. by using "===" instead of "==") and by applying simple string functions such as strpos instead of regular expressions.
ARC is a lightweight alternative (or addition) to RAP's feature-rich API when only limited functionality such as parsing or displaying is required. Being open source and written entirely in PHP, the RDF classes can be bundled with PHP frameworks and used in shared Web hosting environments. The advantage of using PHP arrays instead of object structures increases with the size of parsed RDF/XML documents. The main idea of ARC is to provide lightweight RDF classes. However, several options have already been added to ARC which might not be needed for certain use cases. It is planned to build a simple parser generation service which will allow developers to tailor the ARC scripts to their needs. It will be possible to e.g. exclude the method for using an HTTP socket instead of PHP's one-line fopen function, or to automatically remove comments. Together with other configuration options the parser's size could be reduced to 20KB or less. 5 xdebug had to be disabled for this test as it needed to much main memory to profile RAP 6 The complete benchmark details can be downloaded from