Version 3 History

Changes from 3.2 to 3.3

• The convertdb program was moved from the bin subdirectory to the root of the installation directory.

• The part printing rules have changed slightly to be more consistent. The list below summarizes the output. The ??? are printing as UNICODE. The http://www.ex.com/ is the namespace registered for the prefix "ex"; http://www.non.com/ has no namespace prefix registered with it.

concise http://www.ex.com/??? concise http://www.non.com/??? concise ??? concise ???@fr concise ???^^http://www.ex.com/foo terse ??? terse ??? terse ??? terse ??? terse ???

The printer in 3.2 would have output:

concise    <http://www.ex.com/???>  
concise    <http://www.non.com/???>  
concise    ???  
concise    ???@fr  
concise    ???^^http://www.ex.com/foo  
terse      http://www.ex.com/???  
terse      http://www.non.com/???  
terse      ???  
terse      ???  
terse      ??? 

(:ntriples and :long are the same). The change is that :concise consistently has extra punctuation (brackets) removed and that terse is terser than concise. The new code also parts UPI and future-parts the same in all cases

• several new q and q-like functor forms are added. The complete list is:

  (q ?s ?p ?o ?g)  
  (q ?s ?p ?o ?g ?i)  
  (q ?s ?p (-o +o1 +o2))  
  (q ?s ?p (-o +o1 +o2) ?g)  
  (q ?s ?p (-o +o1 +o2) ?g ?i)  
  (q ?s ?p ?o (-g +g1 +g2))  
  (q ?s ?p ?o (-g +g1 +g2) ?i)  
  (q ?s ?p ?o (-g +g1 +g2) ?i ?triple)  
   
  (q ?s ?p ?o (-g (:member +g1 +g2 ...)))  
  (q ?s ?p ?o (-g (:member . +glist)))  
  (q ?s ?p (-o +o1 +o2) (-g (:member +g1 +g2 ...)))  
  (q ?s ?p (-o +o1 +o2) (-g (:member . +glist)))  
   
  (qd +db ?s ?p ...)   all the same spogi patterns as q  
   
  (q- ?s ?p ... )    all the same spogi patterns as q  
    is equivalent to  
    (qd (?? (ground-triple-store *db*)) ?s ?p ...) 

