2008-04-01 Version 1.05

	* N3Reader: Correct the class of characters allowed in variable
	  names, and fix reading ( ) lists.
	* N3Reader: Parse true/false as xsd:boolean. Patch from Mark
	  Cidade: thanks!!
	* Created a new interface that allows the N3Reader to signal to
	  the N3Writer when a [] bnode goes out of scope, so the writer
	  can remove from memory the association from the bnode object
	  to the local name it gives it in the output.
	* Store: Correct a bug in Clear() and recognize the "sqlstore:"
	  spec string for creating data sources. (Khaled Hammouda)
	* SQLStore: Allow both LIMIT and TOP clauses, for SqlServer, and
	  escape apostrophes in string values too (Khaled Hammouda).
	* New SQLServerStore class (Khaled Hammouda).
	* Makefile: Build SemWeb.SQLServerStore.dll.
	* SQLStore: Query: Make sure to add JOINs for variables with literal
	  value filters, and to not add WHERE expressions for filters
	  that did not get a JOIN. If we create a VIEW in order to do
	  projections of variables, issue a DROP VIEW IF EXISTS first.
	* GraphMatch: After each part of an intersective query, forget
	  bindings for nondistinguished variables that we dont need
	  anymore.
	* MySQLStore: Make sure database is open before checking server
	  version.
	* SPARQL: Major restructuring of query processing in Ryan's
	  library to push processing as deep into the queries as
	  possible. Which variables are "locally" distinguished are now
	  available at the level of SemWeb's Query() method.
	* Resource: In the .NET 2.0 profile, implements IComparable now
	  in addition to IComparable<Resource>, since ArrayList.Sort
	  expects the former interface to be implemented.

2008-02-02 Version 1.03

	* The library is now dual-licensed under Creative Commons Attribution
	  (as before) plus GNU GPL v2 or later.
	* Entity: Added ValidateUri static method to validate that a string
	  is an ok IRI-Reference.
	* N3Reader, RdfXmlReader: Validate incoming URIs and issue warnings
	  on failures --- since the validation is new and untested.
	* GraphMatch: Once a part of a query narrows the results down
	  to zero possible bindings, don't process it any further.
	* Euler: Properly ignore Meta fields of statements, especially so
	  that when a Query comes down from SparqlEngine, which passes
	  variables for Meta fields, it doesn't get confused here.
	* Implemented a Silverlight build (set the preprocessor define
	  SILVERLIGHT) which removes the dependency on the XmlDocument class.
	* SPARQL DESCRIBE output now includes back-links, but limits the
	  number of returned statements based on the total for each
	  predicate, using hard-coded limits and exponential fall-off.
	* SPARQL: ORDER BY's DESC() now works.
	* SQLStore: CreateLikeTest revised to be able to do string
	  ends-with tests. StringEndsWith literal filters are now
	  passed down into the SQL query.
	* SQLStore: When getting IDs for resources, don't get more than
	  1000 at a time.
	* SQLStore: Create indexes over the literal value column so
	  we can do fast string-starts-with filtering.
	* SparqlEngine: Turn regex(,) calls into literal filters for simple
	  expressions with no operators except ^ and $, so that we can pass
	  them down into the SQL query. Neither ^ and $ map to StringContains,
	  ^... maps to StringStartsWith, ...$ maps to StringEndsWith, and
	  ^...$ maps to StringContains.
	* tools/rdfquery.cs: Added a CSV output format.
	* tools/euler.cs: Allow queries to be issued in SPARQL language.
	* Updated API docs.

2007-10-25 Version 1.021

	* SPARQL: Updated engine's conf/grammars/20070624.jjt so that
	  bnodes as _:... aren't treated as regular qnames.
	* SparqlEngine: When a graph pattern with no named variables
	  but some bnode variables is being evaluated with Query(),
	  make sure to pass at least one variable as a distinguished
	  variable to Query().
	  Implemented some missing methods that are indeed needed.

