Introduction

This document has release notes for several releases prior to the current release. The release notes for the current release are here.

Releases are numbered X.Y.Z. A major release has a number X.Y.0 or X.0.0. Usually a change to the first digit (from, say, 6.5.4 to 7.0.0) indicates a major enhancement or revision, a change to the second digit (7.0.4 to 7.1.0) indicates important changes and new features, and a change to the third digit (7.1.0 to 7.1.1) indicates bug fixes and minor enhancements. The Change History document repeats the list of user-visible modifications for every AllegroGraph release.

Database internal format is changed from version 7.1.0

The database format is changed from time to time. When the format is changed, databases must be upgraded to the new format before they can be used. Upgrading is discussed in the Database Upgrading document. The format in version 7.2.0 is changed from version 7.1.0 and all earlier releases. (The format was previously changed in release 6.7.0.) Therefore it is necessary to upgrade 7.1.0 and earlier databases for them to be used with 7.2.0. Note that backing up repositories before upgrading them to a new version is always recommended. Once a database has been used in a later release, it cannot be used in an earlier release regardless of whether the database format is the same. Upgrading is discussed in the Repository Upgrading document.

Release 7.2.0

See the current release notes.

Release 7.1.0

Release 7.1.0 is a major release with important new features.

Database internal format is unchanged from version 7.0.4

This means version 7.0.4 repositories can be directly loaded into version 7.1.0 without upgrading. Note that backing up repositories before loading them into a new version is always recommended. Once a database has been used in a later release, it cannot be used in an earlier release regardless of whether or not the database format is the same. Upgrading is discussed in the Repository Upgrading document.

Release 7.0.4

Release 7.0.4 is a maintenance release fixing bugs and providing enhancements. There are no major new features.

Release 7.0.3

Release 7.0.3 is a maintenance release fixing bugs and providing enhancements. There are no major new features.

Release 7.0.2

Release 7.0.2 is a maintenance release fixing bugs and providing enhancements. There are no major new features.

Release 7.0.1

Release 7.0.1 is a maintenance release fixing bugs and providing minor enhancements. There are no major new features.

Release 7.0.0

Release 7.0.0 is a major release with significant new features.

The most important new feature is distributed repositories.

Distributed repositories (see the Distributed Repositories Tutorial) allow data to be distributed over several repositories, called shards. Each shard runs on its own server separately from other shards (a single server may support more than one shard). Queries then are run by each server on each shard, with results combined after all individual queries have completed. With very large databases, use of distributed repositories can significantly speed up certain kinds of queries. See the documents Distributed Repositories Tutorial and Distributed Repositories Setup for more information.

Gruff in a browser is available in AllegroGraph 7.2.0. Gruff is a graph visualization and graphical query builder designed to work with AllegroGraph. It is available as a standalone application (see the Gruff page on the AllegroGraph website) and it will run in a browser tab. See Gruff in AllegroGraph document for more information. Documentation for Gruff itself is in the Gruff document.

We have added to the AllegroGraph examples on Github repo. There are examples of using Multi-master replication to allow for scaling out query load. These examples use Kubernetes, Terraform, load balancing with NGINX, and so on.

Release 6.6.0

Release 6.6.0 is a major release with significant new features, including the following:

Release 6.5.0

AllegroGraph 6.5.0 was released on March 4, 2019. Release 6.5.0 is a major release with significant new features, including the following:

Admin notes

These sections note changes which may affect AllegroGraph administration, which includes managing users, dealing with passwords, and so on.

7.1.0 Admin notes

There are no admin notes for release 7.1.0.

7.0.3 Admin notes

There are no admin notes for v7.0.3.

7.0.2 Admin notes

7.0.1 Admin notes

There are no admin notes for v7.0.1.

7.0.0 Admin notes

Programmer notes

These sections note changes which may affect how certain operations or code work compared to earlier releases. These are emphasized here because the changes may be unexpected. The complete list of user-visible changes below also mentions these changes in a shorter format.

7.1.0 Programmer notes

7.0.4 Programmer notes

An unexplained problem with Internet Explorer (IE) 11 makes it unable to display AGWebView. All other important browsers, including Edge, work fine. The problem seems to be related to running JavaScript.

7.0.3 Programmer notes

There are no programmer note for version 7.0.3.

7.0.2 Programmer notes

There are no programmer note for version 7.0.2.

7.0.1 Programmer notes

7.0.0 Programmer notes

6.6.0 Programmer notes

There are no programmer notes for release 6.6.0.

User visible changes

These sections list changes in some releases prior to the current release. See the Change History for a list of changes in all earlier releases.

AllegroGraph 7.1.0

AllegroGraph Server: General Changes

New storage-report option to agtool

The tool shows storage used by a repository. See here in the agtool General Command Utility document.

The Table in the Cluster Managment page modified

The table is illustrated in the Multi-master Replication document. The table now shows the host and port of each instance.

Rfe16562: Support limiting agtool query output to results only

The output of agtool query can now be limited to results only by specifying the --quiet option. When --quiet is set, all log output will be written to the agquery.log file. See agtool query for more information.

Rfe16543 - Replace default index :gospi by :psogi

The set of default triple indices has been modified: gospi has been taken out, and psogi has been added. See 7.1.0 Programmer Notes above.

Rfe16540 - Add support for creating, deleting, and listing repos and dynamic catalogs with agtool

agtool has new repos and catalogs tools. They can be used, respectively, to create and delete repos (including replicated repos) and dynamic catalogs. The tools can also list existing repos and catalogs. See the agtool document for more information.

Bug26221 - Speedup Freetext Index (FTI) phrase match searches

Fixed an inefficiency in FTI phrase matches that caused a slowdown when a word in the phrase appeared in a single triple multiple times. This is now optimized. The speedup seen will vary based on the frequency in which a word from the phrase appears in a given triple. For small string literals and resources, the improvement will be very modest, but for phrase matches in large string literals the speedup can be significant

HTTP Client

No significant changes.

SPARQL

Rfe16530 - Add support for xsd:dateTime subtraction in SPARQL queries

Arithmetic operations in SPARQL's BIND clauses now support xsd:date/xsd:time/xsd:dateTime subtraction that returns xsd:duration values, i.e. query like 

SELECT ?x  
WHERE {  
    BIND (("2020-07-29T17:26:08Z"^^xsd:dateTime -  
           "2020-07-28T17:26:08Z"^^xsd:dateTime) AS ?x)  
}

will return a value 

"P1D"^^xsd:duration

Note that results of date/time subtraction are restricted to xsd:dateTimeDuration subset of xsd:duration values for simplicity reasons.

Rfe16528 - Remove reorderDuringExecution query option

In practice the pattern estimates are good enough to not have to consider reordering. Using the special query prefix: 

PREFIX franzOption_reorderDuringExecution: <franz:yes>

will now give a query warning: 

obsoleteQueryOption: reorderDuringExecution

