[Hibernate-JIRA] Created: (HV-466) Avoid repeated validation of constraints in certain type hierarchies
3:51 p.m.
Avoid repeated validation of constraints in certain type hierarchies
--------------------------------------------------------------------
Key: HV-466
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-466
Project: Hibernate Validator
Issue Type: Bug
Components: engine
Reporter: Gunnar Morling
Priority: Minor
Fix For: 4.x
Let there be the following type hierarchy where the same interface is implemented by two
types in an inheritance hierarchy:
{code:java}
public interface A {
@NotNull
String getA();
}
public class B implements A {
public String getA() {
return null;
}
}
public class C extends B implements A {
}
{code}
When validating an instance of {{C}} the {{@NotNull}} constraint on {{A#getA()}} is
evaluated twice when traversing the type hierarchy of {{C}} in {{ValidatorImpl}}.
This seems to be against the BV spec. which says in chapter 3.5:
{quote}
Note that this [algorithm] implies that a given validation constraint will not be
processed more than once per validation.
{quote}
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:03 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-466) Avoid repeated validation of constraints in certain type hierarchies
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-466?page=com...
]
Hardy Ferentschik commented on HV-466:
--------------------------------------
there is actually one easy way to address this. you just keep track in
_ValidatorImpl.validateConstraintsForDefaultGroup_ which interfaces you already processed
and ignore re-appearing interfaces. We could add this for 4.2 just to make the algorithm
correct and see whether we can come up w/ something better post 4.2.
Avoid repeated validation of constraints in certain type hierarchies
--------------------------------------------------------------------
Key: HV-466
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-466
Project: Hibernate Validator
Issue Type: Bug
Components: engine
Reporter: Gunnar Morling
Priority: Minor
Fix For: 4.x
Let there be the following type hierarchy where the same interface is implemented by two
types in an inheritance hierarchy:
{code:java}
public interface A {
@NotNull
String getA();
}
public class B implements A {
public String getA() {
return null;
}
}
public class C extends B implements A {
}
{code}
When validating an instance of {{C}} the {{@NotNull}} constraint on {{A#getA()}} is
evaluated twice when traversing the type hierarchy of {{C}} in {{ValidatorImpl}}.
This seems to be against the BV spec. which says in chapter 3.5:
{quote}
Note that this [algorithm] implies that a given validation constraint will not be
processed more than once per validation.
{quote}
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:07 p.m.
New subject: [Hibernate-JIRA] Commented: (HV-466) Avoid repeated validation of constraints in certain type hierarchies
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-466?page=com...
]
Gunnar Morling commented on HV-466:
-----------------------------------
Sounds good to me :-)
Avoid repeated validation of constraints in certain type hierarchies
--------------------------------------------------------------------
Key: HV-466
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-466
Project: Hibernate Validator
Issue Type: Bug
Components: engine
Reporter: Gunnar Morling
Priority: Minor
Fix For: 4.x
Let there be the following type hierarchy where the same interface is implemented by two
types in an inheritance hierarchy:
{code:java}
public interface A {
@NotNull
String getA();
}
public class B implements A {
public String getA() {
return null;
}
}
public class C extends B implements A {
}
{code}
When validating an instance of {{C}} the {{@NotNull}} constraint on {{A#getA()}} is
evaluated twice when traversing the type hierarchy of {{C}} in {{ValidatorImpl}}.
This seems to be against the BV spec. which says in chapter 3.5:
{quote}
Note that this [algorithm] implies that a given validation constraint will not be
processed more than once per validation.
{quote}
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:30 a.m.
New subject: [Hibernate-JIRA] Commented: (HV-466) Avoid repeated validation of constraints in certain type hierarchies
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-466?page=com...
]
Kevin Pollet commented on HV-466:
---------------------------------
I'm not really sure that just keep track of already processed interface will work.
With the current implementation I think that the problem only appear for constraints
hosted on an interface Foo which belongs to the groups Foo (eg. constraints which do not
declare a group or the Default group). I have the following example in mind (here only
{{A#getA2()}} will be evaluated twice):
{code}
interface A {
@NotNull(groups = Foo.class)
String getA1();
@NotNull
String getA2();
}
@GroupSequence({B.class, Foo.class})
class B implements A {
String getA1() {
return null;
}
String getA2() {
return null;
}
}
class C extends B implements A {
}
{code}
IMO, keeping track of only interface processed for the default group will works, maybe
it's already your thinking ;). WDYT ?
Avoid repeated validation of constraints in certain type hierarchies
--------------------------------------------------------------------
Key: HV-466
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-466
Project: Hibernate Validator
Issue Type: Bug
Components: engine
Reporter: Gunnar Morling
Priority: Minor
Fix For: 4.x
Let there be the following type hierarchy where the same interface is implemented by two
types in an inheritance hierarchy:
{code:java}
public interface A {
@NotNull
String getA();
}
public class B implements A {
public String getA() {
return null;
}
}
public class C extends B implements A {
}
{code}
When validating an instance of {{C}} the {{@NotNull}} constraint on {{A#getA()}} is
evaluated twice when traversing the type hierarchy of {{C}} in {{ValidatorImpl}}.
This seems to be against the BV spec. which says in chapter 3.5:
{quote}
Note that this [algorithm] implies that a given validation constraint will not be
processed more than once per validation.
{quote}
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:53 a.m.
New subject: [Hibernate-JIRA] Commented: (HV-466) Avoid repeated validation of constraints in certain type hierarchies
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-466?page=com...
]
Hardy Ferentschik commented on HV-466:
--------------------------------------
I think this:
{code}
private <T, U, V, E extends ConstraintViolation<T>> void
validateConstraintsForDefaultGroup(ValidationContext<T, E> validationContext,
ValueContext<U, V> valueContext) {
BeanMetaData<U> beanMetaData = getBeanMetaData( valueContext.getCurrentBeanType()
);
Set<Class> processedInterfaces = newHashSet();
// evaluating the constraints of a bean per class in hierarchy, this is necessary to
detect potential default group re-definitions
for ( Class<?> clazz : beanMetaData.getClassHierarchy() ) {
BeanMetaData<U> hostingBeanMetaData = (BeanMetaData<U>) getBeanMetaData(
clazz );
boolean defaultGroupSequenceIsRedefined =
hostingBeanMetaData.defaultGroupSequenceIsRedefined();
List<Class<?>> defaultGroupSequence =
hostingBeanMetaData.getDefaultGroupSequence( valueContext.getCurrentBean() );
Set<BeanMetaConstraint<? extends Annotation>> metaConstraints =
hostingBeanMetaData.getDirectMetaConstraints();
// if the current class redefined the default group sequence, this sequence has to be
applied to all the class hierarchy.
if ( defaultGroupSequenceIsRedefined ) {
metaConstraints = hostingBeanMetaData.getMetaConstraints();
}
PathImpl currentPath = valueContext.getPropertyPath();
for ( Class<?> defaultSequenceMember : defaultGroupSequence ) {
valueContext.setCurrentGroup( defaultSequenceMember );
boolean validationSuccessful = true;
for ( BeanMetaConstraint<? extends Annotation> metaConstraint : metaConstraints
) {
if ( metaConstraint.getLocation().getBeanClass().isInterface() &&
processedInterfaces.contains( metaConstraint.getLocation().getBeanClass() ) ) {
continue;
}
else {
processedInterfaces.add( metaConstraint.getLocation().getClass() );
}
boolean tmp = validateConstraint(
validationContext, valueContext, metaConstraint
);
if ( validationContext.shouldFailFast() ) {
return;
}
validationSuccessful = validationSuccessful && tmp;
// reset the path
valueContext.setPropertyPath( currentPath );
validationContext.markProcessed(
valueContext.getCurrentBean(),
valueContext.getCurrentGroup(),
valueContext.getPropertyPath()
);
}
if ( !validationSuccessful ) {
break;
}
}
// all constraints in the hierarchy has been validated, stop validation.
if ( defaultGroupSequenceIsRedefined ) {
break;
}
}
}
{code}
would already work. Only evaluate an interface once at the "lowest" possible
level. Say you have an instance of _C_. It is really for this instance you have to
evaluate the interfaces of _A_. We are not evaluating an instance of _C_ and an instance
of _B_. The validated entity entity implements the interface only once.
Avoid repeated validation of constraints in certain type hierarchies
--------------------------------------------------------------------
Key: HV-466
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-466
Project: Hibernate Validator
Issue Type: Bug
Components: engine
Reporter: Gunnar Morling
Priority: Minor
Fix For: 4.x
Let there be the following type hierarchy where the same interface is implemented by two
types in an inheritance hierarchy:
{code:java}
public interface A {
@NotNull
String getA();
}
public class B implements A {
public String getA() {
return null;
}
}
public class C extends B implements A {
}
{code}
When validating an instance of {{C}} the {{@NotNull}} constraint on {{A#getA()}} is
evaluated twice when traversing the type hierarchy of {{C}} in {{ValidatorImpl}}.
This seems to be against the BV spec. which says in chapter 3.5:
{quote}
Note that this [algorithm] implies that a given validation constraint will not be
processed more than once per validation.
{quote}
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:26 a.m.
New subject: [Hibernate-JIRA] Commented: (HV-466) Avoid repeated validation of constraints in certain type hierarchies
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-466?page=com...
]
Kevin Pollet commented on HV-466:
---------------------------------
Ok I see.
Sounds good to me :)
Avoid repeated validation of constraints in certain type hierarchies
--------------------------------------------------------------------
Key: HV-466
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-466
Project: Hibernate Validator
Issue Type: Bug
Components: engine
Reporter: Gunnar Morling
Priority: Minor
Fix For: 4.x
Let there be the following type hierarchy where the same interface is implemented by two
types in an inheritance hierarchy:
{code:java}
public interface A {
@NotNull
String getA();
}
public class B implements A {
public String getA() {
return null;
}
}
public class C extends B implements A {
}
{code}
When validating an instance of {{C}} the {{@NotNull}} constraint on {{A#getA()}} is
evaluated twice when traversing the type hierarchy of {{C}} in {{ValidatorImpl}}.
This seems to be against the BV spec. which says in chapter 3.5:
{quote}
Note that this [algorithm] implies that a given validation constraint will not be
processed more than once per validation.
{quote}
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
1:46 p.m.
New subject: [Hibernate-JIRA] Updated: (HV-466) Avoid repeated validation of constraints in certain type hierarchies
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-466?page=com...
]
Hardy Ferentschik updated HV-466:
---------------------------------
Affects Version/s: 4.1.0.CR1
Avoid repeated validation of constraints in certain type hierarchies
--------------------------------------------------------------------
Key: HV-466
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-466
Project: Hibernate Validator
Issue Type: Bug
Components: engine
Affects Versions: 4.1.0.CR1
Reporter: Gunnar Morling
Priority: Minor
Fix For: 4.x
Let there be the following type hierarchy where the same interface is implemented by two
types in an inheritance hierarchy:
{code:java}
public interface A {
@NotNull
String getA();
}
public class B implements A {
public String getA() {
return null;
}
}
public class C extends B implements A {
}
{code}
When validating an instance of {{C}} the {{@NotNull}} constraint on {{A#getA()}} is
evaluated twice when traversing the type hierarchy of {{C}} in {{ValidatorImpl}}.
This seems to be against the BV spec. which says in chapter 3.5:
{quote}
Note that this [algorithm] implies that a given validation constraint will not be
processed more than once per validation.
{quote}
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:45 a.m.
New subject: [Hibernate-JIRA] Resolved: (HV-466) Avoid repeated validation of constraints in certain type hierarchies
[
http://opensource.atlassian.com/projects/hibernate/browse/HV-466?page=com...
]
Hardy Ferentschik resolved HV-466.
----------------------------------
Resolution: Fixed
Fix Version/s: (was: 4.x)
4.2.0.CR1
Avoid repeated validation of constraints in certain type hierarchies
--------------------------------------------------------------------
Key: HV-466
URL: http://opensource.atlassian.com/projects/hibernate/browse/HV-466
Project: Hibernate Validator
Issue Type: Bug
Components: engine
Affects Versions: 4.1.0.CR1
Reporter: Gunnar Morling
Priority: Minor
Fix For: 4.2.0.CR1
Let there be the following type hierarchy where the same interface is implemented by two
types in an inheritance hierarchy:
{code:java}
public interface A {
@NotNull
String getA();
}
public class B implements A {
public String getA() {
return null;
}
}
public class C extends B implements A {
}
{code}
When validating an instance of {{C}} the {{@NotNull}} constraint on {{A#getA()}} is
evaluated twice when traversing the type hierarchy of {{C}} in {{ValidatorImpl}}.
This seems to be against the BV spec. which says in chapter 3.5:
{quote}
Note that this [algorithm] implies that a given validation constraint will not be
processed more than once per validation.
{quote}
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
http://opensource.atlassian.com/projects/hibernate/secure/Administrators....
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
5465
days inactive
5472
days old
hibernate-issues@lists.jboss.org
7 comments
3 participants
participants (3)
-
Gunnar Morling (JIRA) -
Hardy Ferentschik (JIRA)
-
Kevin Pollet (JIRA)