# Redland RDF Application Framework - Release Notes

## Redland 0.9.14 Changes

This version of Redland is an update mostly to synchronise with the Raptor version 1.0.0 (RDF/XML and N-Triples parser) - see Raptor NEWS for the changes since 0.9.12.

New in this version is the `rdfproc` utility which allows command line creation of redland stores, parsing of syntaxes and manipulation of the model.

### Configuration changes

Added `--with-raptor` to either choose the system or internal raptor library. If omittted, redland will guess and choose either the system one, if new enough or the internal one (always present).

### Hash Class changes

Added a librdf_hash_put_strings helper method to put a pair of string values into a hash. Useful for making model or storage options.

### Node Class changes

Resource (URI) / literal / blank nodes are now interned on construction so there is only one object for each distinct librdf_node object. This reduces memory and makes copying cheaper at the cost of an increase in construction cost. Copying nodes is very common, since not only is it done for nodes but any time a statement is used or returned. This interning was already done for the URI class but the change required librdf_node to be made immutable, which was done in 0.9.13.

### Storage Class changes

Added librdf_storage_context_as_stream deprecating librdf_storage_context_serialise to be consistent with the *as_stream method name changes to model.

Added librdf_new_storage_with_options taking an librdf_hash of options rather than the string of librdf_new_storage.

Added new optional storage factory methods context_add_statements and context_remove_statements. If omitted, the storage class implements them with context_add_statement and context_remove_statement.

### Stream and Iterator Classes changes

Optimised the stream and iterator internals to do less factory method calls when looking for new items or the end of stream/iterator. This should make them slightly faster.

### Miscellaneous changes

Renamed Redland statics to be `librdf_*` rather than `redland_*`. Added a one-line librdf_short_copyright_string.

### Perl API Changes

Fixed the broken use of `UNIVERSAL::isa`

## Redland 0.9.13 Changes

This version of Redland is a major update to 0.9.12 changing the node class. librdf_node objects are now immutable once created, higher-level language APIs no longer have deal with sharing or copying internals, some additional API support for parsing content from strings.

This includes the stable and complete version 0.9.12 of the Raptor parser which supports all of the revised RDF/XML syntax.

Initial work was added on an ECMA CLI interface using the C# ("C sharp") language.

Blank nodes generated by parsing the syntaxes are now generated more unique (not guaranteed) based on the Redland startup time and a serial number.

The Perl, Python and Java APIs now always return new nodes and statements removing the need to consider sharing at this level. This means that the following operation is legal in Perl, Python and Java:

    # perl
    $n=RDF::Redland::Node->from_uri("http://example.org/foo");
    $s=new RDF::Redland::Statement($n, $n, $n);
    $model->add($s);

    # python
    n=RDF.Uri("http://example.org/foo")
    s=RDF.Statement(n, n, n) # n is used as a resource RDF.Node here
    model.add_statement(s)

### Configuration

Several improvements were made to the building and configuring including a better attempt to find matching Sleepycat/Berkeley DB header and library files (and support BDB up to 4.1), searching for installed Java JDKs and Tcl headers. Each of the language interfaces can be individually enabled to be build, tested and installed with the main C library.

### Node Class changes

The librdf_node class was modifed to make objects immutable once constructed, they cannot be modified. The following set methods were consequently removed.

- librdf_node_set_blank_identifier
- librdf_node_set_li_ordinal
- librdf_node_set_literal_value
- librdf_node_set_type
- librdf_node_set_typed_literal_value
- librdf_node_set_uri

The following utility methods were added (covering all the librdf_node_get_type values):

- librdf_node_is_blank - return non-0 if the node is a blank node
- librdf_node_is_literal - return non-0 if the node is a literal
- librdf_node_is_resource - return non-0 if the node is a URI

(These are reflected into the same methods on the Perl, Python and Java node classes)

`LIBRDF_NODE_TYPE_LI` as returned by librdf_node_get_type was deleted, it was never used.

