Version 3 History
Changes from 3.1.1 to 3.2
AllegroGraph 3.2 introduces a new query planner to the Prolog select family of macros. This planner performs both clause re-ordering and re-writing to make
select queries much more efficient. The underlying query engine also now creates temporary maps for particular subsets of the triples in a store. These maps make many queries significantly faster.
We have increased the maximum size of the string-dictionary to 8-GB. Existing triple-stores will need to be converted to use the new format and new stores will not be readable by previous versions of AllegroGraph. If a store is opened in Lisp, then a restart will be offered to convert the store. Otherwise, the
convertdb command-line tool should be used.
In addition, The internal encoding of Cartesian geospatial subtypes has changed. Triple-stores containing Cartesian geospatial data created with earlier releases can not be opened under under 3.2 and must be re-built. Contact us if this is a serious problem. Note that spherical data is unaffected.
Finally, AllegroGraph no longer modifies the Lisp readtable (with the enable-!-reader function). If your code relies on the reader, then you will either need to enable it yourself or use the facilities of Allegro's named readtables).
The command line argument
--client-select-querieswas changed to
--client-prolog, and the valid values changed from
The configuration file keyword
:client-select-querieswas changed to
:client-prolog, and the valid values from
Enhancements and Features
When using RDFS++ reasoning, the Prolog query engine dynamically optimizes queries to match the underlying ontology and assertions.
Improved get-triples and RDFS++ reasoning for many common cases.
Added :exclude-standard-ontology-uris to create-triple-store.
Many other minor enhancements and improvements.
Fixed bugs and other corrections
If an old store was opened read-only, then the version information was not being correctly written for the updated store.
Corrected the way select queries dealt with missing strings (previously, a query would immediately short-circuit if a string in the query was known to not be in the store; now the clause simply
failsso that other clauses will run.)
Corrected some problems with hasValue reasoning tutorial.
Corrected a bug where load-rdf/xml could not be used if a triple-store was also using free-text indexing.
Many other minor corrections and fixes.
The :algebra query engine is now used for all queries unless a different query engine is explicitly chosen. It is also the main focus of future AllegroGraph development. Any bugs (such as extraordinary differences in behavior between the :algebra and the :allegrograph-2 engines) should be addressed to email@example.com.
Speed and DISTINCT improvements.
Algebra engine now treats encoded values and RDF literals as equal when appropriate. This functionality is still being explored with respect to AllegroGraph's custom type mappings.
Algebra engine now supports :with-variables, with all applicable optimizations, such as eliding of ORDER BY conditions and simplification of FILTERs.
More efficient FILTERs, particularly including dateTimes.
More constraints are extracted from FILTERs, which should cause some queries to be faster.
Encoded values now work correctly in more cases: for example, the SPARQL datatype() function now works correctly on more literals.
Improved correctness in some contrived situations. No additional DAWG test passes: the algebra engine continues to achieve almost perfect scores, excepting documented extensions and one missing XSD date feature.
A bug was corrected in the older allegrograph-2 engine, which now functions correctly with GRAPH clauses and the default graph. The algebra engine has never exhibited this problem.
Correct a minor issue involving an interaction of compiled optimizations and the :with-variables argument. This does not affect SPARQL queries initiated from Java, Python, or over HTTP: only queries included in compiled Lisp code.
Minor fixes and optimizations.
Major Java API changes:
The revised API includes new classes and deletes many methods. 3.1.1 source code will not compile or run but 3.1.1 applications using the 3.1.1 jar files will run against a 3.2 server.
This class includes methods that access the new query planner operations.
- ValueSetIterator interface
An instance of
ValueSetIteratordelivers one set of results from a query at each step in the iteration. The set of results appears as an array of bindings for the query variables. Values can be retrieved by index or by name.
All the methods in AllegroGraph for making Prolog queries have been eliminated in favor of the PrologSelectQuery class.
All the methods in AllegroGraph for making SPARQL queries have been eliminated in favor of the SPARQLQuery class.
Many minor bug fixes and performance improvements to the Java server.
Many minor bug fixes and performance improvements in the Jena API implementation.
Added a BulkUpdateHandler implementation.
A new Sesame 2 Repository implementation allows for much more efficient SPARQL queries.
- The Python API now supports both Prolog and geospatial reasoning.
Changes from 3.1 to 3.1.1
Changes from 3.0.1 to 3.1
- Prior to 3.1, close-triple-store would set *db* to
nilregardless of its current value. In 3.1,
*db*is only set to nil if it is the same as (
eq) to the triple-store being closed.
New Features and improvements
SNA includes a new centrality algorithm: page-rank-centrality
Federated triple-stores now support most of the freetext-indexing API
String-tables are now memory-mapped on 64-bit Operating Systems for read-only triple-stores
has-value-reasoning is now part of the reasoner, not the AllegroGraph application as a whole. It can be turned on and off as needed.
Many performance enhancements including
Freetext queries no longer return deleted triples.
The date-string-to-upi now works with dates, times or date-times.
Data and predicate type mapping now works for all data importers (not just load-ntriples).
Added a wait keyword argument to stop-ag-server.
Though AllegroGraph is optimized for 64-bit operating systems, it supports 32-bit ones for testing, evaluation and educational purposes. This release supports more efficient use of system resources so that the only remaining constraint on triple-store size is the number of unique strings. If a triple store has many long resource and literal strings, the effective size limit may still be just a few million triples. But a store with few strings and primarily using encoded UPIs can now support in excess of 10^8 triples (subject to licensing limits). Of course, speed on 32-bit platforms will still be substantially less than 64-bit platforms.
An exception class used by load-ntriples was missing
Windows was unable to simultaneously open more than one remote triple-store.
The patches loaded message was incorrectly reporting that some patches were not loaded even when they were.
We have reduced the likelihood that the same temporary directory could be used during clustered-indexing.
Some range queries could fail to return all of the correct triples if some indices were not present in the store.
Some federated queries could signal an error instead of returning triples.
The files for the string-table could occasionally be left open needlessly draining the number of available file handles.
Find-triple-store was occasionally confused by pathnames on Windows.
It was impossible to use load-ntriples-from-string on remote-triple-stores. fix bug in find-upis-for-column
Corrected several small glitches in the implementation of remote-cursors (used for queries against remote-triple-stores).
Algebra engine sees many performance improvements, particularly in FILTER and ORDER BY, and in cache usage. It is now the recommended engine, though you must explicitly opt-in.
Restored memoization to the algebra engine in many places.
Added preliminary GEO pattern support to algebra engine. This allows for fast geospatial querying. (Documentation coming soon)
Added :planner keyword argument and an extensible BGP planner system.
More results and RDF formats.
Conformance and bug fixes.
The Java API in AG 3.1 has been re-organized internally but there are few user-visible changes. Existing applications will run without change.
The current API will be deprecated in the next release, when the new API is exposed as the native API to AG.
We have added extensions that enable access to AG with Jena and Sesame 2.x API calls. Applications using Jena or Sesame 2.x must use the new revised API to access native AG features. Note that we are continuing to tune and improve both of these APIs and will release updates on a regular basis. Be sure to consult Franz's webpage detailing recent AllegroGraph patches and updates for more information.
added Jena and Sesame extensions (using revised API)
Java API requires Java 1.5 or later
clients can bulk load from URL
added GeoExtension.getSubtypes() method
added methods to control hasValue reasoning in TriplesQuery or SPARQLQuery classes
added methods to control SPOGI caching
numerous bug fixes and performance improvements
Changes from 3.0 to 3.0.1
New Features and improvements
Freetext indexing now works with federation. Note that freetext-get-ids does not work with federation because the ids returned are ambiguous with respect to the leaf store from which they came.
Added neighbor-matrixes to help increase the speed of many SNA algorithms by moving triple-store queries from disk into main memory.
Various fixes for running AllegroGraphServer as a service on Windows.
Correct bug that caused the server to incorrectly report the list of applied patches.
Lisp Bug fixes and Enhancements
Various fixes to free-text indexing.
Various fixes to the SNA implementation.
graph-density was not restricting nodal-neighbors to elements of the sub-graph
The path finding algorithms no longer produces duplicate paths.
depth-first-search could signal an error when the node to be found was immediately adjacent to the initial-node.
Encoded time, date and date-time UPIs now correctly ensure that the strings they encode represent valid time, dates and date-times (respectively).
Corrected bug wherein freetext-indices where not synced to disk until a triple-store was closed. They are now synched whenever sync-triple-store is called.
print-object for triple-stores now indicates whether or not the triple-store is opened read-only.
corrected a bug where part->value was not signaling an error when the namespace for a future-part could not be resolved.
Various fixes to the N-triples parser.
get-triples now works correctly for in-memory triple-stores.
cut-readerwas unnecessary and has been removed. To use the bang (!) character in Prolog clauses, simply escape it with a backward-slash. For example:
Some minor case-sensitivity fixes.
many minor performance enhancements to SNA, the reasoner, query and cursors, and N-Triples parsing.
pprint-subject and pprint-object now query the current triple-store's inner-triple-store. In practice, this means that inferred-triples will not be shown using these functions and that they will be significantly faster.
fixed various bugs in part-printing when using read-only triple-stores.
The AllegroGraph Java API up to this release has included the openrdf.org.model interfaces from Sesame 1.2. These interfaces will not be implemented or included in the API after this release. We plan to provide Sesame 2.0 compatibility in the next release of AllegroGraph.
Java API changes in 3.0.1:
Classes and interfaces have been reorganized. Most of the documented methods of the AllegroGraph API are now defined in Java interfaces instead of Java classes. Most user code should run without any changes.
A new class TriplesQuery allows program access to all the search features of AllegroGraph.
various bug fixes and minor performance enhancements.
Many conformance improvements, many of which are around handling of typed literals; SPARQL query execution now correctly performs XSD type promotion.
A pre-release SPARQL Algebra query engine is now included. Use the :engine :algebra argument to run-sparql. This engine passes more SPARQL DAWG tests than the previous :allegrograph-2 engine. In most cases this should be a drop-in replacement; it offers enhanced performance in some scenarios, and more opportunities for future optimization.
Some minor case-sensitivity fixes.
Minor SPARQL documentation improvements.
Added search to the AllegroGraph documentation.
Improved printing support under Internet Explorer.
Changes from 2.2.5 to 3.0
Major New Features
Federation - AllegroGraph 3.0 can group multiple triple-stores (both local and remote) into a single virtual store.
Remote triple-stores - The Lisp Client API in 2.0 has been removed in favor of the new remote-triple-store. These use the same API as all of the other triple-stores but act as proxies for triple-stores in other processes. These processes can be local to the current machine or exist on the network.
Geospatial Primitives - AllegroGraph 3.0 includes encoded datatypes for representing two-dimensional points and a large set of functions for searching through these points efficiently.
Temporal Primitives - We also include new datatypes for encoding points in time, date-times, intervals and durations and a set of functions for efficiently querying a triple-store about them.
Social Networking Analysis - There is a new Social Networking Analysis library that has functions for treating a triple-store as a graph of relations. There are functions for measuring importance and centrality as well as several different families of search functions.
Enhanced server security by adding configuration options that control the use of evalInServer() and Prolog code. See the server installation guide for more details.
New Features and Improvements
Many low-level speed and efficiency improvements (especially on 64-bit platforms)
Better error reporting and handling
Triple-stores can now be opened in true read-only fashion making it possible to scale query efficiency and perform load balancing.
:minimum and :maximum can be used in as pseudo-UPIs in range queries to find all of the triples from the smallest (or largest) value.
If a query involves strings that are not yet interned in the triple-store (i.e., stored in the string dictionary), then the query will fail immediately instead of engaging in a search that is guaranteed to fail.
Many new utility functions
More flexible reasoning architecture that will support future developments in new reasoning engines
Many bug fixes in the RDFS++ reasoner
The hasValue reasoning support is now better integrated with the rest of the RDFS++ reasoner and has also been more throughly tested.
Greatly improved N-Triples parser for compliance with the N-Triples standard (it is still possible to load non-conforming N-Triple files if desired) including support for different external-formats and UNICODE.
Greatly improved RDF/XML parser: now passes almost the entirety of the W3C test suite.
More consistent UPI and triple printing
The Prolog select-distinct macro (and variants) can handle non-UPIs in its return values.
Improved bang-! reader integration with UNICODE support and REPL support
On 64-bit platforms, AllegroGraph makes greater use of memory-mapped files for indices and meta-indices. This can result in large efficiency improvements.
Greatly optimized Client/Server infrastructure to reduce the number of round-trips in queries.
start-ag-server has a new
error-logkeyword argument to control where stack backtrace is sent when a client request triggers an error.
get-triple is now more efficient
The JSON results format for SPARQL queries is now up-to-date, without the "distinct" and "ordered" attributes in the header.
General documentation improvements.
Incompatible triple-store format: The triple-store format has changed. See the upgrade guide for details.
There have been API changes that are incompatible with the behavior seen in AllegroGraph 2.x. These were made to improve function and argument names, reduce and minimize redundant duplications and increase consistency. See the upgrade guide for more details
- Deprecated functions and variables
*use-reasoner* - reasoning functions very differently in AllegroGraph 3.0 and this variable no longer makes sense. See the reasoner tutorial for a good overview of the changes.
:use-reasonerkeyword argument of get-triples-list has been deprecated.
The already deprecated function
property-mappinghas been removed. Use predicate-mapping in its place.
- Renamed functions
- Other changes
create-triple-store no longer creates directories automatically. When you create the triple-store
sample, all of the directories above
samplemust already exist.
load-ntriples is much stricter regarding the N-Triples specification both in its rejection (by default) of non-7-bit ASCII and in its internal validation. You can use the new
:external-formatargument to continue to load non-7-bit ASCII files directly.
- Deprecated functions and variables
Most of the Lisp Client API functions are no longer exported. All operations on a triple store are performed using a remote-triple-store instance and ordinary triple-store functions.
Java API Changes
GeoExtension, GeoSpatialSubtype, Polygon -- These classes implement access to the geospatial library in AllegroGraph.
SNAExtension -- This class implements access to the Social Network Analysis library in AllegroGraph
SPARQLQuery makes available all SPARQL query options.
RDFSerializer, RDFManifestSerializer, RDFN3Serializer, NTripleSerializer -- These classes implement access to all the serializer features in AllegroGraph.
DefaultGraph to represent the default graph object.
NamespaceRegistry -- this class is used to collect namespace prefix definitions in Java. Java application can define a default namespace registry for each AllegroGraphConnection; this registry is used to initialize new AllegroGraph instances.
This new behavior is similar but not identical to earlier namespace behavior.
There is no Java access to the global namespace definitions in Lisp. The global namespace definitions in Lisp have no effect on the Java client interface.
NEW Methods in class AllegroGraph:
addEncodedLiteral( String, "date-time")
selectValues(boolean, boolean, ...)
selectStatements(boolean, boolean, ...) -- The first boolean argument controls inferencing. The second boolean argument controls uniqueness of results.
closeTripleStore(boolean) to request true closing of store if only one ref (this is the default)
getSyncEveryTime() and setSyncEveryTime() to control synchronization in addStatement() and addStatements().
setAttribute() allows Java application to control all triple store access parameters.
EncodedLiteral instances created from triple parts
allow "minimum" and "maximum" in range form of getStatements()
add 8 and 9 argument forms of getStatements() to permit all possible range queries.
addPart() method allows ValueObject instances to be created from ntriples or ! notations (ie Literal, Node, and BlankNode instances).
selectSingleValues() like selectValues() but query is restricted to a single result variable. Query returns a one-dimensional array of results.
Added baseURI argument to loadRDF() method
Deleted methods bindInServer() and evalInServer(String, String). The use of evalInServer() is now restricted.
NEW Methods in Class AllegroGraphConnection
access(Allegrograph), open(Allegrograph), create(Allegrograph), renew(Allegrograph). replace(Allegrograph) -- These methods are used when attributes are set before accessing the store.
access(), open(), create(), renew() and replace() methods accept a path string as the name argument, The directory argument is optional.
federate(), getStores(), findStore() to create and access federated triple stores.
setTimeout() and getTimeout() -- to control timeout interval for socket connection to server
Triple and Cursor component accessors are redeclared to return more general result objects. When this conflicted with the openrdf model declarations, added methods getSubjectInstance and getPredicateInstance
Bug Fixes (partial list):
twinqlAsk() calls were throwing an exception in the server.
hasStatement() with wild card was throwing error.
getSubjectLabel() and friends were failing or giving incorrect results for some Cursor instances.
getParts() was throwing exception if agument was a BlankNode.
Version 2 History
Changes from 2.2.4 to 2.2.5
Improved support for EBV invalid literals.
Made available simple automatic dataset (FROM and FROM NAMED) fetching, using twinql's built-in dataset hooks.
Improved support for
*sparql-query-planner*so that it is possible to use alternative planners.
Increased the efficiency of certain LIMIT queries.
Added a new
Triple-stores can be set as read-only using the read-only-p slot. These stores will not update the disk after they are opened. It is still not possible to open a triple-store in full read-only mode.
Many improvements were made in the RDFS++ reasoner including bug fixes and additional reasoning capabilities.
Fixed a bug in create-triple-store that occurred when trying to use :if-exists :open.
Cleanup messages can be suppressed using the new property
We have added getters and setters for
Made several improvements in timeout-handling and improved the error messages so that they are easier to understand.
we have added nethods getSyncEveryTime and setSyncEveryTime to allow applications to control when the triple store is synchronized in addStatement and addStatements calls
Changes from 2.2.3 to 2.2.4
SPARQL / twinql
Update to the latest SPARQL XML results format.
SPARQL Protocol servers now have a base-uri field. See the SPARQL Protocol Server Guide for details.
The SPARQL Protocol server now accepts requests with no specified Accept: header.
Many speed improvements:
- Queries with DISTINCT or ORDER BY clauses are now significantly faster,
- FILTERs operating on numeric types,
- Other, general, performance improvements,
- Minor parser improvements.
Lisp / AllegroGraph Core
- Significantly increases the speed of triple printing which should also increase the speed of transferring data over a socket.
Both loadRDF() and loadNTriples() correctly accept a context argument.
Updated getUnmergedCount(), getIndexFlavors() and Triple.getContextLabel() to avoid potential exceptions.
SPARQL / twinql
Some non-matching OPTIONAL patterns were being mis-interpreted.
Minor fix to dataset handling in certain situations.
Changes from 2.2.2 to 2.2.3
Ensure that version 2.2.1 databases can be read.
Minor fix to Java loadRDF() method.
Changes from 2.2.1 to 2.2.2
Freetext indexes can now be used from SPARQL via the magic predicates: fti:match and fti:matchExpression (assuming, of course, that fti is the namespace
<http://franz.com/ns/allegrograph/2.2/textindex/>.). See the freetext-tutorial for details.
The reasoner can now answer queries where none of subject, predicate and object are given (i.e., tell me everything you know and everything you can infer).
The load-rdf/xml function has a new parameter, :use-rapper-p, that can be used to cause AllegroGraph to call out to rapper for parsing rather than relying on the internal parser. (Note that this has been available since 2.2.1 but was not included in that version's change history).
Sesame HTTP server:
XML transaction format now allows N-Triples notation or a simple URI label inside a
An XML transaction containing a
<literal>element with a datatype attribute was causing the transaction to fail. This problem is corrected.
loadRDF()method now works correctly both with and without a context argument.
Some inconsistencies in the freetext indexer's string down-casing have been corrected.
The reasoner was not re-setting its cache of available subjects which could cause queries to fail whenever new subjects were added after certain reasoning queries were performed.
There have been several minor N-Triples parser fixes especially as regards blank node handling.
Changes from 2.2 to 2.2.1
The reasoner is now much faster when dealing with triple-stores containing thousand (or even hundreds of thousands) of rdfs:subClassOf relations.
The Java Updater program no longer produces spurious error messages when applying patches
The Java server now loads patches more reliably.
The N-Triples printer now prints escape characters (e.g., control characters like #\Newline and Unicode characters) correctly.
We've added some minor optimizations in the N-Triples parser.
Improved the behavior of SPARQL's DESCRIBE verb.
We've corrected several typos in the documentation.
qfunctor could incorrectly act like
qsand return results from the reasoner. This can no longer occur.
The RDF/XML serializer no longer becomes confused when given duplicate namespace definitions
The RDF/XML serialize now prints literals correctly in all known cases.
The reasoner was not correctly returning all possible results from the transitive application of rdfs:subClassOf rules. Now it does.
The Lisp Client function
create-literalfunction was creating invalid encoded literals; this has been fixed.
AllegroGraph's SPARQL query engine (twinql) was not choosing the correct comparison function when working with encoded UPIs (e.g., for range queries.). This has been corrected.
The free-text indexer could generate file system errors in some edge cases. This has been fixed.
Changes from 2.1 to 2.2
Triples and UPI can now be printed in a terse readable format. See enable-print-decoded for details.
There is now a Lisp client API available. It mirrors the Java version of the API.
Get-triples and SPARQL now both work with AllegroGraph's RDFS++ reasoner
AllegroGraph now includes both a TRIX serializer and parser.
Added :allegrograph-2.2 and :allegrograph2 to the features list. In general, each release of AllegroGraph will have three features associated with it: the most general :allegrograph, the major-version specific :allegrographN and the version-specific :allegrograph-N.M.
get-triples now supports the indexed-triples-only-p keyword and the :use-reasoner argument. The former causes it to perform queries over only indexed triples whereas the later turns on reasoning for a single call.
AllegroGraph indices are not opened until necessary; Index chunks are better managed to reduce the chance of running out of file handles even when querying, loading and indexing simultaneously.
Freetext indexing: AllegroGraph can now index the text in triple-objects and perform very fast queries over the indices.
!!-reader macro was removed (though this actually occurred way during the transition from 1.x to 2.x). Use the
!-reader macro in all cases
??operator of Allegro Prolog greatly simplifies the embedding of Lisp forms and variables in Prolog clauses. This feature is part of Prolog 1.0.4 (8.0 patch prolog.004 or 8.1 patch prolog.001).
upip - is something a UPI
upi-type-code - returns the 'type-code' of a UPI
load-rdf/xml* - load multiple RDF/XML files
load-rdf/xml-from-string - load triples from a string treating it as if it is an RDF/XML data-set
get-triple - search for a single triple and return it
triple-exists-p - return
tif a triple exists and
find-triple-store - lookup a triple-store by name
blank-node-p - return true if a UPI is a blank node
with-blank-nodes - create one or more blank nodes and execute the body of this macro with them bound.
merge-new-triples - Merge small index chunks without trying to merge everything into one single index; this can be much more efficient depending on your data processing needs.
added merge-chunk-count-limit. If set, then at most this many chunks will be merged in a single merge operation.
API Changes and Improvements
Close-triple-store: changed the default of
Create-triple-store: change default value of
delete-triple-store: can now take pathnames
Functions that take a triple-store pathname (e.g., Create-triple-store) now require that it be a non-directory path (i.e., that it does not end in a slash). For example,
(create-triple-store "temporary-files/test/")will generate an error in AllegroGraph 2.2.
load-rdf/xml -- added
The agraph-manager period has been reduced from 60 down to 2 to help it keep the triple-stores running optimally.
Changed signature of upi->value to match other functions in the public API. The old version used an &optional, the new one uses &key.
Changed threshold based indexing so that it occurs based on the number of unindexed triples rather than on the sum of the total number of unindexed triples per index flavor.
Made future-parts easier to use: they no longer require an open triple-store until a part must actually by interned.
improve N-Triple parsing and escape handling
Corrected a bug in get-triple-by-id that left it confused when trying to retrieve a triple that had not yet been synchronized.
Removed an unnecessary Lisp cleanup function that was prevented AllegroGraph from terminating nicely when it received an interrupt.
fixed several small errors in AllegroGraph's cluster code that could cause some remote jobs to fail.
Numerous other small improvements and fixes.
twinql now supports a complete remote querying interface.
SPARQL queries can now fully exploit AllegroGraph's RDFS++ reasoner.
We have implemented SOP memoization which allows many queries to run much more quickly
fixed minor bugs in twinql's datetime comparison routines
new SPARQL special variable:
sparql.sop:*optimize-sparql-filter-application-p*. If true, constant expressions will be collapsed. Set to false if you need constant functions to be executed during query runtime.
sparql:*dataset-load-function*to provide hooks into the FROM clause
The RDFS++ reasoner now support
owl:hasValuerestrictions (this is not fully documented, please contact Franz if you have questions)
rdfs:subClassOfnow correctly handle transitivity
Queries of the form (q- ?s !rdf:type ?o) now correctly find all results.
ValueObjectinstances to be created from
N-Triplesor using the !-notation (i.e., Literal, Node and BlankNode instances).
twinqlAsk()calls were throwing an exception in the server
added the method
selectSingleValues()which is like
selectValues()but the query is restricted to a single result variable. It returns a one-dimensional array of results
added per-triple-store namespace methods to AllegroGraph class:
hasStatement()with wild card was throwing error
getSubjectLabel()and friends were failing or giving incorrect results for some Cursor instances
getParts()was throwing exception if argument was a BlankNode
loadRDF()is available once again.
If desired both
loadNtriples()can now return the UPI of the graph used during the load.
Changes from 2.0.1 to 2.1
We have improved AllegroGraph's string dictionary usage and the speed of its internal hashing Algorithms. These improve performance on all platforms but allow for dramatic speed increases under 32-bit Windows. Unfortunately, these changes mean that triple-stores built with previous versions of AllegroGraph will no longer operate with AllegroGraph 2.1. If you have triple-stores that you would like to migrate from an earlier version to version 2.1 (rather than rebuilding your stores from your original data), you will need to export your data and import it into the new format. If you find yourself in this situation, please contact support@franz for assistance before you begin the process.
- Created a much improved cross-platform, non-consing hash algorithm that both increases overall performance and dramatically improves performance on 32-bit Windows.
- Improved the storage of strings from typed literals and literals with language encoding.
- (Windows) Triple-stores can now be stored on any drive-letter (regardless of the location of the AllegroGraph executable).
- Fixed a serious bug that caused merged indices to be highly unreliable. This bug was introduced in version 2.0.1. Note that we have also improved our internal test suite so that this will not occur again.
- Multiple simultaneous Java and/or HTTP connections to the same triple store are allowed. Each client has exclusive access during one operation:
- In Java an operation is defined by each of the API methods. Thus the array methods offer a primitive form of transaction.
- In HTTP, each request is one operation.
- Bulk loading operations may lock out other clients for extended periods.
- There is no concept of ownership or restricted access, therefore clients must exercise some self-discipline.
- New parseNTriples can parse strings in N-Triple format and add the triples to a triple-store
export-to-sesame. This parameter specifies how long an idle triple store should remain open.
idle-lifearguments to start-agj-server.
- The timeout parameter specifies how many seconds a client will wait for a busy triple store before signaling an error.
- The idle-life parameter specifies how many minutes an idle triple store will remain open.
- Added new command line arguments to the AllegroGraphJavaServer executable.
- The triple:
-hinitallow a single server to work with either Java, HTTP or both simultaneously.
- The pair
idle-lifeparameters set the timeout and idle-life of the server and triple-stores respectively
- The triple:
addStatement(Object,Object,Object,Object)was ignoring the fourth, context (or graph), argument. This problem has been corrected.
Changes from 2.0 to 2.0.1
- AllegroGraph now runs on the Windows platform (both 32 bit and 64 bit windows are supported).
- The API of
deleted-triple-phave changed to match that of the rest of the public functions
- The functions
create-triple-storeall accept logical-pathnames for their name parameter in addition to strings.
load-ntriples-from-stringto read a string containing one or more triples in N-Triple format.
- You can now use
:unmerged-chunk-count-thresholdas parameters to
value->upifunction does a better job of converting strings into typed UPIs
- Exported and documented the functions
- Added the macro
iterate-cursorand the function
- AllegroGraph indexing and merging is significantly faster that in 2.0
SPARQL / twinql improvements
- Added a SPARQL protocol server
- Many fixes and performance enhancements including the optional memoization of SOP functions and low-level improvements
- Added summary statistics such as MEDIAN, MODE, SUM and so on as an extension to SPARQL (you must set
:extendedp tto use these in a SPARQL query.)
- DISTINCT + LIMIT + OFFSET are now completely streaming; only ordered queries are not
- Minor fixes for specification conformance in parsing, DISTINCT, and DESCRIBE *.
query->verbfunction to return the verb (e.g., :select) from a query.
- To improve their performance, constant queries are parsed at compile-time rather than run-time.
- The N-Triples parser took an overly strict view of angle bracket terminators (the grammar specifies that any character is permitted between the <>s, including other <>s). Fixed.
Get-triple-by-idcould return the wrong triple if a triple-store used both encoded and string representations of the same triple. Fixed.
- Many other bug fixes
Removed or deprecated functionality
- The function
property-mappinghas been deprecated in favor of
- The function
upi->stringhas been removed (use
part->stringin its place)
- Because its behavior was ambiguous,
load-ntriplesno longer parses strings in N-Triple format. Use
load-ntriplesto read N-Triples from files or streams and use
load-ntriples-from-stringto read N-Triples from a string.
- The function
do-cursorhas been deprecated in favor of the new function
map-cursorand the new macro
- (General) The encodings for :short and :int and for :unsigned-short and :unsigned-int are reversed. Shorts should encode 16-bits of information and ints should encode 32 but in AllegroGraph 2.0.1, Shorts encode 32 and ints encode 16.
- (Windows) AllegroGraph can be confused about a triple-store location if the program is run on a different drive than that of the triple-store itself.
- (Java) The method AllegroGraph.addStatement(Object, Object, Object, Object) always uses null for the fourth, context, argument. The workaround is to call AllegroGraph.addStatements(Object, Object, Object, Object) instead.
Java Specific Changes
New functions and improvements
selectStatements()methods and deprecated the
valueNames()to retrieve the variable names and order of a SPARQL query
- Added method
twinqlCount()that returns the number of results in the query
- Added context argument to
loadNtriples()to support named-graphs.
- Added new class
- Added additional signatures to
hasStatement()to enable reasoning in queries
- Added a wait argument to the indexing methods
- Added method
AllegroGraph.serverTrace()to allow selective tracing by triple store
- Added method
AllegroGraphConnection.interrupt()to allow Java application to cancel a runaway operation
- Added method
AllegroGraphConnection.isBusy()to query state of connection
moreValues()method now always returns the full count and never an estimate
twinqlSelect()returns an array that can be refilled using
twinqlFind()is now more efficient
- Correct error that caused
getNamespaces()to return null
- Correct error that caused exception in
Changes from 1.2.6 to 2.0
Major improvements and changes
- Faster, more memory efficient string-table dictionaries.
- Full support for named-graphs.
- Sesame 2.0 HTTP Interface.
- Improved SPARQL query engine.
- All the parts of a triple (subject, predicate, object and graph) can have a range of values encoded in them directly (by-passing the string dictionaries). These encoded-triples provide support for very fast range queries.
- Type-mappings can be added to a triple-store to automatically create encoded-triples as new triples are loaded into the store.
- New patent-pending triple format using hashed Unique Part Identifiers (UPIs) (patent-pending).
- Greatly optimized indexing algorithms.
- RDFS++ Reasoner is now fully integrated with AllegroGraph.
- Automatic Triple-store index management.
- Greatly improved Java integration including support for all of the many new capabilities.
- Greatly improved concurrency support.
- Support for multi-CPU clusters (on both single multi-CPU / multi-core machines or multiple-machines over a network) for indexing.
- Improved tutorials and documentation.
- You can control the indices used by each triple-store:
- At creation-time, you can use the
- You can use
drop-indicesafter a triple-store has been created.
- At creation-time, you can use the
ag-property-names) to help manage triple-store behavior, and properties can be saved and loaded between sessions.
- Future-parts and the !-reader have been optimized and improved:
- in addition to deferred UPI computation, they also provide delayed namespace resolution, and
- functions like
- The AllegroGraph RDFS++ reasoner is now fully integrated with each triple-store:
- reasoning data structures are automatically maintained, and
- reasoning data structures are private to each triple-store so that reasoning can be used on multiple stores simultaneously.
- The following functions are deprecated:
API improvements and additions
- There are many new functions to manage AllegroGraph as a whole and each triple-store in particular.
- Triple-store functions like
open-triple-store, and friends now accept complete pathnames to specify a triple-store location instead of requiring you to separate the name from the directory.
- You can use
:if-existskeyword parameter to
create-triple-store. This will cause
create-triple-storeto open the store if it already exists.
- Added an
open-triple-store. It can take on the values
- Added a
default-graphparameter to load-ntriples.
Load-ntriplesreturns, as multiple-values, the number of triples loaded and the default-graph used.
- Added a
streamargument to print-triples.
- Aside from support for range queries,
get-triples-listcan now take optional
filtersto limit the triples returned.
- The family of
selectfunctions can¯ now produce arbitrary templates rather than only lists of triples.
The AllegroGraph Java API in Version 2.0 is similar to the API in Version 1.2, but many method signatures have changed because the implementation of the triple store has been revised extensively. All 1.2 application programs need to be inspected carefully and revised accordingly.
Major change summary:
- All methods that accept subject, predicate and object arguments are extended to allow a context argument as well.
- Literal and Node identifiers are UPI instances in AllegroGraph 2.0. These values were Java long numbers in 1.2. Triples are still identified by Java long numbers in 2.0.
- The select() and selectValues() methods are revised to return all results. The results are no longer limited by the setSelectLimit() number.
Version 1.0 History
Changes from 1.2.5 to 1.2.6
- Added the rebuild-indices command
- Added the variables use-reasoner-prototype and verbose-prepare-reasoning to control the use of the reasoner prototype.
- If use-reasoner-prototype is true, then get-triples-list will use the reasoner to return inferred triples (in addition to the usual ground triples).
- Future-parts delay namespace resolution so that future-parts with namespaces can be used more easily in compiled code.
- Future-parts are better documented
- There is a new tutorial on the AllegroGraph reasoner prototype
- Corrected a bug in the reasoner that affected transitive properties.
- Java: Added several methods to AllegorGraphConnection including defaultPollCount(), pollCount(), defaultPollInterval(), pollInterval(), setDefaultPolling(), and setPolling().
- Java: Corrected an unusual case in selectValues() where the results could include a Future-part instead of the usual integer part-numbers.
- The reasoner is better integrated into AllegroGraph
- Added make-tutorial-store to add in testing the AllegroGraph prototype reasoner.
Changes from 1.2.4 to 1.2.5
- Improved triple-store version detection
- Augmented some triple-store functions to allow the use of triple-store names instead of triple-store objects
- Java: improved Java / AllegroGraph API for namespace management
- Java: augment Java / SPARQL interface
- Updated the reasoner prototype to handle transitive-properties and improve sameAs handling.
- Improved the implementation of the !-reader to prevent surprises when working with multiple threads
- Java: added evalInServer() to ease remote support
Changes from 1.2.3 to 1.2.4
- Augmented end of line handling in the RDF/XML importer so that files with Windows, Macintosh, or UNIX style line endings -- or even a mixture of all three -- are optimally parsed.
- Revised resizing of string information that could result in the loss of information about a single string in the triple store with each resize.
Changes from 1.2.2 to 1.2.3
Changes to the Java interface:
- The server code and Java libraries in this version are not compatible with earlier versions. If an older Java library is used with the newer server, an error is signaled in the server and reflected as an exception in the Java code. If the newer Java library is used with an older server, an exception is thrown in the Java code.
- The performance of cursor operations has been improved significantly. As a result, large AllegroGraph databases will open in TopBraid Composer in half the time or better. Applications that iterate through large cursors will see a similar improvement.
- Avoid an error when a null element appears as the first item in a sequence of strings.
Changes from 1.2.1 to 1.2.2
Changes to the Java interface:
- Avoid an error in TopBraid Composer when an AllegroGraph database contains a typed literal with an XML Schema data-type.
- Improve memory handling for large numbers of unique resources.
Changes from 1.2.0 to 1.2.1
Changes to the Java interface:
- All errors in the server are now reflected as Java exceptions in the Java application.
- Avoid a divide by zero exception when selectValues returns an empty array.
- Avoid an error that produced an incorrect triple as the last cached result of a Cursor instance.
- New command line arguments to AllegroGraphJavaServer -exres and -index allow adjustments to the storage configuration of the server.
- New command line arguments to AllegroGraphJavaServer -standalone and -stop may be used to diagnose storage problems.
Changes from 1.1 to 1.2
Major changes and enhancements
Minor changes and enhancements
- AllegroGraph now supports RDF/XML serialization via the
- The already existing
*synchronize-automatically*has been documented and exported. This provides greater control over triple-store synchronization for increased speed.
- We have improved the selection of hash table parameters to increase performance.
- We have fixed several small bugs in our NTriple import function.
- We have fixed a serious bug that made it impossible to retrieve large literals.
- The symbol
:allegrograph-1.2is now pushed onto
- We fixed a small bug in
next-pthat caused an error if next-p was called after it had already returned
nil. Next-p now correctly returns
nilonce a cursor has been depleted regardless of how many times it is called.
Changes from 1.0 to 1.1
We are now using a faster mechanism to store and retrieve URI information. The new method also uses much less memory so that larger RDF files can be loaded.
The triple store disk format has changed between release 1.0 and release 1.1. Release 1.1 will not read 1.0 triple stores. The easiest thing to do is to recreate your databases with the new version. Please contact us (firstname.lastname@example.org) if you need assistance in converting your 1.0 triple stores into the new format. The section on "Savings Triples to a file" below may also be helpful.
*version*was renamed agraph-version.
pprint-resourcewas renamed to
*index-chunk-count-warning-limit*was removed and
*maximum-indexing-sort-chunk-size*was added; improved the index chunk size selection.
:allegrograph-1.2are now on
:agraphmodule has been loaded.
Minor Enhancements ¯
!!reader macro can be used in compiled code.
!!reader macro and string can now be used in the prolog
- Many more functions and variables have now been documented.
- Many areas of triple query, triple parsing, and retrieval have been optimized.
Changes in the Java Interface
- The Lisp-Java connection always uses two socket ports listening in the Lisp server. The default ports are 4567 and 4568.
- A new method
select()allows triples to be retrieved with a Prolog expression.
- A new method
selectValues()allows arbitrary values (Resources, Literals, or BlankNodes) to be retrieved with a Prolog expression.
- The Lisp-Prolog expression passed in the select() or selectValues() method call is parsed in a fixed package. The package
- A new method
serverTrace()enables or disables trace output in the Lisp server. The trace output shows calls from Lisp to Java, their arguments and the returned values.
- The Lisp server attempts to close databases opened from Java if a connection is closed prematurely or the Lisp server exits.
- The Value class and subclasses implement the
hashCode()method specified by the
- A new method
getParts()allows conversion of id numbers into strings.