2007-10-21 Version 1.02

	* Literal: Removed static Create(bool) method, which was
	  a strange duplicate of FromValue(bool).
	* Query: Added MimeType property to control general
	  query output.
	* SparqlProtocolHander: Properly treat mime-types of
	  the different SPARQL types, and allow for Accept:
	  content-negotiation of output format for DESCRIBE and CONSTRUCT.
	* RdfWriter: Added Create factory-style methods.
	* RdfReader: LoadFromUri now passes the URI of the resource
	  it got to the reader as BaseUri so it can resolve
	  relative URIs in the document.
	* N3Reader: Added @base directive as per latest N3/Turtle specs,
	  and properly raise an error if the three @-directives are
	  used where they shouldn't be.
	* Inference.cs: Improved distributed queries a bit by
	  not querying sources that can't match statements better.
	* GraphMatch: Pass down result limits to the data sources
	  if no intersection is involved in the query.
	  Implemented a sort of adaptive technique to pass down
	  limits to the data sources even in an intersective query.
	  Correct a KeyNotFoundException bug in the generics build
	  in calls to AddLiteralFilter.
	* SPARQL: Pass down LIMITs as far into the query as possible.
	  Updated to IKVM 0.34.
	  Updated to the latest engine upstream from Ryan Levering's
	  SourceForge repository.
	* doc/: Added design document, corrected a mistake
	  reported by Peter Williams (thanks!), and added something
	  on SparqlHttpSource to doc/query.html.

2007-07-17 Version 1.01

	* RdfXmlWriter.cs: Collapse rdf:Description nodes with only
	  an rdf:about attribute into rdf:resource attributes on the
	  parent predicate node.
	* sparql/Makefile: Added a step to get the upstream sources
	  if they're not downloaded yet. [from M. David Peterson]
	* Implement GT/GE/LT/LE/NE math: relations for Euler engine;
	  fixed some bugs when literal values ended up in subject
	  position during inferencing, and when improper xsd literal
	  values were parsed; made the euler.exe command-line tool
	  output all found proofs, not just the first. Note that the
	  math:notLessThan relation's URI differs from the math:
	  ontology by correcting the "L" to be uppercase

2007-06-10 Version 1.00 -- "Finally"

	* N3Writer: Correct output if a namespace is added after the
	  first statement has been written.
	* NamespaceManager: Made AddNamespace virtual.
	* rdfstorage: Added experimental --buffer option which runs
	  input and output in separate threads, though this doesn't
	  seeem to improve performance any.

2007-05-11 Version 0.87 -- Bugs and minor improvements

	* RdfXmlWriter: Fixed another bug where empty Description
	  nodes inside predicates seemed to vanish (which may actually be 
	  compliant, but looked weird).
	* SQLStore: Always pre-fetch the database IDs of resources being
	  Select'ed/Query'd on en mass so we don't send individual
	  SELECTs per resource to get their IDs later.
	* SQLStore/MySQLStore: Moved 255 character limit on URIs
	  to MySQLStore for MySQL < 4.1.2.
	* Literal: Don't Intern() values. Causes memory bloat.
	* SparqlEngine: Added some caches to hopefully speed things up.
	* QueryResultSink: Removed the distinct and ordered arguments
	  to the Init method, which were for SPARQL, but those have
	  been removed from the latest SPARQL XML results format draft.
	* QueryOptions: Added helper method AddDistinguishedVariable.
	* GraphMatch: Added NRE checks and passing query comments up.
	* rdfquery.exe: When running a query on a sparql-http (i.e.
	  SparqlHttpSource), don't use SparqlEngine; send the SPARQL
	  query directly to the remote end point. See the docs for an
	  example.
	* MySQLStore: Allow an environ variable to control how Import()
	  transactions are wrapped, default changed to a BEGIN/COMMIT
	  transaction, since it's less prone to issues. See the end of
	  the Using Databases section of the docs for more. Also, turned
	  off the timeout in RunCommand since Clear() can take a while.

2007-04-12 Version 0.86 -- New SPARQL methods and code clean-up

	* Renamed: Sparql class to SparqlEngine.
	* Renamed: SparqlProtocol class to SparqlProtocolServerHandler.
	* SparqlXmlQuerySink: The spec changed a year ago and unbound
	  variables no longer show an <unbound/> node, instead are just
	  omitted from the document.
	* SparqlHttpSource: fixed bugs, now exposes ability to make
	  direct SPARQL-formatted queries on the end point through
	  new interface SparqlSource. (File Remote.cs also renamed to
	  SparqlClient.cs.)
	* Added a new example in examples/sparql1.cs for using
	  the SparqlHttpSource for making SPARQL queries in various ways.
	* RdfReader: Create method accepts more MIME types, new
	  Create(string,Stream) method added.
	* New class: QueryResultBuffer.
	* VariableBindings: New this[string] method.
	* VisualStudio project files actually included in the deployment
	  package now (oops).

