6:40 p.m.
Historically annotation binding within Hibernate made a huge assumption
that AccessType and PropertyAccessor were the same thing. They aren't
necessarily. AccessType is simply meant to dictate where to look for
annotations relating to "persistent attributes". PropertyAccessor is
Hibernate's way of accessing property values (getting/setting) at runtime.
Granted, AccessType *by default* should indicate the PropertyAccessor to
use. I am not arguing that. I am just suggesting that we should keep both
as distinct values. At the moment we collapse them into a single String
(we dump AccessType and keep "PropertyAccessor name").
The trouble is that later on we sometimes need to know the AccessType, at
which point we are forced to make a guess by interpreting the
PropertyAccessor in use and hoping that a custom PropertyAccessor was not
supplied.
Keeping these as distinct values alleviates that. Thoughts?
11:30 a.m.
On 5 Jan 2014, at 18:40, Steve Ebersole <steve(a)hibernate.org> wrote:
Historically annotation binding within Hibernate made a huge
assumption
that AccessType and PropertyAccessor were the same thing. They aren't
necessarily. AccessType is simply meant to dictate where to look for
annotations relating to "persistent attributes". PropertyAccessor is
Hibernate's way of accessing property values (getting/setting) at runtime.
Granted, AccessType *by default* should indicate the PropertyAccessor to
use. I am not arguing that. I am just suggesting that we should keep both
as distinct values. At the moment we collapse them into a single String
(we dump AccessType and keep "PropertyAccessor name").
The trouble is that later on we sometimes need to know the AccessType, at
which point we are forced to make a guess by interpreting the
PropertyAccessor in use and hoping that a custom PropertyAccessor was not
supplied.
I don’t know where it is exactly where you need the distinction, but if you do,
I also think they should be kept separated. Also having distinct concepts for this maybe
makes concepts also a bit clearer.
+1 from me
—Hardy
1:22 p.m.
On Thu 2014-03-06 11:30, Hardy Ferentschik wrote:
On 5 Jan 2014, at 18:40, Steve Ebersole <steve(a)hibernate.org> wrote:
> Historically annotation binding within Hibernate made a huge assumption
> that AccessType and PropertyAccessor were the same thing. They aren't
> necessarily. AccessType is simply meant to dictate where to look for
> annotations relating to "persistent attributes". PropertyAccessor is
> Hibernate's way of accessing property values (getting/setting) at runtime.
>
> Granted, AccessType *by default* should indicate the PropertyAccessor to
> use. I am not arguing that. I am just suggesting that we should keep both
> as distinct values. At the moment we collapse them into a single String
> (we dump AccessType and keep "PropertyAccessor name").
>
> The trouble is that later on we sometimes need to know the AccessType, at
> which point we are forced to make a guess by interpreting the
> PropertyAccessor in use and hoping that a custom PropertyAccessor was not
> supplied.
I don’t know where it is exactly where you need the distinction, but if you do,
I also think they should be kept separated. Also having distinct concepts for this maybe
makes concepts also a bit clearer.
AccessType in JPA means both but is also much more limited than our
PropertyAccessor approach. If your plan is to separate them in the
metamodel, then +1 and if propertyAccessor is not set, fall back to
JPA's default behavior.
5:41 p.m.
AccessType in JPA means both but is also much more limited than our
PropertyAccessor approach. If your plan is to separate them in the
metamodel, then +1 and if propertyAccessor is not set, fall back to
JPA's default behavior.
What I mean is that currently we utterly have no internal support for
recognizing:
@Access(FIELD)
@AttributeAccessor("property")
...
private String someAttribute;
which is perfectly valid (aka, look to the field for annotations, but at
runtime access getter/setters). There are really 2 questions here in
Hibernate terminology. As you say, JPA simply condenses that to one and
limits it.
The idea of AccessType (where to look for annotations) is what it is;
Hibernate's PropertyAccessor contract (AttributeAccessor annotation) has no
bearing on that. Given a missing AttributeAccessor annotation, we will
default the PropertyAccessor based on the attribute's AccessType.
I don't know where it is exactly where you need the distinction,
but if
you do,
I also think they should be kept separated. Also having distinct
concepts
for this maybe
makes concepts also a bit clearer.
Right, aside from cleanliness/correctness, one place at least where I have
seen it be problematic is in building the JPA metamodel. One thing we are
supposed to return is the "java member" for the attribute
(javax.persistence.metamodel.Attribute#getJavaMember). I guess it is
somewhat arguable given that the spec does not describe what exactly is
expected here. Which is not surprising since the spec condenses both
concepts together. But I'd think that the more correct return there is the
"annotated member". Which is exactly opposite of what we do today when
these conflict.
7:31 p.m.
New subject: Separating javax.persistence.AccessType and org.hibernate.property.PropertyAccessor
+1 for separating.
----- Original Message -----
From: "Hardy Ferentschik" <hardy(a)hibernate.org>
To: "Steve Ebersole" <steve(a)hibernate.org>
Cc: "Hibernate" <hibernate-dev(a)lists.jboss.org>
Sent: Thursday, March 6, 2014 2:30:21 AM
Subject: Re: [hibernate-dev] Separating javax.persistence.AccessType
and org.hibernate.property.PropertyAccessor
On 5 Jan 2014, at 18:40, Steve Ebersole <steve(a)hibernate.org> wrote:
> Historically annotation binding within Hibernate made a huge assumption
> that AccessType and PropertyAccessor were the same thing. They aren't
> necessarily. AccessType is simply meant to dictate where to look for
> annotations relating to "persistent attributes". PropertyAccessor is
> Hibernate's way of accessing property values (getting/setting) at runtime.
>
> Granted, AccessType *by default* should indicate the PropertyAccessor to
> use. I am not arguing that. I am just suggesting that we should keep both
> as distinct values. At the moment we collapse them into a single String
> (we dump AccessType and keep "PropertyAccessor name").
>
> The trouble is that later on we sometimes need to know the AccessType, at
> which point we are forced to make a guess by interpreting the
> PropertyAccessor in use and hoping that a custom PropertyAccessor was not
> supplied.
I don’t know where it is exactly where you need the distinction, but if you
do,
I also think they should be kept separated. Also having distinct concepts for
this maybe
makes concepts also a bit clearer.
+1 from me
—Hardy
_______________________________________________
hibernate-dev mailing list
hibernate-dev(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/hibernate-dev
3706
days inactive
3710
days old
4 comments
4 participants
participants (4)
-
Emmanuel Bernard -
Gail Badner -
Hardy Ferentschik -
Steve Ebersole