Hibernate - Is there any way to get the name of the column for which a Constraint was violated?

I'm using Hibernate to save Entities in a Database.

On the Entity fields (columns), I have defined a lot of Constraints (such as NotNull or length=10).
When a Constraint is violated, a ConstraintViolationException is thrown. I want to somehow be able to track for which column a constraint was violated.
The ConstraintViolationException in the Java-Library "javax.validation.ConstraintViolation" has a method "getConstraintViolations()" so I can just do

> constraintViolationException.getConstraintViolations().getPropertyPath()

which should give me the column name.

However, the ConstraintViolationException thrown by Hibernate does not have a method "getConstraintViolations()" and there doesn't seem to be anything like it.
My only option now would be to analyze the String returned by calling "getConstraintName()":

> constraintViolationException.getConstraintName()

But this seems kind of messy and not secure.

Does anyone have an idea how I can get the column name?

EDIT:

Relevant dependencies inside the pom.xml:

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
        </dependency>

You are mixing things.

Bean Validation

The Bean Validation API lets you validate your beans, with the @NotNull, @Size, and all the other annotations of the javax.validation.constraints package.

You can use a Validator to validate your beans and get a javax.validation.ConstraintViolationException with all the ConstraintViolation with the info of the property.

JPA/Hibernate supports the Bean Validation API. If the <validation-mode> element in persistence.xml is set to AUTO (or it's not set, as AUTO is the default value), JPA will validate entities prior to saving them with a Validator, and throw a javax.validation.ConstraintViolationException if there are any ConstraintViolations, only if an implementation of Bean Validation is present on the environment. If you set <validation-mode> to CALLBACK, JPA will always validate the entities and will throw an error during deployment if there is not a Bean Validation implementation on the environment.

SQL Constraints

JPA annotations, like @Column provide information to generate your database DDL. Using @Column(nullable = false, length = 10) will generates a database column with a maximum length of 10 and a NOT NULL SQL constraint. But that's it. Hibernate don't check this before sending the statement to the database.

If a null value is provided, the database will report an SQL Error, that will be mapped to a SQLException by the JDBC driver. The error message in the SQLException will be different for each DBMS, but will contain the constraint name. Hibernate wraps this exceptions in a org.hibernate.exception.ConstraintViolationException that extracts the constraint name from the SQLException message.

Conclusion

• Set <validation-mode> to CALLBACK on your persistence.xml to make sure validation is always performed and invalid values don't hit the database

• Use javax.validation.constraints annotations to mach the SQL column constraints, for example, a not null column with a max size of 50:

  @NotNull @Size(max = 50)
  @Column(name = "NAME", nullable = false, length = 50)

• Provide meaningful names for unique constraints and foreign key constraints, as this will be the only info you can get to identify what constraint is violated.

The answer by Areus explains to not confuse Hibernate validator and the database constraints, but building on that, it's not always easy to fetch the affected column name from the database exception that you get. For instance when you have a unique constraint on the database column it's hard to properly return this exception to the user.

What I did was have a class that handles my REST call exception handling and finds that specific exception message. I found no other way to do this yet in Spring/Hibernate.

@ControllerAdvice
@RequestMapping(produces = APPLICATION_JSON_VALUE)
public class RestResponseEntityExceptionHandler {
@ExceptionHandler(DataIntegrityViolationException.class)
public ResponseEntity<ErrorDTO> dataIntegrityViolationException(final DataIntegrityViolationException e) {
String mostSpecificCauseMessage = e.getMostSpecificCause().getMessage();
if (e.getCause() instanceof ConstraintViolationException) {
String name = ((ConstraintViolationException) e.getCause()).getConstraintName();
log.debug("Encountered ConstraintViolationException, details: " + mostSpecificCauseMessage);
return determineError(mostSpecificCauseMessage, name);
} else {
log.debug("Encountered DataIntegrityViolation exception, details: " + mostSpecificCauseMessage);
ErrorDTO errorDTO =
new ErrorDTO("BAD_REQUEST_ERROR", "DataIntegrityViolation exception. " + mostSpecificCauseMessage);
return new ResponseEntity<>(errorDTO, HttpStatus.BAD_REQUEST);
}
}
//this catches the manually invoked entityManager.flush() exceptions
@ExceptionHandler(ConstraintViolationException.class)
public ResponseEntity<ErrorDTO> constraintViolationException(final ConstraintViolationException e) {
String message = e.getMessage();
String name = e.getConstraintName();
log.debug("Encountered ConstraintViolationException, details: {}", message);
return determineError(message, name);
}
private ResponseEntity<ErrorDTO> determineError(String message, String name) {
Map<String, String> errors = new HashMap<>();
switch (name) {
case Project.UNIQUE_CONSTRAINT_NAME:
errors.put("name", ALREADY_EXISTS);
break;
case Value.UNIQUE_CONSTRAINT_VALUE:
errors.put("value", ALREADY_EXISTS);
break;
//and so on
default:
break;
}
if (!errors.isEmpty()) {
ErrorDTO error = new ErrorDTO(VALIDATION_ERROR, VALIDATION_ERROR_MESSAGE, errors);
return new ResponseEntity<>(error, HttpStatus.BAD_REQUEST);
} else {
ErrorDTO errorDTO = new ErrorDTO("CONFLICT_ERROR", message);
return new ResponseEntity<>(errorDTO, HttpStatus.CONFLICT);
}
}
}

You also need to define the constraint name in your Model entity/database, such as:

@Table(uniqueConstraints = {
@UniqueConstraint(name = UNIQUE_CONSTRAINT_VALUE, columnNames = {"value"})})
public static final String UNIQUE_CONSTRAINT_VALUE = "unique_constraint_property_value";

And in the database definition as well of course.