[Hibernate-JIRA] Created: (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
8:01 p.m.
Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
-----------------------------------------------------------------------------------------
Key: HHH-6911
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911
Project: Hibernate Core
Issue Type: Improvement
Components: annotations, metamodel
Reporter: Steve Ebersole
Priority: Minor
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the discriminator
for concrete class resolution (reading) they are still expected to write it out to the
database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out. Longer term
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
8:05 p.m.
New subject: [Hibernate-JIRA] Updated: (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911?page=c...
]
Steve Ebersole updated HHH-6911:
--------------------------------
Description:
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the discriminator
for concrete class resolution (reading) they are still expected to write it out to the
database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out.
Longer term we could *possibly* even use the DiscriminatorColumn/DiscriminatorValue (if
present) instead of the SQL CASE statement thing we do now.
See HHH-4358 for the origins of this request...
was:
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the discriminator
for concrete class resolution (reading) they are still expected to write it out to the
database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out. Longer term
Labels: jpa2 (was: )
Write DiscriminatorValue to DiscriminatorColumn when combined with
InheritanceType#JOINED
-----------------------------------------------------------------------------------------
Key: HHH-6911
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911
Project: Hibernate Core
Issue Type: Improvement
Components: annotations, metamodel
Reporter: Steve Ebersole
Priority: Minor
Labels: jpa2
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the
discriminator for concrete class resolution (reading) they are still expected to write it
out to the database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out.
Longer term we could *possibly* even use the DiscriminatorColumn/DiscriminatorValue (if
present) instead of the SQL CASE statement thing we do now.
See HHH-4358 for the origins of this request...
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
9:11 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911?page=c...
]
Karsten Wutzke commented on HHH-6911:
-------------------------------------
Wow you created the same report one hour earlier. :D Please mark HHH-6912 as a duplicate
of this one.
Write DiscriminatorValue to DiscriminatorColumn when combined with
InheritanceType#JOINED
-----------------------------------------------------------------------------------------
Key: HHH-6911
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911
Project: Hibernate Core
Issue Type: Improvement
Components: annotations, metamodel
Reporter: Steve Ebersole
Priority: Minor
Labels: jpa2
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the
discriminator for concrete class resolution (reading) they are still expected to write it
out to the database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out.
Longer term we could *possibly* even use the DiscriminatorColumn/DiscriminatorValue (if
present) instead of the SQL CASE statement thing we do now.
See HHH-4358 for the origins of this request...
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:50 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911?page=c...
]
Julien Martin commented on HHH-6911:
------------------------------------
I think this is an important feature to have. Do you plan on implementing it in the
future?
Write DiscriminatorValue to DiscriminatorColumn when combined with
InheritanceType#JOINED
-----------------------------------------------------------------------------------------
Key: HHH-6911
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911
Project: Hibernate Core
Issue Type: Improvement
Components: annotations, metamodel
Reporter: Steve Ebersole
Priority: Minor
Labels: jpa2
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the
discriminator for concrete class resolution (reading) they are still expected to write it
out to the database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out.
Longer term we could *possibly* even use the DiscriminatorColumn/DiscriminatorValue (if
present) instead of the SQL CASE statement thing we do now.
See HHH-4358 for the origins of this request...
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:17 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911?page=c...
]
Karsten Wutzke commented on HHH-6911:
-------------------------------------
I think so, too. The question is rather *when* in the future... while it's rather easy
to do and somewhat isolated it usually takes Hibernate months. IMO it's not obvious
that the JOINED doesn't need discriminators, but when using them customers think
Hibernate is inferior or you made a bad recommendation.
Write DiscriminatorValue to DiscriminatorColumn when combined with
InheritanceType#JOINED
-----------------------------------------------------------------------------------------
Key: HHH-6911
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911
Project: Hibernate Core
Issue Type: Improvement
Components: annotations, metamodel
Reporter: Steve Ebersole
Priority: Minor
Labels: jpa2
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the
discriminator for concrete class resolution (reading) they are still expected to write it
out to the database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out.
Longer term we could *possibly* even use the DiscriminatorColumn/DiscriminatorValue (if
present) instead of the SQL CASE statement thing we do now.
See HHH-4358 for the origins of this request...
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:19 p.m.
New subject: [Hibernate-JIRA] Issue Comment Edited: (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911?page=c...
]
Karsten Wutzke edited comment on HHH-6911 at 1/5/12 4:18 PM:
-------------------------------------------------------------
I think so, too. The question is rather *when* in the future... while it's rather easy
to do and somewhat isolated it usually takes Hibernate months (if at all). IMO it's
not obvious that the JOINED doesn't need discriminators, but when using them customers
either think Hibernate is inferior or that you made a bad recommendation. I'd really
like to see this, the sooner the better.
was (Author: kwutzke):
I think so, too. The question is rather *when* in the future... while it's rather
easy to do and somewhat isolated it usually takes Hibernate months. IMO it's not
obvious that the JOINED doesn't need discriminators, but when using them customers
think Hibernate is inferior or you made a bad recommendation.
Write DiscriminatorValue to DiscriminatorColumn when combined with
InheritanceType#JOINED
-----------------------------------------------------------------------------------------
Key: HHH-6911
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911
Project: Hibernate Core
Issue Type: Improvement
Components: annotations, metamodel
Reporter: Steve Ebersole
Priority: Minor
Labels: jpa2
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the
discriminator for concrete class resolution (reading) they are still expected to write it
out to the database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out.
Longer term we could *possibly* even use the DiscriminatorColumn/DiscriminatorValue (if
present) instead of the SQL CASE statement thing we do now.
See HHH-4358 for the origins of this request...
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:21 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911?page=c...
]
Steve Ebersole commented on HHH-6911:
-------------------------------------
Well if its so easy to do and isolated and soooooo very important, where is the pull
request?
Write DiscriminatorValue to DiscriminatorColumn when combined with
InheritanceType#JOINED
-----------------------------------------------------------------------------------------
Key: HHH-6911
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911
Project: Hibernate Core
Issue Type: Improvement
Components: annotations, metamodel
Reporter: Steve Ebersole
Priority: Minor
Labels: jpa2
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the
discriminator for concrete class resolution (reading) they are still expected to write it
out to the database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out.
Longer term we could *possibly* even use the DiscriminatorColumn/DiscriminatorValue (if
present) instead of the SQL CASE statement thing we do now.
See HHH-4358 for the origins of this request...
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:47 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911?page=c...
]
Steve Ebersole commented on HHH-6911:
-------------------------------------
Julien, yes i will do this at some point. As I mentioned above, pull request gets it in
faster.
Write DiscriminatorValue to DiscriminatorColumn when combined with
InheritanceType#JOINED
-----------------------------------------------------------------------------------------
Key: HHH-6911
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-6911
Project: Hibernate Core
Issue Type: Improvement
Components: annotations, metamodel
Reporter: Steve Ebersole
Priority: Minor
Labels: jpa2
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the
discriminator for concrete class resolution (reading) they are still expected to write it
out to the database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out.
Longer term we could *possibly* even use the DiscriminatorColumn/DiscriminatorValue (if
present) instead of the SQL CASE statement thing we do now.
See HHH-4358 for the origins of this request...
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
2:35 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
[
https://hibernate.onjira.com/browse/HHH-6911?page=com.atlassian.jira.plug...
]
Roberto Ruiz commented on HHH-6911:
-----------------------------------
There is situation when @DiscriminatorColumn in JOINED inheritance is quite useful. It
happens when the discriminator column is also a foreign key to another table (which may
contain the description of the subtype)
For example:
@Entity
@Table(name="CONTRACT")
@Inheritance(strategy=InheritanceType.JOINED)
@DiscriminatorColumn(name="ID_CONTRACT_TYPE",
discriminatorType=DiscriminatorType.INTEGER)
public class ContratoJoin {
@Id
@Column(name="ID_CONTRACT")
private Long id;
@Column(name="DESCRIPTION")
private String description;
@ManyToOne
@JoinColumn(name="ID_CONTRACT_TYPE", insertable=false, updatable=false)
private ContractType contractType;
//getters, setters
}
... subclasses with @DiscriminatorValue ...
@Entity
@Table(name="CONTRACT_TYPE")
public class ContractType {
@Id
@Column(name="ID_CONTRACT_TYPE")
private Long id;
@Column(name="DESCRIPTION")
private String description;
//getters, setters
}
In this case, the value of the column ID_CONTRACT_TYPE should be inserted automatically
depending on the subclass, so that the description is retrieved on query.
Currently, in order to do that I must set the ContractType manually. It's not much
work, nut it is error prone.
There is also an advantage when using discriminator column. I may look directly into the
CONTRACT table, and know the type.
Write DiscriminatorValue to DiscriminatorColumn when combined with
InheritanceType#JOINED
-----------------------------------------------------------------------------------------
Key: HHH-6911
URL: https://hibernate.onjira.com/browse/HHH-6911
Project: Hibernate ORM
Issue Type: Improvement
Components: annotations, metamodel
Reporter: Steve Ebersole
Priority: Minor
Labels: jpa2
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the
discriminator for concrete class resolution (reading) they are still expected to write it
out to the database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out.
Longer term we could *possibly* even use the DiscriminatorColumn/DiscriminatorValue (if
present) instead of the SQL CASE statement thing we do now.
See HHH-4358 for the origins of this request...
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
5:17 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
[
https://hibernate.onjira.com/browse/HHH-6911?page=com.atlassian.jira.plug...
]
k reid commented on HHH-6911:
-----------------------------
Hmmm...guess I didn't search the forums well enough before opening HHH-7144 for this
same issue. Please review it and mark as duplicate if necessary.
Thanks.
Write DiscriminatorValue to DiscriminatorColumn when combined with
InheritanceType#JOINED
-----------------------------------------------------------------------------------------
Key: HHH-6911
URL: https://hibernate.onjira.com/browse/HHH-6911
Project: Hibernate ORM
Issue Type: Improvement
Components: annotations, metamodel
Reporter: Steve Ebersole
Priority: Minor
Labels: jpa2
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the
discriminator for concrete class resolution (reading) they are still expected to write it
out to the database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out.
Longer term we could *possibly* even use the DiscriminatorColumn/DiscriminatorValue (if
present) instead of the SQL CASE statement thing we do now.
See HHH-4358 for the origins of this request...
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
5:23 p.m.
New subject: [Hibernate-JIRA] Issue Comment Edited: (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
[
https://hibernate.onjira.com/browse/HHH-6911?page=com.atlassian.jira.plug...
]
k reid edited comment on HHH-6911 at 3/3/12 5:23 PM:
-----------------------------------------------------
Hmmm...guess I didn't search the forums well enough before opening a ticket for this
same issue. Hibernate supports this functionality using the xml descriptor but not using
annotations. Please review HHH-7144 and mark as duplicate if necessary.
Thanks.
was (Author: kor):
Hmmm...guess I didn't search the forums well enough before opening HHH-7144 for
this same issue. Please review it and mark as duplicate if necessary.
Thanks.
Write DiscriminatorValue to DiscriminatorColumn when combined with
InheritanceType#JOINED
-----------------------------------------------------------------------------------------
Key: HHH-6911
URL: https://hibernate.onjira.com/browse/HHH-6911
Project: Hibernate ORM
Issue Type: Improvement
Components: annotations, metamodel
Reporter: Steve Ebersole
Priority: Minor
Labels: jpa2
The JPA spec states that {{DiscriminatorColumn}} can be used in conjunction with JOINED
inheritence. The only section that seems to deal with this combination is _11.1.10
DiscriminatorColumn Annotation_ where it says
{quote}
For the SINGLE_TABLE mapping strategy, and typically also for the JOINED strategy, the
persistence
provider will use a type discriminator column. The DiscriminatorColumn annotation is used
to
define the discriminator column for the SINGLE_TABLE and JOINED inheritance mapping
strategies.
{quote}
Apparently this is meant to imply that even if providers do not need/use the
discriminator for concrete class resolution (reading) they are still expected to write it
out to the database. Dunno, thats just what we have been told :)
Anyway, like I said, Hibernate itself does not need the discriminator column/value to
interpret the concrete classes. However, in the interest of portability we certainly
*could* write it out.
Longer term we could *possibly* even use the DiscriminatorColumn/DiscriminatorValue (if
present) instead of the SQL CASE statement thing we do now.
See HHH-4358 for the origins of this request...
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
1:43 a.m.
New subject: [Hibernate-JIRA] (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
1:45 a.m.
New subject: [Hibernate-JIRA] (HHH-6911) Write DiscriminatorValue to DiscriminatorColumn when combined with InheritanceType#JOINED
4429
days inactive
4673
days old
hibernate-issues@lists.jboss.org
12 comments
6 participants
participants (6)
-
Julien Martin (JIRA) -
k reid (JIRA)
-
Karsten Wutzke (JIRA)
-
Roberto Ruiz (JIRA)
-
Steve Ebersole (JIRA)
-
Tom Hoornaert (JIRA)