2007-03-31 Version 0.85 -- Major Refactoring Release

	Bugs fixed and other minor things:
	* N3Reader: Reading of "(...)" lists was not working right.
	* Sparql.cs: In ASK, don't close the target stream via XmlWriter
	  after writing; just flush the XmlWriter.
	  Don't attempt to use the Query fast path if there's a statement
	  with no variables in it (as in an ASK).
	* Resource.cs: BNodes without LocalName and variables without
	  names would ToString() with their hash code, but negative
	  hash codes look funny, so it outputs the abs(hashcode) now.
	  Also added Literal.FromValue(Decimal).
	* Euler: Slight public API change.  All of the cwm math:
	  special predicates are implemented.
	* Store: Corrected NullRefExceptions in default Query() impl.
	* euler.exe: Added this new command-line program.
	* When building with make: .NET 1.1 binaries are put in "bin"
	  and .NET 2.0 binaries are put in "bin_generics." Both are
	  build by default now. Also, the SQL database adapters are now
	  only build if the required libraries are present.
	* Documentation: Now tracks the generics version of the library.
	* SparqlHttpSource: Now supports QueryableSource interface.
	
	Major changes:
	* Store and MultiStore: Completely rewritten and merged. The
	  Store is now the MultiStore. The old Store class is gone,
	  and SQLStore no longer inherits from it. But, to get the same
	  functionality back, just add a SQLStore object into a Store
	  object.
	* MemoryStore: Inherits from the new Store class as a special
	  case. Your use of MemoryStore shouldn't change, though.
	* Reasoner: New class that is the base class of RDFS (no longer
	  SelectableSource) and Euler (no longer QueryableSource).
	* Query results: When getting the results of a Query via
	  QueryableSource, the use of VariableBinding[] arrays is
	  replaced with a new VariableBindings class.
	* SQLStore: Now uses SQL VIEWs where supported to speed up
	  queries (through QueryableSource.Query) that ask for fewer
	  variables than are mentioned in the graph.

2007-01-21 Version 0.82 -- 1st Release Candidate for version 1.0

	* RdfXmlWriter: A new Options nested class and a new set of
	  constructors allows the style of the output to be controlled.
	  Use RdfXmlWriter.Options.XMP to enforce output consistent with
	  the XMP spec.
	* N3Writer: Write out xsd:integer and xsd:double typed values
	  without quotes in the formats that support it (integers in
	  N3 and Turtle, doubles only in N3).
	* N3Reader: When an unquoted numeric literal is parsed, type it
	  with xsd:integer or if it's non-integral xsd:double.
	* MultiStore's QueryableSource implementation now implements
	  a distributed query over the sources it combines.  Rather
	  that using the default GraphMatch engine, which uses the
	  SelectableSource interface of the underlying data sources,
	  it now breaks the query into chunks, where possible, and
	  sends entire chunks to the possibly optmized QueryableSource
	  interfaces of the underlying data sources.
	* GraphMatch reorganized a little so MultiStore can take
	  advantage of its algorithm for distributing a query.
	* Literal: Use XmlConvert class to parse XSD values in ParseValue().
	* SQLStore: Minor bug fix/crash in Query.

2006-12-21 Version 0.811

	* Implemented the rdfs:member property in the MemoryStore
	  and all SQL stores.  It matches against any rdf:_# predicate.
	  Also Store.SelectObjects will automatically sort the results
	  by the rdf:_# number when the predicate is rdfs:member.
	* RdfXmlWriter: Replace rdf:_# predicates with rdf:li.  This
	  only works if they are streamed to the writer *in order*.
	* RdfXmlWriter: Another bad bug where some data gets totally losts.
	* MySQLStore: Don't open the connection until it's needed.