To support datatyped literals, the following method was added:

- librdf_node_get_literal_value_datatype_uri - get the typed literal datatype URI of the literal node

### Model Class changes

Added librdf_model_sync to sync the model to the backing store.

Added librdf_model_as_stream and librdf_model_context_as_stream to replace librdf_model_context_serialise and librdf_model_context_serialize respectively. This was done both to reduce the confusion with the librdf_serializer class and the mixture of US/UK spelling of that word. The old functions will remain for now.

### Parser Class changes

Added librdf_parser_parse_string_as_stream and librdf_parser_parse_string_into_model to allow parsing content from strings.

### Statement Class changes

Added librdf_statement_is_complete to test if a statement has all the subject, predicate and object fields assigned. Partial statements cannot be added to a model but can be used in matching statement queries with librdf_model_find_statements.

### Storage Class changes

Added librdf_storage_sync to sync the backing store. (This is slightly internal to Redland, you should not be calling this directly)

### Perl Interface Changes

Updated to make the object constructors less verbose and to allow Redland URI objects and native perl URIs to be used in place of Redland Nodes where convienent (such as in making Statements). All existing code should work but can be shortened. A new `--with-perl` configure argument to enable the perl interface.

### Python API changes

A major update to use Python 2.2+ idioms and features by Edd Dumbill with help from Matt Biddulph for unit tests. A new `--with-python` configure argument to enable the python interface. Edd wrote the following change log.

General changes

- Removed string exceptions and replaced with RedlandError ones
- Where underlying Redland C objects were unexpectedly null, raise exceptions rather than returning None, "" or [] as appropriate.
- Raise exceptions if Redland C constructors fail in Python constructors.
- Did quite a lot of documentation updating, where possible demonstrating preferred Pythonic usages.
- Added more unit tests to test changed functionality.

#### RDF.Node class

- Constructor now accepts Uri to make a resource/property node, or a string to make a string literal
- Removed usage of node_type() in favour of is_resource(), is_blank() etc methods.
- DEPRECATED get_blank_identifier() etc. methods in favour of node.blank_identifier etc properties. Raise exception if properties inconsistent with the node type are requested.

#### RDF.Statement class

- No need to name subject, predicate, object in constructor any more. Uris or string literals accepted in place of nodes in constructor argument.
- __getattr__ method deleted, using new-style property() for subject, predicate, object

#### RDF.Model class

- Deleted get_*_iterator methods
- Renamed sources() to get_sources(), targets() to get_targets(), arcs() to get_predicates(). Retained old method names as aliases.
- Added get_sources_context(), get_targets_context(), get_predicates_context() which return (node, context) tuples.
- Amended get_source(), get_sources() etc methods so that Uri and string literals were acceptable as shortcut types for nodes.
- Added find_statements_context() which returns (statement, context) tuples.
- Renamed context_remove_statements() to remove_statements_with_context(). Retained old method name as an alias.
- Added __delitem__ method so del[statement] and del[statement, context] work.
- Added append() method so append(statement) and append(statement, context) work. Suggest that append() is used in preference to add_statement() for Python idiomatic usage.
- DEPRECATED serialise() in favour of as_stream().
- Added as_stream_context() to serialise (statement, context) tuples.
- Exception raised if len() is attempted on model with a non-countable storage.
- DEPRECATED Model.add(), Model.add_typed_literal_statement() usages: now that constructing Statements is easier, it's incongruous to have these in the model. Additionally it saves reproducing various bits of error checking that properly belong in the Node() constructor.
- Implemented __contains__() so "if statement in model" and "if (statement, context) in model" work as expected using the more efficient Redland C methods where possible.

#### RDF.Stream class

- DEPRECATED Stream.context_iter(). Use in preference the _context variants of the appropriate Model methods. This leads to fewer lines of code.

#### RDF.Uri class

- Amended constructor so strings or Uri instances can be passed as the first argument, without named parameters being required, and the right thing still happen.

