2.6.3

• Fix a ClassCastException when building plural object property attribute value from axioms.
• Temporarily disable entity loading optimization when the target type is not abstract and has subclasses.
• Allow variable in graph IRI position in FROM/FROM NAMED clauses.

2.6.2

• Fix issues introduced by the entity loading optimizer (Enhancement #357) and the new grammar-based SPARQL processing.
  • Allow variable in GRAPH IRI position (e.g., in DROP GRAPH queries)
  • Fix Query.getSingleResult behavior
  • Fix issues with asserted/inferred attributes
  • Handle queries where the triple last pattern does not end with a .
• Entity loading optimization will not be applied when the query contains a GRAPH or SERVICE clause, as it could
  lead to incorrect results being returned
• Rename the plugin property (cz.cvut.kbss.jopa.plugin.persistenceUnit). The previous version (which missed the kbss
  part) is still supported for backward compatibility.

2.6.1

• Experimental implementation of optimized entity retrieval from query results (Enhancement #357).
  • Enabled on entity manager/entity manager factory level using the
    cz.cvut.kbss.jopa.experimental.query.enableEntityLoadingOptimizer property (see the JOPAExperimentalProperties
    class).
  • Works only for typed queries selecting an entity — they project a single variable, and the query result type is an
    entity type.
  • The optimization adds a triple pattern ?x ?y ?z into the query, selecting all property values for the given
    subject, the query projection is then modified to ?x ?y ?z. Query result rows are transformed to axioms and an
    entity is reconstructed from them.
  • Works for plural attributes as well - result rows are grouped until a single entity can be reconstructed from
    them.
  • This optimization should reduce the number of repository calls. A single query execution will be able to load the
    resulting entities (previously, each entity was loaded separately after the query execution). That is, if the query returns n results, the previous implementation would make n + 1 repository calls to load the entities. The new implementation will make just 1 call. Note that references (i.e., relationship traversal) are still loaded by separate repository calls.
  • Current limitations:
    • Optimization is not applied if offset or limit are set on the query
    • Optimization is not applied if the query results are retrieved as a stream (Query.getResultStream)
    • Descriptor provided to the query is not applied to the entity loading - entity is reconstructed directly from
      query results.
  • If an IC violation is thrown (because the query does not differentiate asserted and inferred data), the entity is
    loaded using the usual mechanism which separates asserted and inferred data.
  • Since JOPA now uses a grammar-based SPARQL parser, it is stricter when handling queries. This brings the following
    potential breaking changes:
    • Positional parameters without a position number are not supported anymore (e.g., SELECT ?x WHERE { ?x a $ }
      must be changed to SELECT ?x WHERE { ?x a $1 }). On the other hand, the same positional parameter (same
      position number) can now be used multiple times in a query.
    • Parameters cannot be used in IRI string anymore, i.e., <http://example.com/?1> will not work
• Dependency updates: RDF4J 5.1.6.

2.6.0

• Support multilingual RDF containers (i.e., multiple translations at the same position in an RDF container) (Enhancement #369).
• Sanitize invalid characters in generated Java names in OWL2Java (thanks to @lukaskabc for a PR).
• Update dependencies: RDF4J 5.1.5.

2.5.1

• Fix an issue with translating SOQL to SPARQL when referencing an RDF container attribute (Bug #366).

2.5.0

• Support IRI as Query parameters (Enhancement #354).
• Add entity class IRI to the static metamodel (Enhancement #360).
• Implement a plugin API - currently there is plugin for the whole persistence unit lifecycle (Enhancement #361).
• Support generating Java URI constants into the Vocabulary file in OWL2Java.
• Make static metamodel generator a service discoverable using the Java Service Provider Interface.

2.4.4

• Fix an issue with merging entities with unset/changed query attributes (Bug #351).
• Dependency updates: Jena 5.5.0.

2.4.3

• Fix an issue with parsing SPARQL with IRIs containing hashtag (Bug #348).

2.4.2

• Fix an issue with handling ORDER BY in SOQL/Criteria API (Bug #343), default order is now ASC.
• Support RDF collections and OWL lists in SOQL/Criteria API (Enhancement #339).
• Natively handle Locale instances - store them as RDF simple literals (Enhancement #340).

2.4.1

• Prevent race condition when getting objects from second-level cache (Bug #329).
• Improve cache hit/miss ration by using the correct descriptor type for plural attribute elements (Bug #333).
• Support RDF containers in SOQL (typically MEMBER OFclauses) (Enhancement #335).