Reworked integration test to make it work on EclipseLink, too. Simply checking for new no joins doesn't work here as it even adds joins for plain attribute traversals using root.get(…). We're now using Mockito to verify the expected behavior on the interaction level instead of the Root's state.
Removed superfluous finals. Added some Javadoc where necessary.
Original pull request: #151.
QueryUtils.toExpressionRecursively(…) now also checks the provided root for already existing fetches to avoid creating superfluous join.
Original pull request: #151.
If parameter names for derived queries use names that collide with reserved keywords in JPQL (e.g. key) switching on Java 8 parameter name discovery previously caused the query execution to fail.
We now check whether the parameter has been explicitly named (using the @Param annotation) and only use the name if so.
We now only validate parameter names if the declared query actually uses named parameters.
This is mainly needed in context of an (accidentally) mixed use of named parameters with indexed placeholders which can occur if compiling with parameters is activated on Java 8 (i.e. using -parameters) but indexed parameters are used in the query definition.
AbstractStringBasedJpaQuery now considers the native flag of the underlying JpaQueryMethod when creating count queries.
Had to widen the return type of AbstractJpaQuery.createJpaQuery(…) to Query to accommodate the return value EntityManager.createNativeQuery(…). Tweaked the implementation of PagedExecution to handle non-Long return values potentially converting them to longs to retain API.
DefaultJpaContext is set up of all EntityManager instances in the current ApplicationContext and exposed for injection. Its interface JpaContext then currently allows looking up EntityManagers by managed domain types.
If multiple EntityManagers of the current ApplicationContext manage the a single domain type the request is rejected.
We now use an improved regular expression to detect identifier clauses in JPQL queries to be able to derive count queries for queries that use non-ASCII characters in entity names.
We now not only detect alias in left (outer) joins but basically all of them to find out whether or not to prefix sort expressions with the root alias.
We now ensure that all the SpEL parameters are correctly substituted when used together with an IN-clause. Previously we incorrectly used the initial query as the result again which then only substituted the very last parameter correctly.
Original pull request: #148.
Moved logic to create an ad-hoc entity graph into Jpa21Utils to avoid having to create a PersistenceProvider instance just for the sake of creating such a graph. Moved test code for that into newly introduced Jpa21UtilsUnitTests.
JpaEntityGraph now uses an unmodifiable List instead of an array to prevent having to deal with modifications. Jpa21Utils now uses Collection sorting and reversing to be able to use the for-each loop.
Polished imports, JavaDoc and @since tags where necessary.
Original pull request: #140.
We now support the specification of ad-hoc entity graphs on repository finder methods by allowing to specify the fetch graph paths via the "attributePaths" attribute on the EntityGraph annotation.
Configured EclipseLink tests to use dynamic weaving, required for dynamic entity fetch graphs. Fixed typo in CrudMethodMetadataPopulatingMethodInterceptor.
Original pull request: #140.
Disabled outdated Travis build profiles for Spring 4.0 and 4.1. Upgraded profiles for Hibernate 4.2 and 4.3 to the most recent releases.
Fixed stored procedure integration test to really run on EclipseLink for the EclipseLink specific tests. Added workaround for EclipseLink using invalid syntax (see [0]).
[0] https://bugs.eclipse.org/bugs/show_bug.cgi?id=467072
Tweaked method signatures in JpaRepositoryFactory after some signature changes in Spring Data Commons. Use newly introduced getTragetRepositoryViaReflection(…) to obtain the repository instance via the super class.
Added repositoryBaseClass() attribute to @EnableJpaRepositories.
Related tickets: DATACMNS-542.
Added new ….and(…) methods to JpaSort to take a Direction and Paths or Attributes to allow more concise definition of additional orders.
Slightly changed the method signature for methods on Path taking a Plural attribute to satisfy the compiler.
Slightly refactored general infrastructure integration tests to make sure they're executed during the build. Added neccesary ignores to prevent the test cases from running into spec violations.
We now honor @EntityGraph definitions on CrudRepository.findOne(…) which was previously only the case for methods that created a Query explicitly.
Extracted tryGetFetchGraphHints(…) method from tryConfigureFetchGraph(…) method in Jpa21Utils to allow EntityGraph hints to be used in SimpleJpaRepository.findOne(…). Construction of query hints from context information in SimpleJpaRepository is now performed via the getQueryHints(…) method. Adjusted QueryDslJpaRepository to use query hints as well.
Added unit and integration tests to verify that @EntityGraph information is propagated to findOne executions.
Original pull request: #137.
@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.