### Java Interface Changes

Additions for the new API calls as outlined above (such as model/storage sync, parsing from strings etc.). New configure argument `--with-jdk` to pick the JDK in order to find the JNI headers. See the java API page for details.

### PHP, Ruby and Tcl Interfaces Changes

Updates in configuring and building these interfaces and new `--with-php`, `--with-ruby` and `--with-tcl` configure arguments. See the corresponding API pages and installation documentation for details. Tcl now tries to guess the includes directories.

### Internal changes and fixes

- Added Sleepycat/BDB 4.0 and 4.1 support - the open API changed again
- Split the librdf_model class into model interface (librdf_model) and implementation class (librdf_model_storage).
- Removed the old and outdated repat RDF parser.
- Removed the very old expat XML parser from the sources; much newer or expat or libxml2 are very widespread.
- Added simple thread support from patches by Seth Ladd with configuration option `--with-threads` that locks key shared classes to allow separate threads to work in the same memory space. The current locked classes are URI and World.
- Deleting statements in the in-memory store now works.
- Getting the context of iterators returned from in-memory sources, targets, arcs now works.

## Redland 0.9.12 Changes

This version of Redland is a major update to 0.9.11 incorporating a much more improved, complete and stable version 0.9.7 of the Raptor parser and a significant new feature, contexts. The high-level language APIs received some updates and the start of two new languages APIs were added: Ruby and PHP.

Several incompatible API changes were made in this release that effect the C interface and all the higher level language APIs. These were made to support contexts and to fix some inconsistencies in the interface about object ownership.

The persistent storage format was changed to support RDF typed literals and this requires an upgrade of any existing Berkeley/Sleepycat DB stores created by Redland 0.9.11 or earlier. A utility redland-db-upgrade is provided that will create an updated store from an existing one.

A Perl script utils/update-api-0912.pl can help automate the API changes as far as possible or warn about those that cannot be automatically updated.

### New Feature - Contexts

This feature allows a Node to be given whenever a statement is added to a model which can can be retrieved from any model query that returns answers as an Iterator of Nodes or a Stream of Statements. Both of these classes gained a new method `get_context` that returns the original Node that was given when the statement corresponding to the answer was added to the model.

The context node can also be used to add and remove sets of statements to/from a model, and each statement with a given context node can be listed as a stream of statements.

Adding this feature required substantial internal changes to these two classes and the internal storage apis and implementations along with moderate code changes at the application level, which are described below.

This feature can be used for the following (not an exhaustive list):

- Enable true graph merging / updating / demerging - identify the subgraphs with context nodes.
- Statement Identity - add each statement with a different context node
- Statement Provenance - use the context node as the subject of other statements about the statement that is returned.

### Iterator Class Changes

The Iterator `get_next` method was split into `get_object` always returning a pointer to a shared object and the `next` method to advance the iterator. The `get_object` method is generally called `current` in the higher level language APIs.

(Iterator and Stream now have consistent method names; they may be merged in future.)

The `get_object` method now always returns a pointer to a shared object. If this object is needed outside the scope of an iteration, it must be copied, which for Nodes is the copy constructor `librdf_new_node_from_node`.

C example for Redland 0.9.11 and earlier:

      while(!librdf_iterator_end(iterator)) {
        node=(librdf_node*)librdf_iterator_get_next(iterator);
        /* do something with the node */
      }

Redland 0.9.12:

      while(!librdf_iterator_end(iterator)) {
        node=(librdf_node*)librdf_iterator_get_object(iterator);
        /* do something with the node */
        librdf_iterator_next(iterator);
      }

A new method `get_context` was added returning a Node for the context of the original Statement that generated the Iterator Node.

C Iterator context example:

      while(!librdf_iterator_end(iterator)) {
        node=(librdf_node*)librdf_iterator_get_object(iterator);
        context_node=(librdf_node*)librdf_iterator_get_context(iterator);
        /* do something with the node and its context */
        librdf_iterator_next(iterator);
      }