2006-12-11 Version 0.81

	Bugs:
	* RdfXmlWriter crashed over cyclic relations between nodes.
	Misc:
	* RDFS.cs: Cleanup.
	* RdfReader.cs: Generic-ified some collections in the DOTNET2 build.
	* MySQLStore.cs: Force an ANALYZE TABLE after an Import().
	Build changes:
	* sparql-core.dll: Updated to latest upstream version in the
	  SourceForge repository.
	* MySQLStore is now built against MySQL Connector by default,
	  instead of the ByteFX library.  Put it in the lib directory.
	* Added Visual Studio 2005 project files (thanks to RollsAppleTree).
	* Sparql.cs: Now compiles against the .NET 2.0 SemWeb.dll
	  with the DOTNET2 precompilation flag set (in both projects).

2006-12-02 Version 0.80

	Big changes and new features:
	* GraphMatch.cs: GraphMatch class completely reimplemented.
	  The code is much, much shorter and cleaner now.
	* RDFS.cs: The RDFS class now implements QueryableSource,
	  which means SPARQL queries over rdfs-wrapped data sources
	  can now take advantage of the base data source's
	  query optimizations (as in the SQLStore).  The implementation
	  in RDFS doesn't cover all of RDFS yet, though.
	* RdfXmlReader: Load namespace declarations from the
	  document element early (in constructor) so that the namespaces can be
	  read off before streaming the statements begins.
	* Store.cs: Implement QueryableSource and provide a default
	  implementation of Query using the GraphMatch class.
	* The QueryableSource interface gets a new method MetaQuery
	  which is used to cheaply determine how the Query method
	  will be performed.
	Bugs and code cleanup:
	* Sparql: DESCRIBE without WHERE clause threw exception.
	* MultiStore: Close() should close any underlying stores.
	* Store.cs: Split off the main interface types out of Store.cs
	  into Interfaces.cs.
	* Store.cs: When compiling with the DOTNET2 flag, only
	  use generic collections.  Code cleanup.

2006-10-23 Version 0.76

	* SQLStore: Indexes are only created the first time
	  the tables are created, so you can modify the indexes
	  manually and not have the usual ones recreated again
	  automatically.
	* MySQLStore now uses ALTER TABLE DISABLE KEYS
	  rather than LOCK TABLES during Store.Import.
	* RdfXmlWriter no longer closes the underlying
	  stream when it finishes writing, which makes it
	  do the same as N3Writer.
	* Removed: MemoryStore.Statements property.
	  Use ToArray() instead, or just foreach over
	  the MemoryStore directly.
	* SPARQL: Bug in my added optimizations caused
	  problems if a predicate in the query is a variable.

2006-10-02 Version 0.751

	FIXES:
	* SQLStore: Adding/importing statements works again.
	  I botched this recently.
	* SPARQL: Fixed several bugs I introduced recently	
	  when upgrading to the 0.8 library.
	* PostgreSQL Store: Working again.
	* MySQLStore: A flag got reverted that allows
	  queries to avoid the DISTINCT keyword.
	FEATURES:
	* Added: SelectableSource::Contains(Resource).
	* N3Reader: Added a new special =:> syntax.  Now
		?variable =:> { ...statements... }
	  is interpreted as ?variable being assigned to
	  the meta field of each statement in the formula.
	* QueryableSource API is changed.
	* SQLStore now implements QuueryableSource by
	  converting a graph into a large SQL query.
	* SPARQL: When querying over a QueryableSource, pass
	  group constraints (i.e. { . . . }) directly to
	  the QueryableSource.  Major speed improvement.
	MISC
	* The SPARQL Protocol handler is moved into its own file.