Rfe16510 - Support for SPARQL*

AllegrGraph now supports queries that use the SPARQL* syntax, like: 

select * {  
  << ?s ?p ?o >> <ex:key> ?value  
}  
 
select * {  
  bind( << ?s <ex:pred> ?o >> as ?triple )  
}

A reified triple is represented as an IRI that looks like: <http://franz.com/ns/allegrograph/4.0/tripleId#123> which means isIRI(?triple) will return true for reified triples.

There is a new SPARQL filter function: isTriple(?triple) that returns true only if ?triple is a reified triple.

SPARQL* queries are not yet supported on federated or distributed repositories.

Rfe16504: Remove "enableDuplicateReduction" query option

The SPARQL query option enableDuplicateReduction, if set to true, would behave somewhat like specifying reduced. In all cases where it would be relevant to enable this reduction, it is better to specify reduced or distinct in the query. Therefore the setting is removed.

Usage of the franzOption_enableDuplicateReduction query prefix will now lead to a warn-obsolete-query-option entry in the query result metadata: 

(run-sparql "PREFIX franzOption_enableDuplicateReduction: <franz:yes>  
             select ...")

has fourth return value: 

#<done  
  [warn] obsolete-query-option: enableDuplicateReduction  
  [time] ...  
  ...>

Bug26333 - Property paths that join bindings may produce bogus results

It was possible for the SPARQL sequence property paths to produce too many results when joining bindings from VALUES clauses or subqueries. This has been fixed.

Bug26290 - Max when some variable is unbound, must give unbound result value

In AllegroGraph 6.7.0 a SPARQL regression was introduced, where SPARQL MAX aggregator would treat unbound values as bound values (lowest in ordering) and so return a bound value as result.

This was incorrect: when aggregating over an unbound value, the aggregation result should be an unbound value due to a SPARQL type error in the aggregation.

This has been fixed, so that the aggregation result is the unbound value in the described case.

Bug26282 - Stack overflow during OPTIONAL query planning

Certain queries containing an OPTIONAL clause could lead to an error ("stack overflow") during query planning. This is now fixed.

Bug26260 - Fix spurious "emptyBindClause" query warnings

SPARQL queries with a BIND clause at the start of a BGP could generate a spurious "emptyBindClause" warnings saying: 

The BINDING form for ?val cannot succeed

This can be an incorrect warning if the BIND expression does a special operation that can deal with unbound variables, like BOUND, COALESCE, IN or IF.

Examples: 

select * {  
  bind(bound(?o) as ?val) .  
}  
-> ?val = false  
 
select * {  
  bind(coalesce(?o,1,2) as ?val) .  
}  
-> val = 1

This is now fixed so that no spurious warnings are generated.

AGWebView

Bug26332: Broken bulk namespace input dialog in AGWV

The Add a namespace button in query editor shows a dialog that has a Bulk Input button which in turn should be showing a different dialog that allows to input multiple namespace declarations at once. This dialog was broken and an empty dialog box was shown instead. This has been fixed. See the New Query Page section of the WebView document for more information on the Add a namespace button.

Changes to the Lisp API

No significant changes.

Prolog

No significant changes.

Documentation

No significant changes.

Distributed AllegroGraph

No significant changes.

AllegroGraph 7.0.4

AllegroGraph Server: General Changes

Rfe16569 - backup-all (and restore-all) now backs up gruff options

agtool archive backup-all/backup-settings now backs up the settings/gruff/ directory.

Bug26353 - Turtle parser failure on prefixes with upper-case characters

Turtle parser was incorrectly converting prefixes of prefixed names to lower-case if they were at the beginning of the lines and started with the same (ignoring the case) characters as Turtle keywords prefix or base, which caused a namespace lookup failure.

For example, an attempt to parse the following Turtle 

 prefix Basic: <http://example.org/basic#>  
 Basic:subject Basic:predicate Basic:object.

failed with the following error 

 While parsing /path/to/file.ttl: Turtle parser  
 error on line 2: No prefix expansion defined for 'basic'

This has been fixed.

HTTP Client

No significant changes.

SPARQL

Bug26348 - Fix handling of the FROM clauses of SPARQL ASK queries

Starting with AG 7.0.0, running SPARQL ASK queries with the FROM clauses failed with a verbose error that said something like keyword list ... should only contain ... but unexpectedly found .... This has been fixed.

Bug26346 - Fix 'Funcall of nil which is a non-function' error

It was possible to get a Funcall of nil which is a non-function error when executing a SPARQL query that has a UNION of GRAPH clauses with unsatisfiable patterns. This has been fixed.

Bug26331 - Restriction reasoning did not work in remote Lisp AG client

Both SPARQL and Prolog queries run from a remote Lisp AllegroGraph client would miss inferred results when restriction reasoning is enabled. This has been fixed.

AGWebView

No significant changes.

Changes to the Lisp API

No significant changes.

Prolog

No significant changes.

Documentation

No significant changes.

Distributed AllegroGraph

No significant changes.

AllegroGraph 7.0.3

AllegroGraph Server: General Changes

No significant changes.

HTTP Client

No significant changes.

SPARQL

Rfe16530 - Add support for xsd:dateTime subtraction in SPARQL queries

Arithmetic operations in SPARQL's BIND clauses now support xsd:date/xsd:time/xsd:dateTime subtraction that returns xsd:duration values, i.e. query like 

SELECT ?x  
WHERE {  
    BIND (("2020-07-29T17:26:08Z"^^xsd:dateTime -  
           "2020-07-28T17:26:08Z"^^xsd:dateTime) AS ?x)  
}

will return a value 

"P1D"^^xsd:duration

Note that results of date/time subtraction are restricted to xsd:dateTimeDuration subset of xsd:duration values for simplicity reasons.

Bug26309 - Missing zero-length property path results if both s and o are collections

It was possible for a query of the form: 

select ... {  
  values ?start { ... }  
  values ?end { ... }  
  ?start ( <ex:pred1> / <ex:pred2>* ) ?end  
}

with triple data: 

<ex:s> <ex:pred1> <ex:o>

to not return the valid solution: 

?start = <ex:a>  
?end = <ex:b>

where was followed zero times, so effectively not followed. This is corrected.

Bug26293: Property path error if object value constrained

In certain cases a property path expresion in which the object value is constrained to a literal, could lead to an error.

For example in this query ?o is constrained to value 2: 

SELECT ... {  
  bind(2 as ?o).  
  ?s <ex:p>+ ?o  
}

Depending on the active indices and the exact triples in the repository, this could give the error: 

The assertion  
  (loop for x in (list s p o g s-end p-end o-end g-end)  
    always (typep x (quote (or upi null))))  
failed

This is now fixed.

Bug26282 - Stack overflow during OPTIONAL query planning

Certain queries containing an OPTIONAL clause could lead to an error ("stack overflow") during query planning. This is now fixed.

AGWebView

No significant changes.

Changes to the Lisp API

No significant changes.

Prolog

No significant changes.

Documentation

No significant changes.

Distributed AllegroGraph

No significant changes.

(remark -- 7.0.2 start ; -- }

AllegroGraph 7.0.2

AllegroGraph Server: General Changes

An AllegroGraph server may restrict itself to the number of licensed cores

If the UseLicensedCores configuration directive is specified true (that is UseLicensedCores true is in agraph.cfg) then the agraph process will automatically reduce the number of cores it uses to the value given in the license file. Otherwise the server will fail to start up if there are more cores on the machine than the license specifies.

Bug26226 - Changing passwords in AGWebView could fail

When a password has expired, changing it in AGWebView could fail. This has been fixed.

Bug26221 - Speedup fti phrase match searches

Fixed an inefficiency in FTI phrase matches that caused a slowdown when a word in the phrase appeared in a single triple multiple times. This is now optimized. The speedup seen will vary based on the frequency in which a word from the phrase appears in a given triple. For small string literals and resources, the improvement will be very modest, but for phrase matches in large string literals the speedup can be significant

HTTP Client

No significant changes.

SPARQL

Bug26274 - Insert ..^^xsd:string fails

Queries that insert a triple with an XSD string as object, like: 

INSERT {  
  <ex:s> <ex:prop> "2.0.0"^^xsd:string .  
}  
WHERE { }

would fail with the error message: :string fell through a ecase form. This is fixed.

Bug26273 - Do not skip index when rewriting left-joins to joins

In some cases the system would skip the index component of a plan step when constructing a JOIN plan step. This was breaking the assumption that index is non-nil when removing equivalent variables from JOINs. This is now fixed.

Bug26272 - Count DISTINCT of UNION incorrect

It was possible for queries with COUNT DISTINCT of a UNION to give a number that was too high. For example: 

SELECT (COUNT (DISTINCT ?s) as ?s)  
{  
  { ?s <ex:p1> <ex:o1> }  
  union  
  { ?s <ex:p2> <ex:o2> }  
}

This is now fixed.

Bug26263 - Type errors when using UNION and FILTER

This is an issue relevant to queries containing UNION in which an unprojected variable occurs both inside the UNION (at most once per UNION subclause) and once outside it, like ?o in: 

SELECT DISTINCT ?s {  
{ ?s <ex:p1> ?o } UNION { ?s <ex:p2> ?o }  
FILTER (?o > 3)  
  }

In such cases it was possible for ?o to become unbound in the second occurrence (in the FILTER clause) even though the first UNION clause would bind it. This would lead to incorrect query results.

This is now fixed.

Bug26259 - Property path error: "the value of p is "

Certain property path expression would fail with the error: 

the value of db.agraph.sbqe.property-path::p is  
#<db.agraph.utility.dictionary:dictionary ...>  
which is not of type (or null upi real).

This is fixed.

Bug26240 - SPARQL property path that joins bindings misses results

It was possible for property path expressions to miss certain results if the subject or object of the property path was bound by a previous pattern. This is now fixed.

Bug26236 - Errors when using multi-match clause with multiple vars as filter-pattern

There were situations where a query containing a "VALUES" or "FILTER (.. IN ..)" clause, in combination with other patterns, would give incorrect query results. This has been fixed.

Bug26235 - Assertion error :is-ordered-cursor-for-distinct-variable

It was possible for queries with DISTINCT to fail with the error: 

the assertion  
  (null (getf (db.agraph.cursor::cursor-properties db.agraph.sbqe::cursor)  
              :is-ordered-cursor-for-distinct-variable))  
failed.

This has been fixed.

Bug26222 - SPARQL FILTER range errs if there are objects with non-overlapping type

If a SPARQL query included a numerical filter, in the presence of triples whose object value is of a numerical type that does not overlap with that range, this would signal an error at query plan time.

For example: 

SELECT * {  
  ?s ?p ?o .  
  FILTER (?o > 3 && ?o < 10)  
}

This range (3, 10) of positive integers does not overlap with type xsd:negativeInteger. If the repository contain a triple like: 

{ <ex:s> <ex:p> '-123'^^xsd:negativeInteger }

the resulting error would be: 

Error: `3` is not of type xsd:negativeInteger, exceeds the maximum: -1  
  [condition type: xsd-datatype-error]

This has been fixed

AGWebView

No significant changes.

Changes to the Lisp API

No significant changes.

Prolog

No significant changes.

Documentation

No significant changes.

Distributed AllegroGraph

Bug26220 - Fedshard failure for "count distinct" with "group by"

When using FedShard, running a query that combines COUNT DISTINCT with GROUP BY could result in an error. For example: 

SELECT ?s (COUNT(DISTINCT ?o) AS ?count) {  
  ?s ?p ?o  
} GROUP BY ?s

This has been fixed.

AllegroGraph 7.0.1

AllegroGraph Server: General Changes

Rfe16481 - Increase triggered checkpoint timeout

Previously while adding a replica of a large repo on a large memory machine an error like the following could occur:

Error: instance add failed with code 400, body "failed with message: Could not trigger a checkpoint: Checkpointer process failed to respond"

This has been fixed.

Bug26176 - SHACL validation would consider shape graph triples

Under certain circumstances, SHACL validation would incorrectly consider shape graph triples for validation, resulting in reporting triples non-conforming when the data graph triples actually conformed. (Reporting triples as conforming when in fact they did not conform never occurred.) This has been fixed. SHACL and SHACL validation are described in the SHACL document.

HTTP Client

No significant changes.

SPARQL

Rfe16452 - Let GROUP BY with no result rows give zero result rows

The results of GROUP BY queries with aggregates in an edge case has been changed to closer follow the intention of the SPARQL 1.1 standard.

Take this query and assume there are no triples with predicate : 

select ?s (count(?o) AS ?count)  
where {  
  ?s <ex:p> ?o  
} group by ?s

AllegroGraph would return one result row with ?s unbound, and count zero.

An alternative behaviour that some other triple stores have, is to return zero result rows. The text of the SPARQL 1.1 standard conflicts with the "agg-empty-group2" test case, so that either behaviour is reasonable.

The current consensus is that having zero result rows was intended, and is expected by users. See e.g. https://afs.github.io/sparql-agg-group-empty.html#group-agg-no-rows

AllegroGraph has been updated to follow this consensus. So for GROUP BY queries with aggregates, in case of zero matching pattern in the body, there will be zero result rows.

Bug26190: Incorrect rewrite of OPTIONAL with non-patterns on LHS

In some cases queries of the form: 

SELECT .. {  
  VALUES ..  
  ..  
  OPTIONAL { .. }  
}

could be optimized incorrectly, resulting in missing query results. This has been fixed.

Bug26188 - Executing query failed for query with VALUES

Certain queries of the form: 

SELECT .. {  
  VALUES ?x { <a> <b> <c> }  
  .  
}

could lead to an error: 

Error: the value of ag.sbqe::index is nil,  
       which is not of type ag.sbqe::plan-index-type.

this has been fixed.

Bug26181 - Incorrect :time-total addenda value for query on remote store

When executing a SPARQL query in AGWebView the Information tab shows query execution statistics, including the time it took to plan, execute, and output query results.

It could happen that the total time would be incorrect (too low). This has been fixed.

AGWebView

No significant changes.

Changes to the Lisp API

No significant changes.

Prolog

No significant changes.

Documentation

No significant changes.

Distributed AllegroGraph

Rfe16457 - improve shard-local kb support

Previously, when defining a distributed store in the cluster config file, there was limited support for shard-local kb's by including localhost in the KB declaration. That is the following declaration would define a kb on localhost and would inherit whatever scheme/port were the default at the point where the declaration was made: 

KB localhost/catalogs/tests/repositories/kb4

If these defaults match the scheme/port used by each AG shard, then the KB will be shard-local. Now, any triple-store-spec that does not include a server part can be used to define a shard-local KB. Thus 

KB tests:kb4

no longer will inherit defaults from the environment at the point of the declaration, and will inherit the scheme/port of each shard, even if scheme/port differ across all shards.

See the Distributed Repositories Using Shards and Federation Setup document.

Bug26187 - Do not track servers in KB directives

In Distributed AllegroGraph, the servers that comprise a cluster are derived from the directives that refer to servers in the agcluster.cfg file. This includes server, repo, replica, and --incorrectly-- kb directives.

The servers referred to only in KB directives are no longer considered as part of the cluster. This allows remote KBs which do not reside on a cluster host.

AllegroGraph 7.0.0

AllegroGraph Server: General Changes

agtool load changes

The (undocumented) --blank-node-cache-size argument has been removed. (Even though this argument was undocumented, some users may have been told of its existence.) Blank nodes are no longer cached during data loading.

There is a new -w/--workspace option to agtool load. The value should be an existing directory which will be used for temporary files during data loading, particularly for the temporary storage of a table of blank node information. Absent this option, temporary data is stored in /tmp and if that directory is too small, the load will fail.

agtool now supports a triple-count tool

The triple-count tool returns the number of triples in a repository. See here in the agtool document.

agraph-control now takes a --cluster-config control option

The option allows the path of the cluster configuration file to be specified. This file defines distributed repositories (see Distributed Repositories Setup). The agraph-control program is described in the agraph-control of the Server Configuration and Control document.

Adding a triple with a predicate mapping and a datetype mapping might add two triples

Before this change, when adding a triple, if both a predicate mapping and a datatype mapping applied to the object of the triple, two triples would be added. The new defined behavior is that predicate mappings take precedence over datatype mappings.

index-literals argument passed when creating/modifying a freetext index

When creating a freetext index, the index-literals argument determines if and/or under what circumstances a literal will be indexed. The value passed can be either a boolean or a list containing UPIs, future-parts, or strings.

With this change, when passing a string to index-literals, it is expected to be equivalent to the value returned when calling part->value. That is, the string should not contain any embedded angle-brackets (< or >) or double-quotes (") used to denote the string represents a resource or literal, that are not part of the actual value represented by the string.

Rfe16417 - Deprecate style 2 indices

There are two triple index styles available, "style 1" and "style 2", with different storage structures and thus performance characteristics. In practice "style 1" was generally recommended, and "style 2" has been deprecated. The latter has been removed from the documentation and might be removed in a future release.

Rfe16386 - New BriefBacktrace configuration directive.

See the [administrator note](#admin-notes-700} for more information. See Server Configuration and Control for information on configuration directives.

Rfe16364 - New LicenseWarnInAdvance configuration directive.

See the administrator note for more information. See Server Configuration and Control for information on configuration directives.

Rfe16283 - New configuration directive to control the stale DNS retain time

There is a new configuration directive StaleDNSEntryRetainTime which specifies how long AllegroGraph will retain a stale DNS entry. If the DNS mapping from name to IP address may change while the application is running you'll want to specify a very small value (number of seconds) for this directive. See StaleDNSEntryRetainTime in Server Configuration and Control.

Rfe16244 - Update PARSE-NTRIPLES to support N-Triples 1.1 blank node syntax

When importing N-Triple data, certain blank node formats with dots, dashes or underscores were unsupported. For example importing this line: 

 <http://s> <http://p> _:a-b_c.d .

would fail with: 

 Error: N-Triples parser error while parsing string at line 1  
       (last character was #\_): Illegal character

Now AllegroGraph supports the blank node syntax as defined in the N-Triples 1.1 technical recommendation.

Rfe16239 - agtool load/export/archive from/to s3

agtool can access files in Amazon S3. To do so, AWS authentication must be specified on the agtool command line. See the section Accessing and operating on files on Amazon S3 in the agtool document. Files in S3 must be prefaced by s3://, like the following: 

 s3://bucketname/a/b/c/filename

Rfe14667 - Log THP warning only (don't show in AGWV)

The THP (Transparent Hugepages) warning is now logged to agraph.log only and not the console or AGWebView.

Bug26040 - agtool archive restore to a different repo.

The documentation printed by 'agtool archive restore --help' claimed that if the archive directory contained only one repo backup then you needn't name that backup if you restored to a different repo name. This claim has been removed from the documentation because the behavior isn't supported.

Bug26017 - Literal language in rdf/xml was not properly loaded

Previously, instead of setting the language of the literal object, an additional triple with the object being the language value and the predicate http://www.w3.org/XML/1998/namespacelang was incorrectly added to the triple store.

For example, <rdfs:label xml:lang="fr">Autriche</rdfs:label> loaded as: 

<subj> <pred> "Autriche"  
<subj> <http://www.w3.org/XML/1998/namespacelang> "fr"

Bug26011 - Allegrograph licensed cores check prints wrong core count in error message

Previously if the number of CPU cores exceeded the licensed limit, AllegroGraph would generate an error message like the following:

This machine exceeds the CPU core count specified in the license. Maximum licensed cores: X. This machine has: Y.

The value of X would be the license limit but the value of Y would potentially be incorrect (it would report the number of available threads, rather than the number of cores in the machine, which will be different values if hyperthreading is enabled). This has been fixed.

Bug26000 - Fti recovery crashes if stray fti files exist from a prior instance crash

In some circumstances instance recovery could fail with an error message like the following: 

opening of database myrepo has failed (The database system tried to  
allocate a new file with the logical name fti-1-chunk-1 which already  
exists in database myrepo)

This has been fixed.

Bug25999 - Crashed instance process can leave service daemon in confused state

Under some circumstances a crashed instance process would not be automatically restarted by the service daemon. This has been fixed.

Bug25986/Bug25997 - Fix agraph-backup tool initialization issues

When the repo spec was used to specify the repository, the credentials and host values from the spec were ignored and the tool always attempted to connect to 127.0.0.1. This commend thus 

$ agtool archive backup test:xyzzy@remotehost:10035/test test.bak

could fail with a Connection refused (errno 111) message because the host is not localhost. Specifying the credentials when restoring data also could cause the tool to fail (bug25997): 

 # Fails with the message 'Invalid arguments (:params,  
 # :restore-mode-p) found while creating triple-store of class  
 # db.agraph:remote-triple-store. ...'  
 $ agtool archive restore-all test.bak test:xyzzy@127.0.0.1:10035

Both these issues have been fixed. Note that using deprecated arguments like --host and --port could cause problems if the values specified did not match the values in the REPO-SPEC, even default (and thus not-visible) values in some cases. See Older repository specification arguments in the agtool General Command Utility document for examples.

Bug25959 - Fix ACID isolation violation in some ordered cursor operations.

Fixes a bug introduced in v6.5.0 where some ordered triple cursors could produce triples that were not visible in the current transaction. The scope of the problem was limited to triples committed in concurrent transactions that had yet to be written to disk.

Bug25907 - Document how to pass args to agraph using agraph-control

The ability to use agraph-control to pass arguments to the agraph program (which is called by agraph-control) when starting or restarting AllegroGraph existed prior to this change, but was not clearly documented. How to do so is now documented in the agraph-control --help text and in the description of agraph-control in the Server Configuration and Control document.

Bug25901 - Importing triples bypassed security-filters

It was possible for users with security-filters to import triples into a db that those filters were intended to prevent.

This problem is now fixed.

Bug25880 - Remove whitespace trimming in TRIX literals parsing

To restore the behavior specified by the standard, removed whitespace trimming in the TRIX parser while parsing literals.

HTTP API

No significant changes.

SPARQL

Rfe16433 - Remove full-scan-warning

The query warning type "warn-fullscan" and the query option "fullScanWarningSize" have been removed.

In practice these warnings could occur without there being a problem with the query. It would fill agraph.log with warning lines that would be ignored, defeating the purpose.

Usage of the franzOption_fullScanWarningSize query prefix will now lead to a warn-obsolete-query-option entry in the query result metadata: 

(run-sparql "PREFIX franzOption_fullScanWarningSize: <franz:210000000>  
             select ...")

has fourth return value: 

#<done  
  [warn] obsolete-query-option: fullScanWarningSize  
  [time] ...  
  ...>

Rfe16324 - Warn on ASK modifiers

An ASK query does not support LIMIT, OFFSET, or ORDER BY. Now a query warning is signaled if any of these is provided, with the exception of LIMIT 1.

Rfe16279 - Improve checking for unknown constants in the query

The check for unknown constants in the query at plan time is now more advanced, resulting in faster query execution.

For example if a resource <s> only occurs in the subject position of triples, a pattern like ?s <p> <s> will now be marked impossible at plan time.

Another example are references to standard IRIs that are present in every repository automatically, like <http://www.w3.org/1999/02/22-rdf-syntax-ns#type>. Previously a pattern like ?s a ?foo would never be marked impossible, but now if there are no triples with such predicate, the pattern will be marked impossible.

This also has effect on magic properties like <http://franz.com/ns/allegrograph/3.0/temporal/intervalBefore> that under the hood expand into patterns with properties like <t:starttime>, <t:startpoint> and <t:time> (with http://franz.com/ns/allegrograph/3.0/temporal/ as t). If a repository only uses starttime, and never the startpoint/time combination, the plan will be optimized accordingly.

Bug26144 - CAAT ignores :pattern-filters of query patterns

Queries executed with the Chunk-at-at-Time (CAAT) strategy (so with a LIMIT, without DISTINCT or aggregators) could give incorrect results, if a specific query pattern was planned to act as filter for another pattern. This has been fixed.

Bug26143 - Graph <g> {} gives error

A query with an empty named graph clause, like: 

select ?s ?o {  
  graph <ex:g> {}  
  ?s ?p ?o .  
}

would fail with an error: Attempt to access the name field of {g} which is not a symbol. This is now fixed.

The meaning of graph <ex:g> {} as a pattern, is that some triple must exist in the given fixed graph <ex:g>. The meaning of graph ?g {} is that some triple must exist in any named graph.

Bug26137 - Spurious unknown-variables warning for VALUES in inner SELECT

A VALUES clause inside an inner SELECT, like in this query: 

SELECT ?region {  
  SELECT ?region WHERE {  
     VALUES ?type { <ex:Region> }  
     ?region a ?type .  
   }  
 }

would give a spurious warning about the VALUES variable: 

unknown-variables: Unknown variable used in VALUES clause: ?type_1_1

This is now fixed, so that there will be no more warnings.

Bug26116 - FILTER CONTAINS LCASE gives UPI-NOT-IN-STRING-TABLE-ERROR

Certain SPARQL expressions that create intermediate strings, like: 

select ?s {  
  ?s <ex:p> ?o .  
  filter ( contains(lcase(?o), 'something'))  
}

could signal the error: The UPI #(...)is not present in the repository's string table.

This has been fixed.

Bug26093 - GROUP_CONCAT interprets separator arg as format string

If a SEPARATOR argument containing a tilde was supplied to the GROUP_CONCAT aggregator, the resulting string could be incorrect. This has been fixed.

Bug26090 - Boolean value serialized as sparql-json lacks datatype

A boolean value serialized in sparql-json format would look like (here we use the Lisp function sparql:run-sparql but the results would be the same if the query was executed in AGWebView and exported in sparql-json format): 

(sparql:run-sparql "select * { bind(true as ?x) }"  
   :results-format :sparql-json)  
 
-> {"head": {"vars": ["x"]},  
    "results": {"bindings": [{"x": {"type": "literal", "value": "true"}}]}}

But the correct way to serialize a boolean is to include the datatype. Thus this: 

"x": {"type": "literal", "value": "true"}`

is incorrect and should instead be: 

"x": {"type": "literal",  
      "datatype": "http://www.w3.org/2001/XMLSchema#boolean",  
      "value": "true"}

This has been corrected.

Bug26078 - SPARQL FILTER on numeric range excludes UPI types that partially overlap

If a SPARQL query FILTER expression restricts a triple part to a numeric range, and if there is a triple whose part value falls in that range but is of a data type such that the filter range exceeds the data type range, then the triple would not pass the filter, which was incorrect.

For example: 

(add-triple "<ex:s>" "<ex:p>" (value->upi 127 :byte))

and query: 

select * {  
  ?s ?p ?o .  
  filter ((?o > 120) && (?o < 130)  
}

The query FILTER restricts the triple object to (120, 130). The ?o value 127 should pass this filter. The value 127 is of type :byte, which has range [-128, 127].

The incorrect behaviour is that the FILTER range (up to 130) exceeds the data type range (up to 127) and therefore the value 127 was incorrectly filtered out, meaning the triple would not be returned by this query.

This has been fixed.

Bug26071 - COUNT aggregate on unknown variable should return 0.

If a query aggregates a variable that is not otherwise used, like: 

SELECT (COUNT(?bogus) AS ?count) { ?s ?p ?o }

this would be evaluated as if the unknown variable ?bogus was replaced by true. The value of ?count would be the total triple count.

This has been corrected, so that the returned ?count is now zero.

Bug26020 - Invalid OPTIONAL reordering

If a query has an OPTIONAL pattern that binds a variable, followed by a non-OPTIONAL pattern that references that variable, like: 

SELECT * {  
  ?s <ex:p1> ?o .    # (1)  
  OPTIONAL {  
    ?t <ex:p2> ?o2 . # (2) possibly binds ?o2  
  }  
  ?s <ex:p3> ?o2     # (3) references (if bound already) or binds ?o2  
}

the query engine could create an incorrect query plan with evaluation order (1) (3) (2). The evaluation order of (2) and (3) would be reversed: variable ?o2 would be bound based on pattern (3). This is now corrected to have evaluation order (1) (2) (3).

Bug26005 - Incorrect SUM and GROUP_CONCAT default values for empty group

If a SPARQL query has no result rows (or if GROUP BY is used, and a specific group has no result rows) a SUM aggregation and a GROUP_CONCAT aggregation would both return an unbound value.

This was incorrect according to the SPARQL 1.1 spec. Now SUM will return 0, and GROUP_CONCAT will return the empty string.

Bug26004 - Queries that have a constantly true HAVING could fail.

A constantly true HAVING expression in a query, like: 

SELECT ?s (max(?o) as ?maxO) {  
  ?s ?p ?o  
} GROUP BY ?s  
HAVING (3 < 4)

could err with Received signal number 7 (Bus error). This has been fixed.

Bug25999 - Crashed instance process can leave service daemon in confused state

Under some circumstances a crashed instance process would not be automatically restarted by the service daemon. This has been fixed.

Bug25988 - SPARQL function REGEX should err on non-string

Previously AllegroGraph was liberal in accepting a constant resource as REGEX pattern. For example: 

SELECT (regex('ex:foo', <ex:foo>) as ?match) {}

would return "true".

This has been fixed in order to adhere to the SPARQL specification: if the target or pattern is not a string, a type-error is signaled. The above SELECT now returns an unbound value.

Bug25984 - SPARQL function LANGMATCHES should err on non-string

Previously AllegroGraph was liberal in accepting non-strings to function LANGMATCHES and converting them using STR.

For example: 

BASE <http://foo/>  
SELECT (langMatches(<ex>, <ex>) as ?a)  
   (langMatches(123, 123) as ?b) {}

was interpreted as: 

BASE <http://foo/>  
SELECT (langMatches( STR(<ex>), STR(<ex>)) as ?a)  
   (langMatches( STR(123), STR(123)) as ?b) {}

and would return "true" twice.

This has been fixed in order to adhere to the SPARQL specification: if either argument to langMatches() is not a string, the result is a type-error. The above SELECT now returns two unbound values.

Bug25982: Fix HAVING constraint on implicit single group without aggregates

If a query uses HAVING without using GROUP BY, and no aggregates (like MIN, COUNT), as for example in: 

SELECT * { ?s ?p ?o } HAVING (?s = <ex:s>)

then the HAVING clause acts like FILTER: 

SELECT ?s ?p ?o { ?s ?p ?o . FILTER (?s = <ex:s>) }

However in the first query AllegroGraph would incorrectly ignore the HAVING clause, meaning results that should have been filtered out were returned. This is now corrected.

Bug25941 - Blank node patterns not supported in subject position of BGP triples

A query pattern with a blank node pattern as subject, and a property path, like: 

select * {  
  [ <ex:p2> ?o2 ]  ( <ex:p1> | <ex:p2> )  ?o  
}

would give a parse error at the "(" character. This has been fixed.

Bug25936 - Inefficient join with UNION

The query execution planning for certain queries containing UNION has been improved, leading to faster execution. This impacts also magic properties that are implemented using UNION, like <t:intervalBefore>.

Bug25934 - Problem with BIND (EXISTS { pattern1, pattern2 } as ?x)

If a query binds a variable to an EXISTS expression, where the EXISTS contains multiple patterns, like: 

SELECT ?person ?known where {  
  ?person a <ex:Person> .  
  BIND ( EXISTS {  
           ?employee a <ex:Employee> ;  
                     <ex:knows> ?person  
         } as ?known )  
}

then the outcome could be incorrect: the second and later patterns could be ignored, or the query could result in an error like: 

Error: Bad variables for set: (?person).

This is now fixed.

Bug25933 - Duplicate patterns in blank node + property path expansion

For query triple patterns with a property path, and a blank node as object, like: 

?s  ^<ex:p>  [ <ex:p1> <ex:foo> ;  
               <ex:p2> <ex:bar> ]

the expansion into simple triple patterns could contain duplicates: 

1. ?bnode_1 ex:p ?s  
2. ?bnode_1 ex:p ?s  (duplicate)  
3. ?bnode_1 ex:p2 ex:bar  
4. ?bnode_1 ex:p1 ex:foo

The duplicated pattern resulted in superfluous work during query execution. This is now fixed.

Bug25931 - Sending SPARQL query with typed booleans to remote-triple-stores fails

Making SPARQL queries with typed booleans (e.g. true"^^xsd:boolean) would fail with an error indicating that AllegroGraph is unable to convert a boolean UPI into a future part.

This is now fixed

Bug25925 - SPARQL MAX does not handle unbound values correctly

The SPARQL MAX aggregator would return an unbound value as result, if any of the values to aggregate was unbound. This has been fixed.

Bug25920 - SPARQL SERVICE using https without chunking errs

When a SPARQL query was sent to remote SPARQL endpoint that uses HTTPS, and the endpoint sent results not using chunked encoding, then an error would be signaled: 

Error: the value of stream is #<excl::ssl-client-stream ..>,  
       which is not of type  
 (or net.aserve::unchunking-stream util.zip:inflate-stream  
           excl::hiper-socket-stream).  
  [condition type: type-error]

This could happen in a SERVICE <https://...> clause, or by proving a :HOST "https://.." argument to function run-sparql.

This has been fixed.

Bug25919 - SPARQL function STRLEN should err on non-string

Previously AllegroGraph was liberal in accepting non-strings to function STRLEN and converting them using STR.

For example: 

SELECT (STRLEN (<http://franz.com>) as ?s)  
       (STRLEN (123.45) as ?t) {}

was interpreted as: 

SELECT (STRLEN (STR (<http://franz.com>)) as ?s)  
       (STRLEN (STR(123.45)) as ?t) {}

and would return values 16 and 6.

This has been fixed in order to adhere to the SPARQL specification: taking the length of a non-string now gives a type-error. The above SELECT now returns unbound values.

Bug25916 - COUNT DISTINCT of expressions gives error

A query for COUNT DISTINCT where the value is not a variable (like ?o) but an expression (like "strlen(?o)"), for example: 

select (count(distinct(strlen(?o))) as ?olen) {  
  ?s ?p ?o  
}

used to signal an error: 

Received signal number 11 (Segmentation fault)

These queries are now supported.

Bug25898 - SPARQL error for property multimatch with filtered object range

Queries with a property path with alternatives, that have a filter on the object variable, where the object values are of a type that is hashed to a UPI, like: 

select * {  
  ?s ( <ex:p1> | <ex:p2> ) ?o .  
  filter (lang(?o) = 'en')  
}

could result in an error like: 

Error: The UPI #(0 0 0 0 0 0 0 0 0 0 0 3) (which is a literal-language)  
       is not present in the triple-store's string dictionary.

This has been fixed.

Bug25821 - SPARQL function SUBSTR should clip LENGTH to string length

If in SUBSTR the length argument is larger than then the string's length, this would result in an error: 

SELECT * { bind (substr('abc', 1, 100) as ?s) }  
 
Executing query failed:  
In subseq, `end' (100) is beyond the end of the sequence (3).

This is now fixed, so that the substring up to the end of the string is returned. In this case: abc.

Bug25806 - Fix ORDER BY on non-projected variable

For certain SPARQL SELECT queries that use ORDER BY on a non-projected variable, the results could be ordered incorrectly. This has been fixed.

Bug25694 - Fix simplifying SPARQL= into UPI=

It was possible for a SPARQL equality filter: 

FILTER (?a = ?b)

to return false if the values are of different types. For example, if ?a is the integer 2 and ?b the float 2.0. This has been fixed.

Bug25636 - Triple cursor FILTER containing [NOT] EXISTS applied incorrectly

If a query contains a FILTER clause that uses EXISTS or NOT EXISTS, there were cases where that FILTER was evaluated incorrectly and as a result the query would return incorrect results.

Concretely, if in the query plan the filter was integrated in the first triple pattern, it was possible for EXISTS to return true in certain cases where false was the correct answer; and for NOT EXISTS to return false where true was the correct answer.

This has been fixed.

Bug25585 - Support ORDER BY on an aggregate expression

Queries in which the ORDER BY expression refer to an aggregation, for example: 

SELECT ?s (MIN(?o) as ?minO) {  
  ?s ?p ?o  
}  
GROUP BY ?s  
ORDER BY (min(?o))

would fail with the error: 

:aggregate fell through a etypecase form

This is now fixed.

Bug24815 - Fix MINUS with an empty row on the RHS

A query that uses MINUS, where the second BGP contains only unbound values, like: 

SELECT ?x {  
  { VALUES (?x) { (1) (2) (3) (4) } }  
  MINUS  
  { VALUES (?x) { (UNDEF) }  
  }  
}

should have 4 results, namely ?x bound to each integer.

Previously AllegroGraph would return no bindings. This is now corrected.

AGWebView

Bug26010 - Fixed Delete statement confirmation dialog

The Delete statement confirmation dialog in AGWebView is now fixed. Instead of asking for the confirmation, if showed the message: function () { [native code] } and did not allow to confirm the operation. Now, the confirmation dialog is displayed properly and, if the operation is confirmed, it will complete correctly.

Bug25947 - AGWebView doesn't allow all session spec characters

In 6.6.0 AGWebView was too restrictive on the characters allowed in the Session Specification edit box on the main catalog page. This has been fixed.

Bug25856 - Back-up this repository on WebView repo page does not work

Fixed the inner API for remote backup request with target on the server side file system. Fixed the dialog to correctly describe what is expected from user.

Changes to the Lisp API

Improve Materializer support for remote-triple-stores

The keyword arguments :delete-first? and :delete-duplicates-first? are now supported when calling materialize-entailed-triples on a remote triple store via the AllegroGraph Lisp client, and can also be specified via the REST API as well.

Rfe16211 - add IF-DOES-NOT-EXIST parameter to OPEN-TRIPLE-STORE

This change extends the open-triple-store function with an :if-does-not-exist argument. The following values are supported:

Rfe12356 - HTTP proxy support for AllegroGraph Lisp client

New :proxy parameter for create-triple-store, open-triple-store and triple-store-exists-p functions of the AllegroGraph Lisp client API allow to specify an HTTP proxy to be used for all HTTP requests issued by client. Proxy settings can be specified in the form 

[<user>[:<password>]@]<host>[<port>]

Alternatively, components of the proxy specification can be provided explicitly by :proxy-user, :proxy-password :proxy-host :proxy-port parameters. Additionally, the list of domain name suffix strings, for which the proxy should be bypassed, can be specified via :proxy-bypass-list parameter.

Bug25974 - load-ntriples doesn't work with namestring source on remote-triple-store

Previously calling load-ntriples (or any of the other load-* functions) would fail for remote-triple-stores if the source argument was a string naming a file instead of a pathname. This has been fixed.

Prolog

No significant changes.

Documentation

rfe16275 - Storage and memory document for AllegroGraph

There is a new Memory Usage document which discusses memory and disk space requirements when using AllegroGraph.

nD Geospatial

No significant changes.

AllegroGraph 6.6.0

AllegroGraph Server: General Changes

Rfe16127 - Make AllegroGraph's scripting model permissions more strict

Superuser permission is now required to upload, list, view, or delete both sitescripts and reposcripts.

Additionally, reposcripts can no longer be loaded into shared backends.

Rfe16096 - Simplify AllegroGraph script naming.

Scripts no longer support hierarchical naming, in favor of a simple flat namespace. For example, when uploading a script: 

Legal:   http://example.com:10035/scripts/sc.cl  
Illegal: http://example.com:10035/scripts/com/app/module/sc.cl

Rfe16093 - Incoming IP restrictions mechanism for AllegroGraph

New AllowIP configuration directive provides a way to restrict access to AG instance to certain ranges of IP addresses.

Rfe15992 - Add MaximumBackupAge parameter to the agraph.cfg file

One can specify the maximum age in seconds that a backup of the multi-master controlling instance is considered acceptable to use to grow the cluster. See the Instance Settings section of the Multi-master Replication document and also the Top-level directives for multi-master replication clusters section of the Server Configuration and Control document).

Rfe15886, Rfe15470 - UI Improvements to the triple attribute pages.

Merges the 'Define Attribute' and 'Define Static Filter' pages into a single 'Triple Attributes' page that is more streamlined and user friendly. See the Attributes example in the AGWebView documentation.

Bug25833 - Using CorsAllowRegex would break session/backend creation

Setting the CorsAllowRegex directive (see Server Configuration and Control) in your agraph.cfg would cause the creation of dedicated sessions and shared backends to break with a confusing error message in the agraph.log file.

Bug25832 - Only compare CorsAllowOrigin directive against Origin host

Previously, each value specified by a CorsAllowOrigin directive was matched against the full value of the Origin header: scheme, host, and port. Now, each CorsAllowOrigin directive is matched only against the host, per the documentation.

Bug25812 - agtool query --standard-namespaces

If agtool query is given the argument '--standard-namespaces no' then the AllegroGraph set of standard namespace PREFIX definitions will not be prepended to the text of query. Furthermore if the query is going to an AllegroGraph repository that agtool will open itself then the set of namespaces known to AllegroGraph is cleared before the query is run.

Bug25805 - Fix bug in SNA path-finding functions used with remote-triple-stores.

SNA path-finding functions like depth-first-search and all-bidirectional-search-paths would fail when called on a remote-triple-store if either the START or END arguments represented literals. This is now fixed.

Bug25801 - CSV import hangs on surrogate pairs

The CSV importer has been fixed to work with UTF8 surrogate pairs.

Bug25784 - Agtool archive failed when using an https spec.

Trying to use agtool archive with an https spec would fail due to the tool attempting to make regular http requests to the ssl port. This problem is now fixed.

Bug25736 - improved handling of GRAPH in JSON-LD

A JSON-LD error is now signaled when a string which is neither a resource nor URL is passed to as the --graph argument to agtool load. :root is supported as a special value of GRAPH, resulting in using the toplevel subject as a default graph for all triples added for the JSON-LD object with that subject.

Bug25382 - Fix security flaw in AllegroGraph scripting.

Fixes a bug, introduced in v6.3.0, that allowed any file on a filesystem accessible to AllegroGraph to be loaded as a script. Scripts are now only searched for and loaded from their expected locations relative to the SettingsDir directive.

HTTP Client

Bug25820 - CORS does not work via HTTPS

Previously CORS configuration options were ignored for accesses to AllegroGraph made via HTTPS. This has been corrected.

SPARQL

Rfe16157 - Implement logging of slow queries

A new configuration directive SlowQueryLogThreshold, if set, causes SPARQL queries that have total run time in milliseconds greater or equal to the value, to be logged to agraph.log or to a log file specified by SlowQueryLogFile configuration directive.

Bug25831 - Fix optimization of GRAPH with a non-existant value in SPARQL

The query: 

select ?s ?p ?o  
{  
  VALUES ?s { <http://s> }  
  VALUES ?p { <http://p> }  
  GRAPH <http://non-existing> {  
OPTIONAL {  
  ?s ?p ?o  
}  
  }  
}

should return 1 result row with ?s, ?p bound and ?o unbound.

However due to an incorrect optimization of unreachable GRAPH clauses there would be no results. This has been fixed.

Bug25803 - Fix augmenting pattern with two IRI equivalence constraints

SPARQL queries that bind a variable multiple times, like: 

SELECT * {  
  BIND (<http://ex/p2> as ?p)  
  {  
BIND (<http://ex/p1> as ?p)  
?s ?p ?o  
  }  
}

could be optimized incorrectly, leading to the error message: 

Executing query failed:  
 nil is not of the expected type `number'

This has been fixed.

Bug25802 - Join query rewriters lose filters

Certain SPARQL queries where a join happens, and one side contains BIND and FILTER, like: 

SELECT ... {  
  ?s ?p1 ?o1  
  {  
    BIND (<http://p2> as ?p2)  
    ?s ?p2 ?o2  
    FILTER (.. ?o2 ..)  
  }  
}

could be optimized wrongly in that the FILTER would be dropped. This has been fixed.

Bug25794 - BIND variables disappear in join

Certain SPARQL queries where a variable was used in a filter and also projected could return results in which that variable was unbound due to an incorrect query optimization. For example: 

SELECT * {  
  {  
    bind (4 as ?four)  
    ?s ?p ?o .  
    filter (?o != ?four)  
  }  
  {  
    bind (3 as ?three)  
    ?s ?p ?o .  
    filter (?o != ?three)  
  }  
}

could return rows with ?three and ?four unbound. This has been fixed.

Bug25761 - Whitespace symbols are not escaped properly when writing in TSV format

According to the TSV SPARQL standard, when serializing RDF terms some whitespace symbols like tabs, newlines and carriage returns are encoded in strings as \t, \n and \r respectively. This has not been the case, as these symbols were serialized as-is, leading to some parsing problems later, specifically a tab character being treated as separator for TSV format. This has been corrected.

Bug25756 - Unused variable in complex property path gives errors

Queries of the form: 

select ?o {  
  ?s ( ^<http://foo> | <http://bar> ) ?o  
}

in which the property path was not very simple, and also one variable is not otherwise used (here ?s), could lead to an error during execution. This has been fixed.

Bug25752 - Fix missing results for DISTINCT + LIMIT

There could be missing results for queries that uses both DISTINCT and LIMIT due to the DISTINCT condition being applied incorrectly. This has been fixed.

Bug25749 - Filter (str(?var) = '..') marked as impossible

If a SPARQL query had filter pattern comparing a STR() value to a literal string, like: 

filter ('http://g' = str(?g))

this would result in no results and the warning: 

 Warning: `?g` cannot be a literal so the FILTER ?g is one of 1 thing will always fail

This has been fixed.

Bug25714 - SPARQL IRI() and URI() functions must return valid, absolute results

Previously, the SPARQL IRI() and URI() functions could return IRIs and URIs that were syntactically invalid and/or relative. This has been corrected. AllegroGraph will now signal SPARQL type errors which will be treated as UNBOUND for assignment and as FALSE for FILTER evaluation.

Bug22350 - Fix missing results when using CAAT with DISTINCT

When a SPARQL query containing DISTINCT or REDUCED was executed using the chunk-at-a-time strategy, there could be results missing due to incorrect handling of intermediate query results. This has been fixed.

AGWebView

Rfe16012 - Don't show AllegroGraph Utilities menu unless logged in.

When not logged in, AGWebview displayed the Utilities menu even though none of its menu items work without being logged in. Now, the menu is not presented until a user is logged in.

Changes to the Lisp API

Rfe16071 - Implement breadth-first-search-if functionality

The four breadth-first search SNA functions:

have all been enhanced such that the end argument can be a function of one parameter. If end is such a function, then the search code will call it on each node found during the search and will record a successful search if the function returns true.

Bug25759 - Change load-trix :default-graph argument to :graph

To ensure consistency with other load- functions, :default-graph argument to load-trix has been deprecated and will be removed in the subsequent release. :graph should be used instead.

Bug25738 - AGWebView users are notified when query results may be stale

When reloading queries via the 'Saved' or 'Recent' menus--but also when executing new queries--AGWV will now report when there's a possibility the results displayed are out of date.

Prolog

No changes

Documentation

No changes

User-visible changes in earlier releases

See Change History for user-visible changes to earlier releases.