### Model Class Changes

The Model `add_statement` method no longer takes ownership of the passed in statement object. The caller now retains ownership and can reuse the statement several times and has responsibility for freeing it if need be (when it isn't shared).

C example for Redland 0.9.11 and earlier:

      librdf_model_add_statement(model, statement);

Redland 0.9.12:

      librdf_model_add_statement(model, statement);
      librdf_free_statement(statement);

C streaming statement example for Redland 0.9.11 and earlier:

      while(!librdf_stream_end(stream)) {
        librdf_statement *statement=librdf_stream_next(stream);
        /* This statement is new, so could be added directly */
        librdf_model_add_statement(model, statement);
      }

Redland 0.9.12:

      while(!librdf_stream_end(stream)) {
        librdf_statement *statement=librdf_stream_get_object(stream);
        /* This statement is now shared so can still be just added */
        librdf_model_add_statement(model, statement);
      }

`librdf_model_add_string_literal_statement` lost the xml_space argument.

A new method was added to add a Statement with an RDF datatyped literals object:

      int librdf_model_add_typed_literal_statement(librdf_model* model,
         librdf_node* subject,
         librdf_node* predicate,
         char* string, char *xml_language, librdf_uri *datatype_uri);

This should be used in preference to `librdf_model_add_string_literal_statement` which remains in the API as a wrapper around the above.

New methods were added to add, remove and list Statements to contexts.

      /* Add a single statement to the model with context */
      int librdf_model_context_add_statement(librdf_model* model,
        librdf_node* context, librdf_statement* statement);

      /* Add all statements on the stream to the model with context */
      int librdf_model_context_add_statements(librdf_model* model,
        librdf_node* context, librdf_stream* stream);

      /* Remove a single statement from the model with the given context */
      int librdf_model_context_remove_statement(librdf_model* model,
        librdf_node* context, librdf_statement* statement);

      /* Remove all statements from the model with given context */
      int librdf_model_context_remove_statements(librdf_model* model,
        librdf_node* context);

      /* List all statements in the model with the given context */
      librdf_stream* librdf_model_context_serialize(librdf_model* model,
        librdf_node* context);

### Node Class Changes

The Node class gained a new constructor:

      librdf_node* librdf_new_node_from_typed_literal(
        librdf_world *world,
        const char *string,
        const char *xml_language,
        librdf_uri* datatype_uri);

that should be used in preference to `librdf_new_node_from_literal` which remains in the API as a wrapper around the above.

`librdf_node_new_nodefrom_literal` lost the xml_space argument.

### Parser Class Changes

The Parser class has an updated Raptor parser version 0.9.7 - parsers named `raptor` for RDF/XML (MIME Type `application/rdf+xml`) and `ntriples` for N-Triples. See the Raptor NEWS for the detailed changes since 0.9.5 in the last release of Redland.

The Java SiRPAC parsers `sirpac-stanford`, `sirpac-w3c` and the W3C LibWWW parser `libwww` have been removed. Raptor replaces them.

### Serializer Class Changes

The Serializer class gained a new method:

      int librdf_serializer_serialize_model_to_file(
        librdf_serializer* serializer,
        const char *name,
        librdf_uri* base_uri,
        librdf_model* model);

This writes the serialized model to a filename (rather than a file handle as done by `librdf_serializer_serialize_model`) which is easier to use from higher level language APIs until a cross-language I/O abstraction is available.

The class gained an RDF/XML serializer that can be called either by the name `rdfxml` or the MIME Type `application/rdf+xml`. The examples in each language have been updated to demonstrate using this.

### Storage Class Changes

The built in storage factories (`memory`, `hashes`) now both support contexts. These are enabled by adding the storage option `contexts='yes'` to the options string. The hashes storage additionally supports indexing predicates as an extra hash which can be enabled with `index-predicates='yes'`. This makes triple queries of the form (subject unknown, predicate known, object unknown) fast.

C Example of creating a 0.9.12 storage that does contexts using on-disk Berkeley/Sleepycat DB:

       storage=librdf_new_storage(world,
         "hashes",
          name,
         "hash-type='bdb',write='yes',new='yes',contexts='yes'");

### Stream Class Changes

The Stream `next` method was split into `get_object` always returning a pointer to a shared Statement and the `next` method to advance the iterator. The `get_object` method is generally called `current` in the higher level language APIs.

(Iterator and Stream now have consistent method names; they may be merged in future.)

C example for Redland 0.9.11 and earlier:

      while(!librdf_stream_end(stream)) {
        statement=(librdf_statement*)librdf_stream_next(stream);
        /* do something with the statement */
      }

Redland 0.9.12:

      while(!librdf_stream_end(stream)) {
        statement=(librdf_statement*)librdf_stream_get_object(stream);
        /* do something with the statement */
        librdf_stream_next(stream);
      }

A new method `get_context` was added returning a Node for the context of the Statement.

C Stream context example:

      while(!librdf_stream_end(stream)) {
        statement=(librdf_statement*)librdf_stream_get_object(stream);
        context_node=(librdf_node*)librdf_stream_get_context(iterator);
        /* do something with the statement and its context node */
        librdf_stream_next(stream);
      }

### Perl Interface Changes

The Perl interface moved to the `RDF::Redland` package (the `RDF` namespace was deprecated in 0.9.11).

The interface was updated to receive Redland error and warning messages callbacks. These can be set using the `RDF::Redland::set_error_handler` and `RDF::Redland::set_warning_handler` subroutines taking a subroutine argument. They are called with a single scalar argument which is the Redland message.

The interface was updated to match the Interator and Stream changes described above.

Perl iterator example for Redland 0.9.11 and earlier:

      while(!$iterator->end) {
        my $node=$iterator->next;
        # do something with the node
      }

Redland 0.9.12:

      while(!$iterator->end) {
        my $node=$iterator->current;
        # do something with the node
        $iterator->next;
      }

Perl stream example for Redland 0.9.11 and earlier:

      while(!$stream->end) {
        my $statement=$stream->next;
        # do something with the statement
      }

Redland 0.9.12:

      while(!$stream->end) {
        my $statement=$stream->current;
        # do something with the statement
        $stream->next;
      }

Perl example of using the Serializer class:

      # Use any rdf/xml parser that is available
      my $serializer=new RDF::Redland::Serializer("rdfxml");
      $serializer->serialize_model_to_file("output.rdf", $uri, $model);

### Python API Changes

The Python interface gained pydoc comments, along with an HTML derived version.

The interface was updated to receive Redland error and warning messages callbacks as python exceptions. These can be caught using the standard python try {} catch {} blocks.

The interface was updated to match the Interator and Stream changes described above.

Python iterator example for Redland 0.9.11 and earlier:

      while not iterator.end():
        node=iterator.next()
        # do something with the node

Redland 0.9.12:

      while not iterator.end():
        node=iterator.current()
        # do something with the node
        iterator.next()

Python stream example for Redland 0.9.11 and earlier:

      while not stream.end():
        statement=stream.next()
        # do something with the statement

Redland 0.9.12:

      while not stream.end():
        statement=stream.current()
        # do something with the statement
        stream.next()

Python example of using the Serializer class:

      # Use any rdf/xml parser that is available
      serializer=RDF.Serializer()
      serializer.serialize_model_to_file("output.rdf", model)

### Java Interface Changes

The Java classes were updated to have a `finished()` method that the user can call to cleanup objects replacing the rather useless Java `finalize()` method that gives no guarantees to when it is called.

The Java API is still experimental and may change further.

## Redland 0.9.1 - Redland 0.9.11 Changes

Release notes for 0.9.11 and earlier are in the NEWS page or ChangeLog

Copyright 2003 Dave Beckett, Institute for Learning and Research Technology, University of Bristol