where (ground-triple-store db) is defined as (find-inner-store db :not-typep 'reasoning-triple-store :default db).

• Added db.agraph::make-graph-filtered-store &key name db graphs cached-wrapper-key

Create a triple store that exposes only the triples in the specified graphs. See the documentation for a more complete description.

• Added two new keyword arguments to apply-rdfs++-reasoner:

  1. remote-reasoning - when non-nil, db must be a remote-triple-store

  2. instance. This argument enables reasoning on the server side.

• Added two new keyword arguments to open-triple-store:

  These keyword arguments are allowed and are meaningful only when triple-store-class is specified as remote-triple-store.

  1. apply-reasoner-to - specifies a triple store on the server. The specified store is wrapped with a reasoner and the remote-triple-store refers to the reasoning instance.

  2. has-value-reasoning-enabled -when non-nil, enables hasValue reasoning on the server. This argument is used only when the apply-reasoner-to argument is non-nil.

• print-triples was inconsistent in the way it emitted line breaks. Specifically, it did not emit a line break after the last triple printed, and might emit an initial line break. This behavior was inherited by serialize-ntriples, resulting in N-triples files that did not conform to the RDF standard which requires each line to be terminated.

• load-ntriples now correctly processes \Uxxxxxxxx Unicode escapes and transforms characters larger than 1-bits into surrogate pairs. Conversely, serialize-ntriples and print-triples (in :ntriple format) recognize surrogate pairs and regenerate \Uxxxxxxxx syntax.

• Increased maximum size of string-tables to 2 ³⁹ bytes (512 Gigabytes).

Bug Fixes

• simple-cursors and regular cursors work together when concatenated

• simple-cursors could sometimes return deleted triples when they should not have been.

• simple-cursors could sometimes fail to respect geospatial-subtypes

• simple-cursors could sometimes fail to work properly when used in Java queries.

• SNA path functors were all using all-bidirectional-paths instead the path finding algorithm requested.

• in-memory-triple-stores failed to save typed-literal strings correctly.

• The q functor family was causing entire queries to fail when one of their arguments was not in the store.

• Strings were being added to the string-table even when their values were being encoded.

• Automatic indexing and index-all-triples could conflict with one another leading to non-fully merged indices.

• The printing of future-parts could cause the parts to be interned unnecessarily.

• Improved parsing of future-parts with language literals.

• It was possible for select-distinct to lose some answers

• SPOGI caching could cause some SPARQL queries to fail

• It was possible for AllegroGraph to fail to save metadata changes when type-mappings changed.

Enhancements

• ego-group-member functor handles ground ?members more efficiently

• Reorganized and improved Java condition hierarchy

• Improved hasValue reasoning when there is an explicit subClassOf statement

• Improved transitive property inference and transitive inverse property inference.

• select is more robust when finding SNA generators

• Improved efficiency of SNA generators defined with defsna-generator when there are many clauses.

• select returns SNA paths (or other lists of UPIs) more efficiently

• Improved how the query planner works with prolog:optional.

• Improved error messages signaled by the query planner.

• Improved Client/Server handling of virtual blank nodes returned by SPARQL construct queries.

• Increased efficiency of select with filtered triple-stores and reasoning.

• added API for SNA neighbor-matrices similar to that of SNA generators.

• Improved the query optimizer's handling of several Prolog functors.

• Improved triple-store robustness when the string-table overflows.

• Improved handling of graphs in AllegroGraph Jena adapter.

• Improved interoperability of AllegroGraph 3.3 stores (and 3.2) with older versions of AllegroGraph.

• Enhanced clique so that it can return only maximal cliques.

• Added support for N-Quads to AllegroGraph (see load-nquads, load-nquads-from-string and so on).

• Improved control of duplicate reduction.

• Enhanced support for on-the-fly namespaces in serialize-rdf/xml output.

• Added support for fractional seconds to encoded times and dateTimes.

• many documentation enhancements

• Improved the mechanisms by which the server searches for triple-stores by name.

• added support for text-index-minimum-word-size and text-index-stop-words in the Lisp API.

SPARQL

• Significant SPARQL performance improvements throughout, particularly in Left Joins (OPTIONAL), DISTINCT and REDUCED, and certain numeric FILTERs.

• Massive performance increase for queries with both ORDER BY and a small LIMIT.

• Imposed bindings (:with-variables) now apply to the output portion of SPARQL CONSTRUCT and DESCRIBE queries.

• Some queries that use the SPOGI cache as an optimization could return duplicates. Fixed.

• Similarly, the free-text index now returns distinct results in all cases, which avoids some unnecessary duplicate results.

• Add the ability to use a graph URI, on both input and output, as a signifier for the default graph UPI of the current store.

• Complete xsd:string/simple literal entailment. This allows you to seamlessly switch between using xsd:strings and plain literals without query changes. Plain literals are more efficient for the storage layer, and encouraged in all circumstances. Simply create a datatype mapping for xsd:string with the value :plain to automatically strip type information from strings.

• Improvements (in both efficiency and correctness) for SPARQL comparisons and XQuery functions when handling encoded values.

• RDF/XML serializer can now handle on-the-fly namespace abbreviation, at the cost of more verbose output.

• SPARQL extensions (e.g., geospatial forms) are now permitted by default.

• URIs can now be used to specify geospatial subtypes, as well as the more verbose and less portable UUID form.

• Correct erroneous CONSTRUCT output for certain queries with OPTIONAL parts.

• CONSTRUCT now behaves correctly when triples are constructed with literal subjects or predicates: such triples are silently discarded.

• More efficient short-circuiting behavior for some constant comparisons.

• The SPARQL query engine now skips duplicate triples in more situations, yielding fewer duplicate results and improving performance.

• Preliminary SPARQL Update support. You must pass :extendedp :update to run-sparql. This feature is undocumented and has not been extensively tested.

• Add sparql.server:sparql-protocol-default-dataset-behavior, and a default-dataset-behavior URI parameter to the SPARQL Protocol endpoint. These allow HTTP clients access to the :default-dataset- behavior keyword argument to run-sparql.

Changes from 3.1.1 to 3.2

General

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

Server

• The command line argument --client-select-queries was changed to --client-prolog, and the valid values changed from t, nil and disallow to withlisp, nolisp, and block, respectively.

• The configuration file keyword :client-select-queries was changed to :client-prolog, and the valid values from t, nil and :disallow to :withlisp, :nolisp, and :block, respectively.

Lisp

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.

• Improved the performance of client/server bulk-loading operations (e.g., load-ntriples or load-rdf/xml).

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

SPARQL

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 allegrograph-support@franz.com.

Enhancements

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

Bug fixes

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

Java

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.

• New classes:

  • PrologSelectQuery

    This class includes methods that access the new query planner operations.

  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.

  • ValueSetIterator interface

    An instance of ValueSetIterator delivers 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.

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

Other

• The Python API now supports both Prolog and geospatial reasoning.

Changes from 3.1 to 3.1.1

The additions since version 3.1 were for the Python client API. The documents of interest for Python users are the Python Tutorial and the Installation notes for the Python client.

Changes from 3.0.1 to 3.1

API Changes

• Prior to 3.1, close-triple-store would set *db* to nil regardless 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

  • automatic caching of string-table lookups

  • Caching of subject/predicate queries (SPOGI caching)

  • Many cursor data-structures are automatically reused in both SPARQL and Prolog select queries

  • as well as many other minor enhancements

• Freetext queries no longer return deleted triples.

• has-value-reasoning was previously only available in Prolog select queries. Now it works in calls to get-triples and in SPARQL.

• Data loaders like load-ntriples and load-rdf/xml can now import data directly from a URL without requiring a separate download of a file

• The date-string-to-upi now works with dates, times or date-times.

• Federated triple-stores now support both federated loading and indexing.

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

Bug Fixes

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

SPARQL

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

Java

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.

Details:

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

AllegroGraphService

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

• supported-types returns both encoded and hash UPI type codes; see encoded-types if you want only the encoded UPI type codes.

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

  • added breadth-first-distance, depth-first-distance and bidirectional-distance convenience functions.

• clarified the return values of delete-triple and undelete-triple.

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

• count-query and estimated-count-query now work with federated-triple-stores.

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

• The cut-reader was 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.

• added ag-enable-logging and ag-disable-logging to control whether logging is enabled and to where log information is written.

Java

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.

SPARQL

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

• Added db.agraph.serializer:serialize-ntriples, and added :xml-base argument to serialize-rdf/xml. These allow the generation of files with base URIs suitable for import into TopBraid Composer.

• Minor SPARQL documentation improvements.

General

• 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

  • 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 (support@franz.com) 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.

Copyright (c) 2005 - 2011 Franz, Incorporated

Last updated 18 March 2011 at 11:44