Version 3 History

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 operating on 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

  • subject-upi=, etc
  • subject-part=, etc.
  • upi-typep
  • upi-hash-tables

• 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

• Two new macros have been added to efficiently create and use temporary triples and UPIs: with-temp-triple and with-temp-upi.

• 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-log keyword argument to control where stack backtrace is sent when a client request triggers an error.

• get-triple is now more efficient

SPARQL updates

• 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 Changes

• 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.

    • Similarly, the :use-reasoner keyword argument of get-triples-list has been deprecated.

    • load-ntriples* and load-rdf/xml* - both load-ntriples and load-rdf/xml can now operate on a list of files so the starred versions are no longer necessary.

    • The already deprecated function property-mapping has been removed. Use predicate-mapping in its place.

  • Renamed functions

    • All of the functions in the cursor API now include the word cursor. They are: cursor-next, cursor-next-p, cursor-row, and cursor-next-row.

    • upi-lessp has been renamed to upi<

    • manager, etc. have been renamed to agraph-manager.

  • Other changes

    • create-triple-store no longer creates directories automatically. When you create the triple-store sample, all of the directories above sample must 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-format argument to continue to load non-7-bit ASCII files directly.

• 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.

• Renamed functions:

  • client-chunk-size was chunk-size

  • client-expected-resources was expected-resources

  • client-store-exists was exists

Java API Changes

New classes:

• 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.

• getSNAExtension()

• getGeoExtension()

• 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.

• added deleteStore()

• added findStore()

• 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

SPARQL

• 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 :sized-table :results-format.

Lisp

• 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 db-room and added db-room-list to get information about how much space a triple-store is taking on disk and in-memory.

• 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 display-cleanup-messages.

Java

• We have added getters and setters for defaultTimeout and timeout

• 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

Enhancements

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.

Bug Fixes

Java

• 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

Bug Fixes

• 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

Enhancements

• 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 <uri> element.

• An XML transaction containing a <literal> element with a datatype attribute was causing the transaction to fail. This problem is corrected.

Bug fixes

• The Java 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

Enhancements

• 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.

Bug fixes

• We've corrected several typos in the documentation.

• The Prolog q functor could incorrectly act like qs and 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-literal function 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

Major Changes

Lisp

New Features

• 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.

• The !!-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

• The new ?? 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).

• AllegroGraph can import RDF/XML data using the load-rdf/xml, load-rdf/xml* and load-rdf/xml-from-string functions.

New functions

• 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 t if a triple exists and nil otherwise.

• 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 :if-closed from :error to :ignore

• Create-triple-store: change default value of :if-exists to :supersede

• 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 base-uri parameter

• open-triple-store, create-triple-store, and other triple-store functions now correctly handle relative pathnames.

• added db argument to pprint-subject and pprint-object

• The agraph-manager period has been reduced from 60 down to 2 to help it keep the triple-stores running optimally.

• Change the default value of the :wait parameter from nil to t in index-all-triples, index-new-triples and close-triple-store.

• 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.

Bug fixes

• Fixed a bug in new-blank-node, intern-literal and intern-resource that caused problems when they were called with a triple-store not equal to the current one (*db*).

• 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.

SPARQL

• 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

• corrected RDFterm-equal

• 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.

• Exported *sparql-default-graph-behavior*.

• exporting sparql:*dataset-load-function* to provide hooks into the FROM clause

RDFS++ Reasoner

• The RDFS++ reasoner now support owl:hasValue restrictions (this is not fully documented, please contact Franz if you have questions)

• Both rdfs:subPropertyOf and rdfs:subClassOf now correctly handle transitivity

• Queries of the form (q- ?s !rdf:type ?o) now correctly find all results.

Java

• addPart() method allows ValueObject instances to be created from N-Triples or using the !-notation (i.e., Literal, Node and BlankNode instances).

• corrected error: 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:

  • getNamespaces()
  • registerNamespace()
    
  • registerNamespaces()

• corrected error: hasStatement() with wild card was throwing error

• corrected error: getSubjectLabel() and friends were failing or giving incorrect results for some Cursor instances

• corrected error: getParts() was throwing exception if argument was a BlankNode

• The function loadRDF() is available once again.

• If desired both loadRDF() and loadNtriples() can now return the UPI of the graph used during the load.

Changes from 2.0.1 to 2.1

General

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.

Performance improvements

• 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.

Bug fixes