2006-09-19 Version 0.75

	* RdfXmlWriter: Another bug fix, this time with typed nodes.
	  Also detects invalid parseType=Literal + datatype.
	  Don't auto-generate a prefix named "xmlns".
	  Don't condense literal-property-only nodes when there are
	  a lot of literals.
	* RdfXmlReader: New constructors for taking a BaseURI argument.
	* Literal: New static method FromValue which turns doubles,
	  ints, DateTimes, etc. into XMLSchema-typed Literal objects.
	* SPARQL uses the 0.8 version of Ryan Levering's library.
	* Sqlite 3 storage now wont insert duplicate statements
	  into the database (requires Mono 1.1.17's SqliteClient).

2006-06-18 Version 0.741

	* RdfXmlWriter: Condense output with parseType=Literal
	  and parseType=Resource where possible.  Fixed a bug
	  with attributes and characters needing escaping, and
	  incorrect condensing with literal attributes.
	* Sparql: UNIONs of UNIONs would thrown an exception.

2006-06-06 Version 0.74

	* SQLStore:
	  - Improvements to the Import() methodology, now letting
	    the store scale much better, and a dynamic adjustment
	    of the statement-buffer size increases performance a lot.
	  - The literals table is now unique-indexed with a new hash column
	    containing a SHA1 hash of the literal value, language, and
	    datatype.  This also puts an upper limit on the amount of
	    bytes needed to be transfered to the SQL server in order
	    to find a literal: just the hash, and not the whole value.
	    Beware: This makes old databases unreadable.
	  - Also, a bug fix related to literals being added to the literals
	    table multiple times.
	* RdfXmlReader: Detect two cases of invalid RDF.  Properly
	  recognize xml:base on MS .NET, since that apparently isn't
	  taken care of by XmlReader.BaseURI.
	* RdfXmlWriter: Better API for writing directly to a XmlDocument.
	  Also, a minor bug fix.
	* RdfWriters: No need to pass your own NamespaceManager.
	* SelectableSource: The FindEntities method is removed in favor
	  of the as-yet-unimplemented QueryableSource interface.

2006-05-11 Version 0.73

	* RdfXmlWriter: Provide a way to access the generated
	  XmlDocument directly, ensure it uses empty elements where possible.
	* Fixes and optimization for OPTIONAL groups in Sparql.
	* Sparql CONSTRUCT scopes bnodes properly; DESCRIBE works;
	  CONSTRUCT still has bugs.

2006-04-18 Version 0.72

	* Added SemWeb.Variable class: A subclass of BNode.
	  The N3Reader instantiates ?variables as Variable objects
	  rather than plain BNodes, and the N3Writer will write them
	  out in ?variable notation.  The GraphMatch class now
	  assumes all variables are Variable objects, and nothing else.
	* Added SemWeb.Inferencing.Euler: Inferencing based on
	  Jos De Roo's Euler engine (http://www.agfa.com/w3c/euler/).
	  Experimental and not documented yet.
	* SQL stores: Allow insertion of bnodes outside of Import().
	* SPARQL Extension Functions: New class SemWeb.Query.RdfFunction
	  and new method Sparql.AddExtensionFunction.
	* SPARQL: Numeric comparison filters (i.e. <, >), are optimized
	  by passing them into underlying SQL stores.
	* SPARQL: Better syntax error messages.
	* RdfXmlReader: Raise an error when an invalid parseType is used.
	* Literal: Disallow language and datatype being the empty string.
	* BNode: Disallow localames being the empty string.

2006-03-16 Version 0.711

	* Corrected SQLStore bugs:  Select(SelectFilter) would fail and cancel
	  the select if any of the items werent in the store.  The select
	  optimization to precache metas also had two issues.
	* Corrected a Turtle/N3 parsing error with semicolons
	* Added new classes: SimpleSourceWrapper, FilterSink.
	* Added new spec string type: 'class' for loading a .NET class.
	* Added multi-line spec strings for putting together multiple stores.
	* Added Store.DefaultSelect().

2006-03-11 Version 0.71

	* The Select(Entity[],Entity[],Resource[]) API calls are
	  replaced with new Select(SelectFilter) methods.
	* RdfXmlWriter: Improved and tightened output a lot.
	* Sparql: Major performance improvements.
	* SparqlProtocol: Make sure to dispose of data sources after
	  queries if noreuse is set.  Be sure to flush output.
	* RDFS: Bug fix.  Implement IDisposable so it can be disposed
	  to dispose the underlying data.
	* SQLStore: Limit the number of values in a multi-select to
	  500 to prevent the SQL query from getting too long.  Performance
	  improvement to Select(SelectFilter) by selecting on fewer
	  columns.
	* Query/Sparql refactoring a bit.
	* Added a StatementMap which is a Statement-specialized Hashtable.
	* ByteFx and MySql.Connector MySQL adapters are both compiled now. 
	* Removed Store.Write(RdfWriter).  Use Store.Select(RdfWriter)
	  or writer.Write(store) instead.

2006-01-31 Version 0.7

	* New BNode class.  To create a blank node, use new BNnde()
	  in place of new Entity(null), which will now throw an
	  exception.  BNodes remember their local names in documents
	  so reserialization can reuse the names, when possible.
	* New SemWeb.Inference.RDFS class which wraps any SelectableSource
	  and provides RDFS reasoning over the store through the
	  Select methods.
	* Sparql Protocol handler has been reorganized to make it
	  easy to extend it by overriding methods.
	* Algos for finding MSGs and making graphs lean has been
	  improved and is now not so slow to make it useless (if it works).
	* The default baseuri of the N3Reader is now "#".
	* StatementSources now indicate with their Distinct property
	  whether they guarantee to return distinct statements via Select
	  (and the Select overloads for subinterfaces).

2005-12-10 Version 0.61

	* RdfReaders have a new Namespaces property to expose what
	  namespace prefixes were found in the stream.
	* Added PostgreSQL and BDB (ver 4.3 only) stores.  SQL store
	  performance improvement for Select().
	* There's a new SemWeb.Algos namespace containing a class to
	  find Minimun Self-Contained Graphs and to make a store
	  'lean' by removing redundant subgraphs (but exponentially slow).
	* New method Store::RemoveAll(StatementSource).
	* N3Reader: If a BaseUri was set, overriding it with @prefix :
	  did not work.  Changed an error in RdfXmlReader to a warning;
	* RdfXmlReader now passes all W3C tests (positive & negative).
	* A GraphMatch bug was fixed.
	* Store::GetAllEntities/AllPredicates/AllMetas renamed to just
	  GetEntities/Predicates/Metas. 
	* Statement's Subj/Pred/Obj/Meta properties are now read/write
	  fields.
	* Store::Select(Statement[]) is replaced with something else.

2005-10-19 Version 0.6

	* Renamed QueryEngine to GraphMatch since it does a very limited type
	  of query, and made the API cleaner.
	* Added SemWeb.Query.Sparql, a SPARQL query engine powered by
	  http://sourceforge.net/projects/sparql by Ryan Levering,
	  and deleted my own barely-functional SPARQL parser.
	* GraphMatch only allows anonymous nodes to be variables now, and the
	  N3Reader reads variables as anonymous nodes, but remembers their
	  names.
	* Removed the SelectPartialFilter class and the overloads for
	  Store.Select that took one of those as an argument.
	* The overloads for Select that returned a MemoryStore rather
	  than taking a StatementSink as an argument now return a
	  SelectResult which lazy-loads the results into a MemoryStore
	  if the statements are requested by IEnumerable.  Otherwise it
	  can be used as a StatementSource and passed off to other
	  methods so it won't need to load all of the statements into memory.
	* SQLStore: Clear the store by dropping the tables, rather than
	  deleting all of the rows.
	* Various other bug fixes, including to RdfXmlWriter.

2005-07-24 Version 0.503

	* GetHashCode() for anonmyous resources used to return
	  zero, which made hashtables of anonymous resources
	  very slow.  Now it returns Object.GetHashCode().
	* Fixes in the query engine, SQL store, and N3Reader.
	* Statements now have a default non-null Meta field. The
	  default is Statement.DefaultMeta.
	* Something has made SQLite stores much slower.
	* RdfXmlReader respects the RdfReader.Meta property.
	* MemoryStore.FindEntities wasn't working.
	* The SPARQL parser wasn't reading quoted literals or
	  numbers properly.

2005-07-01 Version 0.502

	* More bug fixes.
	* Query engine totally rewritten, which will
	  make much more sense once its documented.
	* Store.Contains now accepts statement templates.

2005-06-20 Version 0.501

	Just lots of bugs fixed.
	* New API to replace one statement with another statement in a store.
	* New API to test whether a statement template matches a statement.
	* The Resource class now has its == and != operators overloaded.
	* Store.CreateForInput/Output now accepts 'ntriples' 'nt' and 'turtle'.
	* Store.SelectSubjects signature change.
	* Select(Statement[]) for SQL stores works now.
	* SQLLite has a bug in how they handle LEFT JOIN.  SQL store now
	  works around this.
	* SQL stores now index on the meta field.
	* FindEntities works now.
	* N3Writer can output in NTriples, Turtle, or full N3 mode.
	* The query engine works now, and it's better optimized (but it wasn't working before anyway).
	* Xml (Sparql) query result output now has nice indentation.

2005-06-10 Version 0.5

	* First release.