2.9.4
	* Automatically delete fault transaction logs
	* Virtuoso backend supports parameterized queries which seem to consume
	  less memory when inserting large amounts of plain text
2.9.3
	* Fix bugs in FilterModel
	* Optimize literal to N3 conversion
	* Virtuoso Backend - Optimize by around 5x
	* Fix potential memory leak in ErrorCache

2.9.2
	* Fix a crash in ServerCore on shutdown
	* Do no require X11 - not needed for compilation
	* Generate tag file for API docs

2.9.1
    * Faster streaming for datetime literals
	* Add a stop method in the LocalServer
	* Fix bugs in LocalSocket and AsyncQuery

2.9.0
	* Better error handling on the Client::LocalSocketClient
	* New DataStream class which shares code between the server and client
	* New boolean option "emptyGraphs" in the Virtuoso backend, which can
		enable/disable checks for empty graphs
	* New boolean option "fakeBooleans" in the virtuoso backend, which can
		enable/disable fake boolean support
	* Client and Server code optimizations

2.8.0
	* Improved NRLModel query prefix expansion.
	* Support for plain SQL queries in the Virtuoso backend.
	* Introduced new query language flag QueryLanguageSparqlNoInference. This language is
          not supported by any backends. It is supposed to be used in clients like Nepomuk
          to avoid the usage of long user types which are harder to read.
	* Convert Virtuoso IRI_ID values into simple literal strings. At some point if the
          need arises we might call ID_TO_IRI() to convert them into URIs.
	* New boolean option "noStatementSignals" in the Virtuoso backend which will disable
	  Model::statementsAdded() and friends.
	* Improved local unix socket communication in the server/client system:
          A custom socket implementation as a replacment for QLocalSocket makes it possible to
          use one socket across threads.
 
2.7.6
	* Support for the new SPARQL 1.1 DELETE statement which omits the graph to delete from
	  for faster removeAllStatement execution.
	* Support for the new default graph query result format of Virtuoso >= 6.1.5
	* Fixed apidox generation with Doxygen 1.8.0.

2.7.5
	* Be less strict when converting a string to a QDateTime:
          - Allow an empty time part, ie. "2011-10-04".
          - Allow the usage of a space instead of "T" to separate date from time.
	* Fixed URI parsing in the SparqlModel.
	* Fixed an endless loop in the VirtuosoModel destruction which can happen in rare error cases.
	* Fixed serialization of non-string literal values.
	* Support Turtle result encoding in the SPARQL model.

2.7.4
	* Enabled large file support (_FILE_OFFSET_BITS=64) to fix large DB file locking on 32bit machines.
	* Do not use an event loop when waiting for Virtuoso to initialize.
	* In the socket client: simply close the connection in case of a timeout. We cannot recover from it
	  anyway.

2.7.3
	* Added new signal in the Virtuoso backend which signals when the server goes down.
	* Soprano can be built with cmake 2.6.4 again.

2.7.2
	* Reverted a change which was introduced in 2.7.1 to use a separate QDBusConnection for the 
          DBusExportModel. It made things worse.
        * Fixed a crash in NRLModel caused by a non-mutex-protected hash.
	* Fixed the Virtuoso backend's option "forcedstart". Now the backend waits for the running instance
	  to be shut down before trying to start a new one.

2.7.1
	* Lowered the min Raptor version to 2.0.0 since it was only a runtime dependancy for KDE.

2.7.0
	* Use the new Virtuoso parameter XAnyNormalization to use normalized accents for full-text searching by default.
	* Updated NAO Vocabulary namespace to include changes from SDO 0.7.
        * Added method LiteralValue::fromVariant which provides some useful type conversions.
	* Fixed incorrect binding names counting in redland queries
        * Ported Raptor serializer and parser plugins to Raptor2.

2.6.1
	* Let onto2vocabularyclass convert dots in entity names to underscores to create valid C++ names.
	* Register DBus types in Client::DBusModel to make sure it can be used without Client::DBusClient.
	* Fixed error propagation in Utils::AsyncQuery.
	* Use a separate QDBusConnection for the DBusExportModel to avoid crashes.

2.6.0
	* Fixed handling of xsd:boolean in SPARQL queries in the Virtuoso backend
          (this is a hack that might not work in all situations)
	* Added new parameter for the Virtuoso backend: QueryTimeout allows to set a maximum query exeution time.
	* Added new parameter for the Virtuoso backend: RestartOnCrash will restart the Virtuoso server if it crashes.
	* QueryResultIterator::next() now always returns false for boolean results. This breaks behaviour
	  compared to previous versions. However, always returning true as before results in endless loops if
	  the client does not check the type of the query result. Thus, in the interest of stability this change
	  has been made anyway.
	* Lock the storage dir of a running virtuoso instance to avoid reusing it.

