[Hibernate-JIRA] Created: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
4:55 p.m.
Native SQL queries with addJoin or <return-join/> return object arrays instead of
single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate3
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.5, 3.2.4
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the quer
y.
I have reproduced this problem in the Hibernate JUnit tests in 3.2.4.ga and 3.2.5.ga,
specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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
7:25 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
Max Rydahl Andersen commented on HHH-2831:
------------------------------------------
this is just how it was done initially....addJoin both eager fetch and return the
result.
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate3
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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:11 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
Jeremy Grodberg commented on HHH-2831:
--------------------------------------
Max Rydahl Andersen wrote : this is just how it was done initially....addJoin both eager
fetch and return the result.
Max, I'm not sure what you are saying. Are you saying it was intended for addJoin to
behave like addEntity for associated objects or rather that it wasn't fully thought
out?
How is addJoin (supposed to be) different than addEntity? It seem like now all it does is
let you specify the entity class by referring to a property rather than naming the class
explicitly, which is not nearly as useful as being able to turn on or off eager fetching
in my externalized named SQL queries without having to dive into the Java code to change
the handling of the list that the query returns. (In my case I had to turn it on to avoid
a massive N+1 selects problem when an association was added to the root entity.)
In HQL queries I can eagerly fetch an association by using LEFT JOIN FETCH and the
associated objects are not returned directly in the query results; the result is a list of
root entities. It sure looks from the documentation like addJoin was meant to be
analogous for SQL queries and it sure would be helpful to have an analog of LEFT JOIN
FETCH for SQL queries.
So, if you are saying that the behavior I see is the design intention for addJoin and
<return-join/> then please change the "component" of this issue from
query-sql to documentation and clarify the documentation of these features to indicate
that eager fetching this way WILL return the associated objects directly as well as in the
properties of the root entity and I will file a separate enhancement request to provide
for SQL queries an analog of LEFT JOIN FETCH.
However, I'd really prefer it if you did not return the associated entities fetched
with addJoin directly, since I can already get the entities returned if I want that by
using addEntity.
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate3
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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
2:45 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
Christian Merenda commented on HHH-2831:
----------------------------------------
Hi, Jeremy, what about the issue? I'm currently facing a similar problem. Perhaps you
- or anybody out there - know a solution for this.
I've got a class with a multi-valued attribute, like this:
public class Person
{
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate3
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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
2:59 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
Christian Merenda commented on HHH-2831:
----------------------------------------
Sorry - I accidentally hit the wrong button...
public class Person
{
int id;
Set<String> names;
}
In the database you end up with two tables:
- "person" with the field "id"
- "person_names" with the fields "id" and "name"
Now I want to use native SQL to do the following query.
SELECT person.id AS {p.id}, person_names.name AS {p.names}
FROM person LEFT OUTER JOIN person_names USING (id)
The SQL query result would be
1 - christian
1 - paolo
2 - stefano
2 - marco
When I make the following call... createSQLQuery(sql).addEntity("p",
Person.class)
... I would expect to retrieve two objects
(1, [christian,paolo])
(2, [stefano,marco])
Actually this does not work - and obviously addJoin will also not help because there's
actually no other entity joined... Is there a solution for this available?
Thanks for your help!
Christian
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate3
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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
11:10 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
Chris Paulson-Ellis commented on HHH-2831:
------------------------------------------
I have discovered another strange fact about addJoin()...
If I do a query joining related entities and call addEntity() & addJoin(), then I get
back an Object[2] = { Entity, Entity } for each row, rather than the expected Object = {
Entity }. This is the problem others have encountered.
However, if I add a scalar to the query results and call addEntity(), addJoin() &
addScalar(), then I get back an Object[2] = { Entity, Scalar } for each row. This is what
I would expect given my reading of the purpose of addJoin(), but is inconsistent with the
behavior without the scalar.
I'm using 3.2.6 GA.
Regards,
Chris.
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate3
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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
11:11 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
Oliver Weichhold commented on HHH-2831:
---------------------------------------
I'm experiencing the same problem. Any ETA on a fix or is this feature working as
intended?
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate3
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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
6:04 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
Gerke Geurts commented on HHH-2831:
-----------------------------------
When working on issue NH-1612 (http://jira.nhibernate.org/browse/NH-1612) I encountered
the same issue. The bug seems to be in the
CustomLoader.ResultRowProcessor.buildResultRow() method
(http://viewvc.jboss.org/cgi-bin/viewvc.cgi/hibernate/core/trunk/core/src/...).
Replacing:
public Object buildResultRow(
Object[] data,
ResultSet resultSet,
boolean hasTransformer,
SessionImplementor session) throws SQLException, HibernateException {
Object[] resultRow;
if ( !hasScalars ) {
resultRow = data;
}
else {
// build an array with indices equal to the total number
// of actual returns in the result Hibernate will return
// for this query (scalars + non-scalars)
resultRow = new Object[ columnProcessors.length ];
for ( int i = 0; i < columnProcessors.length; i++ ) {
resultRow[i] = columnProcessors[i].extract( data, resultSet, session );
}
}
return ( hasTransformer )
? resultRow
: ( resultRow.length == 1 )
? resultRow[0]
: resultRow;
}
with:
public Object buildResultRow(
Object[] data,
ResultSet resultSet,
boolean hasTransformer,
SessionImplementor session) throws SQLException, HibernateException {
Object[] resultRow;
if (hasScalars || !hasTransformer)
{
// build an array with indices equal to the total number
// of actual returns in the result Hibernate will return
// for this query (scalars + non-scalars)
resultRow = new Object[columnProcessors.Length];
for (int i = 0; i < columnProcessors.Length; i++)
{
resultRow[i] = columnProcessors[i].Extract(data, resultSet,
session);
}
}
else
{
resultRow = data;
}
return hasTransformer || resultRow.Length != 1
? resultRow
: resultRow[0];
}
Does the trick in NHIbernate.
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate Core
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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
2:41 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
Paul Benedict commented on HHH-2831:
------------------------------------
Yup, I've been bitten by this bug too.
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate Core
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
Alan Boshier commented on HHH-2831:
-----------------------------------
I would like this bug to be fixed - we want to be able to switch between HQL and SQL named
queries on a case-by-case basis, and to be able to do this within configuration only.
As many of queries require an eager fetch left-outer join, this bug makes it impossible to
do this, because the results returned will be simple Object's for HQL, but Object[]
tuples for SQL.
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate Core
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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:46 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
David Balažic commented on HHH-2831:
------------------------------------
Affects version 3.6.0.Final, please someone update the issue metadata.
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate Core
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the query.
I have reproduced this problem in the Hibernate JUnit tests in 3.2.4.ga and 3.2.5.ga,
specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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:04 p.m.
New subject: [Hibernate-JIRA] Updated: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
Gail Badner updated HHH-2831:
-----------------------------
Affects Version/s: 3.6.0
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate Core
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5, 3.6.0
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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
2:42 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
James DeMichele commented on HHH-2831:
--------------------------------------
Yeah, same here. Pretty mind boggling that this performance issue doesn't seem to get
any notice for *4* major Hibernate releases. I mean, seriously.
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate Core
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5, 3.6.0
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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
7:19 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
Sanjay commented on HHH-2831:
-----------------------------
I have struggled a lot on this problem and luckly found this bug. I request you to
increase priority on this bug. I am working on application that is mainly analytic based
and we use SQL a lot.
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate Core
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5, 3.6.0
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
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
6:49 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831?page=c...
]
Vadim Lotarev commented on HHH-2831:
------------------------------------
Could anybody please tell me when this bug is going to be fixed? I am using 4.0 CR7 - it
is still there ...
Native SQL queries with addJoin or <return-join/> return object
arrays instead of single Entities
-------------------------------------------------------------------------------------------------
Key: HHH-2831
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-2831
Project: Hibernate Core
Issue Type: Bug
Components: query-sql
Affects Versions: 3.2.4, 3.2.5, 3.6.0
Environment: Hibernate 3.2.4.ga and 3.2.5.ga with hsqldb on Win XP
Reporter: Jeremy Grodberg
Attachments: NativeSQLQueriesTest.patch
Although the documentation is not crystal clear, I read it to say that using addJoin
should eagerly fetch an associated object but should NOT return it as a separate value.
In section 16.1.3. "Handling associations and collections" of the online
documentation it says: "It is possible to eagerly join in the Dog to avoid the
possible extra roundtrip for initializing the proxy. This is done via the addJoin()
method, which allows you to join in an association or collection." This comes BEFORE
the section on returning multiple entities, so I say the documentation at least implies it
will only return a single entity at the top level. Also, if the intention is to return
multiple entities, addEntity() works fine for that, so what then would be the difference
of addJoin()? If I'm wrong about what addJoin() should do, please clarify that in the
documentation and also clarify how, if it is possible, one could eagerly fetch the
association without changing the return type of the qu
ery.
I have reproduced this problem in the Hibernate JUnit tests in
3.2.4.ga and 3.2.5.ga, specifically NativeSQLQueriesTest.testSQLQueryInterface().
I'm attaching a patch to the Hibernate junit test
org.hibernate.test.sql.hand.query.NativeSQLQueriesTest.java released in 3.2.5.ga that adds
a test to ensure that a query with addJoin only returns a (list of) entities, not a list
of Object arrays containing entities. Currently, the assertion fails because instead of
returning a list of Organizations we get a list of Object[3] = { Organization, Employment,
Person }, which is exactly what we get when the addJoin()s are replaced with appropriate
addEntity() calls.
--
This message is automatically generated by JIRA.
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:18 p.m.
New subject: [Hibernate-JIRA] (HHH-2831) Native SQL queries with addJoin or <return-join/> return object arrays instead of single Entities
4405
days inactive
6315
days old
hibernate-issues@lists.jboss.org
15 comments
14 participants
participants (14)
-
Alan Boshier (JIRA) -
Chris Paulson-Ellis (JIRA)
-
Chris Williams (JIRA)
-
Christian Merenda (JIRA)
-
David Balažic (JIRA)
-
Gail Badner (JIRA)
-
Gerke Geurts (JIRA)
-
James DeMichele (JIRA)
-
Jeremy Grodberg (JIRA)
-
Max Rydahl Andersen (JIRA)
-
Oliver Weichhold (JIRA)
-
Paul Benedict (JIRA)
-
Sanjay (JIRA)
-
Vadim Lotarev (JIRA)