SimpleJpaRepository.delete(Specification<T> spec) throws NullPointerException

[xsg22]

Hi,
org.springframework.data.jpa.repository.support.SimpleJpaRepository#delete(Specification) throw s an NullPointerException when I execute in the kotlin language environment. More error messages like this

java.lang.NullPointerException: Parameter specified as non-null is null: method cn.sail.patient.controller.mutaion.ExerciseMutation.deleteExerciseRecord$lambda$0, parameter <anonymous parameter 1>

@Override
public long delete(Specification<T> spec) {

    CriteriaBuilder builder = this.em.getCriteriaBuilder();
    CriteriaDelete<T> delete = builder.createCriteriaDelete(getDomainClass());

    Predicate predicate = spec.toPredicate(delete.from(getDomainClass()), null, builder);
    
    if (predicate != null) {
	    delete.where(predicate);
    }
    
    return this.em.createQuery(delete).executeUpdate();
}

when executing "spec.toPredicate(delete.from(getDomainClass()), null, builder)", the second parameter passed in is null. However, the comment on the "Specification.toPredicate(Root root, CriteriaQuery query, CriteriaBuilder criteriaBuilder)" method clearly states that the ’query‘ parameter must not be null. If 'query' is null, the above exception will appear under kotlin because “CriteriaQuery query” is not a nullable type.

/**
* Creates a WHERE clause for a query of the referenced entity in form of a {@link Predicate} for the given
* {@link Root} and {@link CriteriaQuery}.
*
* @param root must not be {@literal null}.
* @param query must not be {@literal null}.
* @param criteriaBuilder must not be {@literal null}.
* @return a {@link Predicate}, may be {@literal null}.
*/
@Nullable
Predicate toPredicate(Root<T> root, CriteriaQuery<?> query, CriteriaBuilder criteriaBuilder);

Thanks for any ideas for smooth workarounds or other input,

Leon

[mp911de]

We have a problem in that area indeed because the query parameter is declared as non-null and yet we call the specification with null.

[mp911de]

In its actual sense, this is not a bug because the documentation says that the specification is expected to be non-null and the argument is not defined as @Nullable. However, several specifications can be null, so we should leniently accept null specifications.

[zteaterml]

@mp911de thank you for patching this issue. When do you anticipate a new version will be cut with this fix?

[mp911de]

Check out the release calendar for our schedule at https://calendar.spring.io/. The next release will be 3.0.5 with the 2022.0.5 release train.

[felixatmaltego]

@mp911de thanks for this fix! I believe that the problem mentioned by @xsg22 still exists.

The problem is that the Specification::toPredicate is being called with null for the query in org/springframework/data/jpa/repository/support/SimpleJpaRepository.java

	@Override
	public long delete(Specification<T> spec) {

		CriteriaBuilder builder = this.em.getCriteriaBuilder();
		CriteriaDelete<T> delete = builder.createCriteriaDelete(getDomainClass());

		Predicate predicate = spec.toPredicate(delete.from(getDomainClass()), null, builder);

		if (predicate != null) {
			delete.where(predicate);
		}

		return this.em.createQuery(delete).executeUpdate();
	}

This happens with 3.0.5 and Kotlin 1.7.22.

Example:

repository.delete(
    Specification.allOf(
        MySpecifications.hasId(id),
        ...
    )
)

I wonder if this is a Kotlin problem as I see no null check. I am happy for any info on this problem!

[mp911de]

Specification accepts a CriteriaQuery whereas for deletes, CriteriaBuilder returns a CriteriaDelete. These types aren't assignable so we cannot fix the nullability issue.

[felixatmaltego]

Thank you for clarifying!

[ghostg00]

I've had this problem too, so what's the latest solution? thanks

[vasanex]

I've just ran into the same issue. The root problem seems to be that the nullability contract of Specification::toPredicate is broken when called from SimpleJpaRepository::delete. Declaring a delete Specification like this:

myRepository.delete { root, _, builder ->
    /* build a predicate */
}

... will throw a NPE in Kotlin because of eager nullability checks that don't exist in pure Java.

However, it's possible to implement a band-aid fix by explicitly providing a nullable type hint for the unused query parameter:

myRepository.delete { root, _: Any?, builder ->
    /* build a predicate */
}

I guess manually providing type hints overrides the nullability contract of Specification::toPredicate, which means the lambda can then be called with a null query parameter.