2.5.0
	* New public qHash method for Statement
	* New Node::fromN3 method and operator>> which allows to parse nodes from N3 encoding.
	* Updated NRL ontology namespace
	* New 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.4
	* Fix to FindIODBC.cmake which ensures that the correct locations are searched first. This
	  allows the usage of a locally installed libiodbc.
	* Fixed a bug in the Virtuoso backend's query construction code.
	* Fixed value of AsyncQuery::bindingNames().
	
2.4.3
	* Quick and ugly fix for LocalSocketClient::isConnected which actually tries to connect instead
	  of checking if a connection has been established in the current thread.

2.4.2
	* LocalSocketClient and TcpClient: do not re-establish a connection on model deletion.
	  (This fixes a crash when using a client as a global static)
	* Properly protect ErrorCache from multithread clashes. (Thanks to Andreas Hartmetz for the patch)
	* Slight optimizations in the Virtuoso backend.
	* Do not crash in ClientModel when the connection is lost.

2.4.1
	* Virtuoso backend: 
	  - new parameter "forcedstart" which when set will make the backend shut down
	    any running Virtuoso instance already accessing the storage dir (does not work on Windows).
	  - Shut down Virtuoso using the SIGINT signal (not available on Windows) to ensure
 	    a checkpoint.
	* Allow to build Soprano with -fvisibility=hidden -fvisibility-inlines-hidden (thanks to
	  Modestas Vainius of Debian for the patch)
	* PkgConfig files for sopranoclient, sopranoserver, and sopranoindex.

2.4.0.1
	* Fixed a bug in the ClientConnection where mutex was deleted before it had been unlocked.

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

2.3
	* 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).
	  (thanks to Greg Beauchesne for the patch)
	  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
	
2.2
	* 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

2.1.2
        * Better URI encoding in DBus communication, fixes problems with some special characters in URIs.

2.1
	* SignalCacheModel to restrict the number of emitted statementsAdded and statementsRemoved signals
	  in a certain timeframe.
	* Raptor serializer now supports all raptor serializer factory names which are mapped to Soprano
	  user serialization types.
	* Changed mimetype of N-Triples to "application/n-triples"
	* New filter model DBusExportModel which exports a single Model via D-Bus.
	* The onto2vocabularyclass tool is now installed by default.
	* New sopranocmd feature: export only part of a model based on a SPARQL construct query.
	* Added OWL Lite resource instances for easy access to OWL Lite members
	* Finer grained control over the D-Bus server components:
	  Soprano::Server::DBusExportModel exports a single model
	  Soprano::Server::DBusExportIterator exports a single iterator
	* Finer grained access to objects exported via D-Bus:
	  the Soprano::Client::DBusXXXIterator classes provide thin wrappers around Soprano iterators
	  exported via D-Bus
	* New method IndexFilterModel::rebuildIndex to rebuild the complete index.
	* New filter model ReadOnlyModel which does exactly what its name suggests: it blocks all writing operations.
	* The unix socket client has been replaced be the LocalSocketClient based on the QLocalSocket which was
	  introduced in QT 4.4. As a result of the design on QLocalServer and QLocalSocket the server is not
	  multithreaded anymore.
	* New Backend method "deleteModelData"
	* New AsyncModel to asyncroneously execute commands on any model.
	* The IndexFilterModel now allows to only index certain predicates and not actually store them
	* Sesame2 updated to 2.1.2

2.0.1
	* Fixed method statementCount in Sesame2 backend
	* Redland backend: Always encode strings as xls:string rather than rdfs:Literal values to match the 
	  Soprano guidelines.
	* Always set a dummy base URI in the raptor serializer
	* Fixed formatting of dateTime values.
	* Fixed NRL namespace
	* Fixed NAO namespace
	* Fixed plugin loading on MAC OS/X

2.0
	* LiteralValue is not derived from QVariant anymore but uses it internally
	* ResultSet renamed to QueryResultIterator
	* Fixed const'ness of many methods
	* Changed StatementIterator layout to match QueryResultIterator's layout using next() and current() methods.
	* Added vocabulary namespaces for usage of shared QUrl values for RDF/S and XML Schema URIs.
	* Added FilterModel class
	* Added RDF/S wrapper methods for easy access to RDF/S resource statements (RDFSchemaWrapper)
	* Added "apidox" build target for building the Soprano API documentation.
	* Added simple inferencing model based on rule files including a rule file parser.
	* Added an index filter model which creates a CLucene index of all literal statements.
	* Support for binary data in RDF literals encoded as base64 in LiteralValue
	* Added Vocabulary namespace containing basic ontology URIs such as RDF, RDFS, XML Schema, and NRL
	* TriG parser through raptor >= 1.4.16
	* NQuads (trivial extension of NTriples) parser and serializer
	* Soprano server library and simple daemon including D-Bus interface.
	* sopranocmd tool which allows to control the soprano server as well as work on the data directly
	  through the backends.
	* Working SPARQL ASK queries with rasqal >= 0.9.15
	
