@EnableJpaRepositories now has a enableDefaultTransactions attribute that defaults to true. The XML namespace has an equivalent enable-default-transactions attribute on the <jpa:repositories /> element.
Related tickets: DATACMNS-656.
Some simplifications in the persistence provider specific implementation of the CloseableIterator execution. Adapt to renames in Spring Data Commons. Missing JavaDoc. Additional test case to verify support for executing a stream query.
Original pull request: #136.
Added support for Streaming query results in Hibernate, EclipseLink and OpenJPA by falling back to store specific APIs to execute the query.
Original pull request: #136.
We now support detecting output parameters for stored-procedures with ParameterMode.REF_CURSOR. Previously we only considered parameters with OUT or INOUT mode as output parameters.
Added additional test cases for various procedure definition options.
Introduced new Dummy test type to avoid polluting the User test type anymore with additional procedure definitions. Added test for eclipse link and Openjpa but I had to deactivate them since they currently need to be run with HSQLDB V1 which doesn’t support stored procedures.
Original pull request: #130.
JPA mapping allows to define a specialized target entity type for associations e.g., to be able to use interfaces with associations but actually have them backed by a JPA entity type.
JpaPersistentPropertyImpl now favors a type detected within an association property over the one declared at the property for calls to getActualType().
Keeping both the ThreeTen and JSR-310 JPA 2.1 attribute converters in a single package will make the use of packages-to-scan with Spring's EntityManagerFactoryBean rather difficult as all converters will end up being picked up by the persistence provider where both of them rely on optional project settings (Java 8 or ThreeTenBp on the classpath).
By moving them into separate packages, the classes can be used to point to packages without interfering with each other.
We now ship JPA 2.1 AttributeConverters for the ThreeTen back port library [0] similarly to the one we provide for JSR-310.
[0] http://www.threeten.org/threetenbp
We now provide JPA 2.1 AttributeConverter implementations for non-time-zoned JSR-310 date/time types inside Jsr310JpaConverters. We transitively use the Jsr310Converters of Spring Data Commons for the actual conversion.
To activate the converters add the Jsr310JpaConverters class to the mapped types of your JPA provider or point your Spring JPA setup to include org.springframework.data.jpa.domain.support as package to scan for JPA persistent types.
Note that this commit requires DATACMNS-623 to be merged as it adds support for JSR-310 Instants to the general converters.
Related tickets: DATACMNS-623.
We now make sure wo register shared bean definitions only once for all usages of a root configuration element (XML or annotation).
Related ticket: DATACMNS-609.
We now support an Iterable of composite primary keys to be passed to findAll(…). Note that since there is no direct support in JPA to perform this query we have to execute a entityManager.find(…) query for every given id, which could lead to performance problems - use with care!
Original pull request: #127.
Specifications now implements Serializable to be able to transfer them across systems boundaries. Introduced special Serializable Specification types for composed and negated Specifications.
Note that currently only Hibernate and EclipseLink expression structures implement Serializable - OpenJPA's don't.
Original pull request: #86.
Introduced potentiallyConvertEmptyCollection method to PersistenceProvider for provider specific handling of empty collections. Special handling is performed for Hibernate and EclipseLink. Conversion is performed in ParameterMetadata.prepare(…). Renamed ParameterMetadataProvider.accessor to bindableParameterValues.
Original pull request: #123.
Previously SpEL template expressions like #{#entityName} could not be used in conjunction with parameter expressions in @Query because the SpEL template parser tried to evaluate the dynamic parameter expressions as well. We now mask the parameters prior to evaluating the SpEL template expression.
Original pull request: #122.
We now use a JpaQueryMethod instance rather than a mock as isPageQuery() cannot be mocked anymore as it has been made final.
Related issue: DATACMNS-601.
A custom ResourceLoader configured on ClasspathScanningPersistenceUnitPostProcessor is now propagated to the ClassPathScanningCandidateComponentProvider used for looking up entity classes. We also forward the configured environment so that profile annotations are evaluated as well.
Related issue: DATACMNS-591.
We now use a shared SpelExpressionParser and propagate this through the String-based JpaRepositoryQuery implementations to avoid reinstantiations.
Cleaned up ParameterBinder inheritance hierarchy by merging (and removing) ExpressionAwareParameterBinder into SpelExpressionStringQueryParameterBinder.
Original pull request: #121.
Renamed CustomAbstractPersistableIntergrationTests to AbstractPersistableIntergrationTests. Reordered declarations in persistence(2).xml to make sure we retain alphabetic sorting.
Original pull request: #115.
We now mark AbstractPersistable.isNew() property as @Transient for JPA in order to make sure that no JPA provider complains about a missing setter in case a user derives a domain entity from AbstractPersistable. Without this it isn't possible to bootstrap a PersistenceContext.
Original pull request: #115.
We now customize the IdentifierAccessor returned from JpaPersistentEntity.getIdentifierAccessor(…) to allow the identifier lookup use persistence provider specific means. This is needed to make sure we lookup identifiers for proxies correctly for which a field value lookup would not succeed (as the providers do not pre-populate the identifier field).
Moved JpaEntityMetadata and DefaultJpaEntityMetadata to query package to avoid a cyclic dependency to it. Jpa21Utils now also resides in the query package as the util package must not depend on other project packages.
Updated the Sonargraph architecture description by adding new architectural artifacts for mapping, the CDI support and utilities. Defined allowed dependencies more strictly to detect architecture violations more aggressively.
Added override for JpaPersistentPropertyImpl.isVersionProperty() to also consider properties annotated with JPA's @Version annotation as version property.
Related pull request: #108.
We now skip the query creation if we detect that the preceding count query returned 0 or no results. Previously we always created a query in every case even if it was not necessary.
Original pull request: #113.
JpaPersistentPropertyImpl now looks up both Spring Data and JPA access type definition annotations from both property and type level. Property-level definitions trump type-level ones, Spring Data ones trump JPA ones if defined on the same level.
In support of DATAREST-269 to be able to work around id access issues when working with proxies created by JPA providers.
Related ticket: DATAREST-269.
We now use a dedicated EntityManager for the named query lookup in NamedQuery.hasNamedQuery(…). Previously we used the given EntityManager to lookup the named query which will cause the transaction to be rolled back due to the Exception thrown in the case that the named query couldn't be found.
Added fast path to NamedQuery.lookupFrom(…) that now uses NamedQuery.hasNamedQuery(…) to test if a query exists or not. Pulled the check for the presence of a named count query from doCreateCountQuery(…) up to the NamedCountQuery constructor. This makes sure that the check is only performed once.
Original pull request: #110.
We now respect the @EntityGraph annotations on redeclared CRUD methods. CrudMethodMetadata now looks for @EntityGraph annotations, and - if present - the appropriate entity graph configuration is applied within SimpleJpaRepository.applyRepositoryMethodMetadata(…).
Previously we mistakenly treated the @EntityGraph annotation as a Query annotation which triggered a query resolution process that tried to find a named or create a derived query and failed. Removed @QueryAnnotation from @EntityGraph, since it should only be used to mark store specific @Query annotations.
Renamed Jpa21QueryCustomizer to Jpa21Utils. Moved Jpa21Utils to org.springframework.data.jpa.util to avoid potential dependency cycles.
Added EclipseLink and OpenJPA specific subclasses for the EntityGraphRepositoryMethodsIntegrationTests to make sure the tests are executed for EclipseLink and OpenJPA as well.
Original pull request: #109.
Adapted to API changes in Spring Data Commons. Added test cases to make sure the lookup of custom repository implementations works.
Original pull request: #105.
Refactored JpaMappingContext to be able to work with multiple instances of Metamodel. This removes the need to wire a dedicated one in JpaMetamodelContextFactoryBean and thus makes it independent of a particular EntityManager(Factory). This significantly eases the implementation of the configuration integration.
The Querydsl query creation now also leverages the CrudMethodMetadata instance held in SimpleJpaRepository to apply lock mode settings and query hints to the query to be executed.
Some persistence providers do not bump the version number in an initial call to EntityManager.persist(…). Thus, in case of a primitive version property we cannot distinguish between a new entity and one already persisted. We now fall back to id inspection whenever we find a primitive version property.
Original pull request: #103.
We now allow the parameters of query methods to also be exclusively consumed by expressions within a given query string. Previously this wasn't possible due to to strict checks for parameter usage in JpaQueryMethod.
Relax check for query param usage in JpaQueryMethod.
Enabled HSQLDB support for oracle syntax to be able to use the ROWNUM() function for pagination.
We now allow the parameters of query methods to also be exclusively consumed by expressions within a given query string. Previously this wasn't possible due to to strict checks for parameter usage in JpaQueryMethod.
Relax check for query param usage in JpaQueryMethod.
We came to the conclusion that allowing SpEL expressions as parameters in derived queries would create incentives for users to mess with the low-level Expressions API in high level user code. Therefore we decided to remove this feature - for now.
We now use the rootObject of the delegates context as the rootObject for the expression evaluation as well as the arguments of the current method call are available via positional indices as well via the special variable called "args".
Added minimalistic Security Context infrastructure that mimics that from Spring Security to ease testing.
Referenced appropriate JIRA issues.
We now treat the result of the SpEL expression evaluation as Object instead of just String in ExpressionAwareParameterBinder. We now prefer index based parameter binding over named parameter binding iff only SpEL expression parameters are present. We now make named parameters available as variables in SpEL expressions.