• (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.

Java-specific

Major Changes

• 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.

Minor Changes

• New parseNTriples can parse strings in N-Triple format and add the triples to a triple-store
• Added idle-life argument to make-sesame-server and export-to-sesame. This parameter specifies how long an idle triple store should remain open.
• Added timeout and idle-life arguments 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: -nojava, -http and -hinit allow a single server to work with either Java, HTTP or both simultaneously.
  • The pair timeout and idle-life parameters set the timeout and idle-life of the server and triple-stores respectively

Bug fixes

• The 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

New functionality

• AllegroGraph now runs on the Windows platform (both 32 bit and 64 bit windows are supported).
• Added undelete-triples function
• The API of delete-triple, undelete-triple and deleted-triple-p have changed to match that of the rest of the public functions
• The functions open-triple-store, delete-triple-store, triple-store-exists-p and create-triple-store all accept logical-pathnames for their name parameter in addition to strings.
• Added load-ntriples-from-string to read a string containing one or more triples in N-Triple format.
• You can now use :unindexed-triple-count-threshold and :unmerged-chunk-count-threshold as parameters to create-triple-store.
• The value->upi function does a better job of converting strings into typed UPIs
• Exported and documented the functions db-room and estimate-required-space
• Added the macro iterate-cursor and the function map-cursor.
• 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 t to 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 *.
• Added query->verb function 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.

Fixes

• 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-id could 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-mapping has been deprecated in favor of predicate->mapping
• The function upi->string has been removed (use part->string in its place)
• Because its behavior was ambiguous, load-ntriples no longer parses strings in N-Triple format. Use load-ntriples to read N-Triples from files or streams and use load-ntriples-from-string to read N-Triples from a string.
• The function do-cursor has been deprecated in favor of the new function map-cursor and the new macro iterate-cursor.

Known problems

• (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

• Added selectStatements() methods and deprecated the select() methods
• Added 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 EncodedLiteral and methods createEncodedLiteral()
• Added additional signatures to getStatements() and 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
• the moreValues() method now always returns the full count and never an estimate
• twinqlSelect() returns an array that can be refilled using selectMore()
• twinqlFind() is now more efficient

Fixes

• Correct error that caused getNamespaces() to return null
• Correct error that caused exception in deleteTriples() calls

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.

Miscellaneous changes

• You can control the indices used by each triple-store:
  • At creation-time, you can use the with-indices parameter.
  • You can use add-index, add-indices, drop-index, and drop-indices after a triple-store has been created.
• Added ag-property (and 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 resource and literal return future-parts.
• 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:
  • add-triple-by-number
  • get-triples-by-number

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 create-triple-store, 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 open for the :if-exists keyword parameter to create-triple-store. This will cause create-triple-store to open the store if it already exists.
• Added an if-exists parameter to open-triple-store. It can take on the values :supersede or open.
• Added a default-graph parameter to load-ntriples.
• Load-ntriples returns, as multiple-values, the number of triples loaded and the default-graph used.
• Added a stream argument to print-triples.
• Aside from support for range queries, get-triples and get-triples-list can now take optional filters to limit the triples returned.
• The family of select functions can¯ now produce arbitrary templates rather than only lists of triples.

Java related

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

AllegroGraph is now integrated with TopBraidComposer and can run as a service accessible to Java programmers using either JLinker or a direct socket interface.

AllegroGraph now comes with a full SPARQL implementation via its twinql sub-system. See the AllegroGraph SPARQL tutorial, the twinql API reference manual, and the release notes for more details.

Minor changes and enhancements

• AllegroGraph now supports RDF/XML serialization via the serialize-rdf/xml.
• 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.2 is now pushed onto *features*.
• We fixed a small bug in next-p that caused an error if next-p was called after it had already returned nil. Next-p now correctly returns nil once a cursor has been depleted regardless of how many times it is called.

Changes from 1.0 to 1.1

Major changes

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 ([email protected]) 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.

Minor changes

• *version* was renamed agraph-version.
• pprint-resource was renamed to pprint-subject and pprint-object was added.
• get-node-short was removed--use part->string with :format :concise instead.
• *index-chunk-count-warning-limit* was removed and *maximum-indexing-sort-chunk-size* was added; improved the index chunk size selection.
• :allegrograph, :allegrograph-1.1, and :allegrograph-1.2 are now on *features* once the :agraph module has been loaded.

Minor Enhancements ¯

• The !! reader macro can be used in compiled code.
• The !! reader macro and string can now be used in the prolog q functor.
• 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 :db.agraph.user that uses :cl :excl :prolog :db.agraph and :db.agraph.java.
• 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 org.openrdf.model interfaces.
• A new method getParts() allows conversion of id numbers into strings.