Soprano 2.5.2 is the second maintenance release of the 2.5 series.
* Fixed a crash in the Soprano local socket client which could occur
when a multi-threaded client tries to reconnect
* Adjusted the default value for the ServerThreads parameter in the
Virtuoso backend to match the documentation.
Soprano 2.5.1 is the first maintenance release of the 2.5 series. It
features only one change important to the KDE SC: the working directory
of the Virtuoso process is set to the storage directory to avoid random
checkpoint_in_progress files popping up all over the place.
Soprano 2.5.0 - the release to go with KDE SC 4.5.
* New qHash implementation for Statement
* New methods Node::fromN3, Node::fromN3Stream, and stream operator which
allows to parse nodes from N3 encoding.
* Updated NRL ontology namespace
* New comparison operator for BindingSet
* Ported the DBus service watching to QDBusServiceWatcher
* Highly improved server socket handling in the local and tcp socket server
implementation.
* Several improvements in the Virtuoso backend plugin.
2.4.0
* New methods Client::SparqlModel::listStatementsAsync and
Client::SparqlModel::listContextsAsync
* Automatic query prefix expansion in NRLModel
* Automatic NRL metadata graph removal in NRLModel
* sopranocmd:
- New paramter --nrl for sopranocmd which will trigger automatic query
prefix expansion based on prefixes stored in the underlying model,
automatic context creation for imported statements that do not have
one set, and automatic metad ata graph removal on removeContext calls.
- New parameter --graphselect which allows to convert SPARQL select query
results into a graph result. This is very usable since SPARQL construct
queries do not support contexts/named graphs.
- New command 'rmgraph' which allows to delete a list of graphs/contexts.
- New parameter --foo which enables scriptable binding results without
variable names.
* ServerCore is now fully multithreaded allowing two clients perform
read-only commands simultaneously.
* New Virtuoso storage backend which can either connect to a running Virtuoso
instance or spawn one locally.
* New convenience methods to handle BackendSettings.
* New class AsyncQuery which will spawn a new thread for real asnycroneous
query execution (in contrast to AsyncModel which only performs the actual
query call in another thread while the iteration is syncroneous.)
* Removed redland/librdf dependancy from raptor parser.
2.3.2
* Do not fail when trying to index empty strings, but ignore them.
* Fixed parsing of plain literals with language code in sopranocmd.
* Make onto2vocabularyclass work with the redland backend (not using graph
SPARQL queries anymore)
2.3.1
* Changed installation path of cmake modules (SopranoAppOntology.cmake)
to <prefix/share/soprano/cmake
* Prevent the redland backend to add one statement multiple times.
* Properly handle class names containing a dash '-' in onto2vocabularyclass
* sopranocmd: Fail if trying to export a non-graph query
* New class LanguageTag replacing the old simple string language handling
with a sophisticated one implementing RFC 4647. At the same time Soprano
now directly supports plain literals in addition to typed string literals
(compare LiteralValue::createPlainLiteral).
CAUTION: This patch changes behaviour: parsers and storage backends will
now return plain literals instead of typed string literals!
* New static methods Node::resourceToN3, Node::literalToN3, and
Node::blankToN3 for easy N3 formatting without the creation of a Node
instance.
* Fixed both Node::matches and Statement::matches - now only the paramter
is treated as a wildcard
* sopranocmd:
- new paramter --file which allows to execute commands on files directly
without creating a database on disk.
- standard namespace prefixes rdf, rdfs, xsd, nrl, and nao are now added
to sparql queries automatically if used.
- construct and describe query results can now be serialized in all
supported formats.
- New parameter --index which allows to wrap an IndexFilterModel around
the actual Model.
- New command 'monitor' which allows to monitor a remote repository for
statementAdded and statementRemoved signals.
* New class Graph which is a simple QSet based container for statements as
a quick replacement for Model in case one wants to handle a small number
of statements without query support.
* Fixed plugin loading on windows.
* Fixed a deadlock in the IndexFilterModel in case a query could not be
parsed.
* Prevent Model::removeContext to remove empty contexts, i.e. the whole
database.
* Statement::operator<<(QTextStream) now uses a simpler format (only spaces
between nodes and no brackets)
* Updated Sesame2 to 2.2.4
* Added prefix handling to the Serializer API. For a future Soprano version
the Serializer API has to be replaced with something more powerful.
* Improved inference rule handling in the rule parser
This changes the buildlink3.mk files to use an include guard for the
recursive include. The use of BUILDLINK_DEPTH, BUILDLINK_DEPENDS,
BUILDLINK_PACKAGES and BUILDLINK_ORDER is handled by a single new
variable BUILDLINK_TREE. Each buildlink3.mk file adds a pair of
enter/exit marker, which can be used to reconstruct the tree and
to determine first level includes. Avoiding := for large variables
(BUILDLINK_ORDER) speeds up parse time as += has linear complexity.
The include guard reduces system time by avoiding reading files over and
over again. For complex packages this reduces both %user and %sys time to
half of the former time.
* The AsyncModel now has a "real" asyncroneous mode which uses multiple
threads to execute the commands.
* New class Soprano::Client::SparqlModel which provides a client to http
Sparql endpoints.
* Added method Node::toN3 to easily build SPARQL queries without having
to encode nodes all the time.
* New convinience method QueryResultIterator::iterateStatementsFromBindings
* Added convinience methods to handle BackendSettings.
* Added operator[] to QueryResultIterator to easily access bindings
* Added parameters influencing the visibility to onto2vocabularyclass
* Soprano::Node now comes with definitions of qHash for both Node and QUrl
* Sesame2 updated to 2.1.4
* The IndexFilterModel can now optionally index specific URIs
(IndexFilterModel::setForceIndexPredicates)
* Added method IndexFilterModel::optimizeIndex which optimizes the clucene
index on disk
* Added method IndexFilterModel::encodeUriForLuceneQuery which
encodes/escapes a URI so it can be used as a field in a clucene query.
* SPARQL endpoint query support in sopranocmd
* Performace improvements
Soprano (formerly known as QRDF) is a library which provides a highly
usable object-oriented C++/Qt4 framework for RDF data. It uses
different RDF storage solutions as backends through a simple plugin
system. Soprano is targetted at desktop applications that need a RDF
data storage solution. It has been optimized for easy usage and
simplicity.
