3:08 a.m.
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.3, 3.5.2, 3.5.1, 3.5.0-Final, 3.5.0-CR-2, 3.5.0-CR-1,
3.5.0-Beta-4, 3.5.0-Beta-3, 3.5.0-Beta-2
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or croos
join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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:43 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Gail Badner commented on HHH-5352:
----------------------------------
Is this still an issue using 3.6.0?
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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
5:07 a.m.
New subject: [Hibernate-JIRA] Commented: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Patras Vlad commented on HHH-5352:
----------------------------------
Yes, it still an issue in 3.6.0
This issue is probably due to the not so obvious difference between comma and cross join
SQL operators (as of SQL-99 standard).
On many forums and even books it's stated that they are functionally equivalent and
it's just a matter of preference or what the DBE supports.
But they are NOT equivalent, for example consider the following SQL:
{code}
CREATE TABLE a (a INT);
CREATE TABLE b (b INT);
CREATE TABLE c (c INT);
INSERT INTO a VALUES (1);
INSERT INTO b VALUES (1);
INSERT INTO c VALUES (NULL);
-- Q1:
SELECT * FROM a , b RIGHT JOIN c on b.b = c.c;
-- Q2:
SELECT * FROM a CROSS JOIN b RIGHT JOIN c on b.b = c.c;
{code}
When running the above SQL in an SQL-99 compliant DBE (such as MySQL 5 or MS SQL Server
2005), Q1 and Q2 will return different results (Q1> 1 null null, Q2> null null
null). The only difference between Q1 and Q2 is comma being replaced with CROSS JOIN, thus
the two operators are not equivalent.
From the hibernate source code:
{noformat:title=org.hibernate.dialect.Dialect.java}
/**
* Get the separator to use for defining cross joins when translating HQL queries.
* <p/>
* Typically this will be either [<tt> cross join </tt>] or [<tt>,
</tt>]
* <p/>
* Note that the spaces are important!
*
* @return
*/
public String getCrossJoinSeparator() {
return " cross join ";
}
{noformat}
It is obvious that the developer is not aware that CROSS JOIN is different from comma.
First, the method is named getCrossJoinSeparator even though it refers to what a comma in
HQL is going to be replaced with, and then there is the comment that says "Typically
this will be either <tt> cross join </tt> or <tt>, </tt>".
This functionality was implemented to fix HHH-1480. But that is not an actual fix,
it's a hack.
Basicly HHH-1480 says "JOIN and comma have different precedence in SQL but they have
the same precedence in HQL".
Instead of fixing the problem, the solution was "Oh, we will just change the meaning
of comma in HQL to be a CROSS JOIN so it will have the same precedence as other
JOINs".
Changing the meaning of comma changes the results returned by HQL queries. All this
happens silently, it's not even specified in the documentation. If an application does
not have comprehensive unit testing this is likely to go by unnoticed.
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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
12:45 p.m.
New subject: [Hibernate-JIRA] Updated: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Gail Badner updated HHH-5352:
-----------------------------
Affects Version/s: 3.6.0
Fix Version/s: 4.0.0.Alpha1
3.6.1
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3, 3.6.0
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
Fix For: 3.6.1, 4.0.0.Alpha1
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Gail Badner commented on HHH-5352:
----------------------------------
Please update org.hibernate.test.hql.HQLTest to reproduce your issue.
Thanks,
Gail
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3, 3.6.0
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
Fix For: 3.6.1, 4.0.0.Alpha1
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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:44 p.m.
New subject: [Hibernate-JIRA] Updated: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Gail Badner updated HHH-5352:
-----------------------------
Fix Version/s: (was: 3.6.1)
3.6.next
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3, 3.6.0
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
Fix For: 3.6.next, 4.0.0.Alpha1
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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:08 a.m.
New subject: [Hibernate-JIRA] Updated: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Patras Vlad updated HHH-5352:
-----------------------------
Attachment: commaAgainstCrossJoin.patch
When HHH-1480 was implemented it is obvious that {{org.hibernate.test.hql.HQLTest}} would
have failed.
So the developer added {{public static boolean REGRESSION_STYLE_CROSS_JOINS = false;}} to
{{org.hibernate.hql.ast.SqlGenerator}}.
This is set to {{true}} in {{prepareTest}} and to {{false}} in {{cleanupTest}}.
If you want {{HQLTest}} to fail just set {{REGRESSION_STYLE_CROSS_JOINS}} to {{false}}
again, it's only purpose is to make {{HQLTest}} pass.
Even the test case considers "cross join" and comma to be equivalent by ignoring
the change (it tells the query generator to use commas again just for testing purposes).
There is no test that actually checks if the generated sql returns the same thing after
the change.
For this purpose I modified {{org.hibernate.test.orphan.OrphanTest}} (it has suitable
entities).
The important bit is:
{noformat}
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = true;
session = openSession();
t = session.beginTransaction();
log.info("Running with comma");
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated to commas is SQl
and this will work as expected.
//the condition "where 1=1" is added so the queries are different, otherwise the
next one will be taken from cache.
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
1=1").list().size());
t.commit();
session.close();
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = false;
session = openSession();
t = session.beginTransaction();
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated a dialect
specific string, usually "cross join"
//this fails on H2 with "unsupported outer join condition" - it seems H2
doesn't even support this
//on MySQL and MS Sql the assert will fail because the query only returns one result
log.info("Running with cross join");
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
2=2").list().size());
t.commit();
session.close();
{noformat}
It is obvious from the test that when creating sql the old way
({{REGRESSION_STYLE_CROSS_JOINS}} is {{true}}) everything works as expected. But when
replacing commas with "cross join" ({{REGRESSION_STYLE_CROSS_JOINS}} is
{{false}}), the query dosn't return the expected results and even crashes on HyperDB
2.
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3, 3.6.0
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
Fix For: 3.6.next, 4.0.0.Alpha1
Attachments: commaAgainstCrossJoin.patch
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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:22 a.m.
New subject: [Hibernate-JIRA] Issue Comment Edited: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Patras Vlad edited comment on HHH-5352 at 1/18/11 7:21 AM:
-----------------------------------------------------------
When HHH-1480 was implemented it is obvious that {{org.hibernate.test.hql.HQLTest}} would
have failed.
So the developer added {{public static boolean REGRESSION_STYLE_CROSS_JOINS = false;}} to
{{org.hibernate.hql.ast.SqlGenerator}}.
This is set to {{true}} in {{prepareTest}} and to {{false}} in {{cleanupTest}}.
If you want {{HQLTest}} to fail just set {{REGRESSION_STYLE_CROSS_JOINS}} to {{false}}
again, it's only purpose is to make {{HQLTest}} pass.
Even the test case considers "cross join" and comma to be equivalent by ignoring
the change (it tells the query generator to use commas again just for testing purposes).
There is no test that actually checks if the generated sql returns the same thing after
the change.
For this purpose I modified {{org.hibernate.test.orphan.OrphanTest}} (it has suitable
entities).
The important bit is:
{code}
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = true;
session = openSession();
t = session.beginTransaction();
log.info("Running with comma");
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated to commas is SQl
and this will work as expected.
//the condition "where 1=1" is added so the queries are different, otherwise the
next one will be taken from cache.
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
1=1").list().size());
t.commit();
session.close();
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = false;
session = openSession();
t = session.beginTransaction();
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated a dialect
specific string, usually "cross join"
//this fails on H2 with "unsupported outer join condition" - it seems H2
doesn't even support this
//on MySQL and MS Sql the assert will fail because the query only returns one result
log.info("Running with cross join");
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
2=2").list().size());
t.commit();
session.close();
{code}
It is obvious from the test that when creating sql the old way
({{REGRESSION_STYLE_CROSS_JOINS}} is {{true}}) everything works as expected. But when
replacing commas with "cross join" ({{REGRESSION_STYLE_CROSS_JOINS}} is
{{false}}), the query dosn't return the expected results and even crashes on HyperDB
2.
Note that a patch with the changes is attached.
was (Author: senoctar):
When HHH-1480 was implemented it is obvious that {{org.hibernate.test.hql.HQLTest}}
would have failed.
So the developer added {{public static boolean REGRESSION_STYLE_CROSS_JOINS = false;}} to
{{org.hibernate.hql.ast.SqlGenerator}}.
This is set to {{true}} in {{prepareTest}} and to {{false}} in {{cleanupTest}}.
If you want {{HQLTest}} to fail just set {{REGRESSION_STYLE_CROSS_JOINS}} to {{false}}
again, it's only purpose is to make {{HQLTest}} pass.
Even the test case considers "cross join" and comma to be equivalent by ignoring
the change (it tells the query generator to use commas again just for testing purposes).
There is no test that actually checks if the generated sql returns the same thing after
the change.
For this purpose I modified {{org.hibernate.test.orphan.OrphanTest}} (it has suitable
entities).
The important bit is:
{code}
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = true;
session = openSession();
t = session.beginTransaction();
log.info("Running with comma");
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated to commas is SQl
and this will work as expected.
//the condition "where 1=1" is added so the queries are different, otherwise the
next one will be taken from cache.
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
1=1").list().size());
t.commit();
session.close();
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = false;
session = openSession();
t = session.beginTransaction();
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated a dialect
specific string, usually "cross join"
//this fails on H2 with "unsupported outer join condition" - it seems H2
doesn't even support this
//on MySQL and MS Sql the assert will fail because the query only returns one result
log.info("Running with cross join");
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
2=2").list().size());
t.commit();
session.close();
{code}
It is obvious from the test that when creating sql the old way
({{REGRESSION_STYLE_CROSS_JOINS}} is {{true}}) everything works as expected. But when
replacing commas with "cross join" ({{REGRESSION_STYLE_CROSS_JOINS}} is
{{false}}), the query dosn't return the expected results and even crashes on HyperDB
2.
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3, 3.6.0
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
Fix For: 3.6.next, 4.0.0.Alpha1
Attachments: commaAgainstCrossJoin.patch
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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:22 a.m.
New subject: [Hibernate-JIRA] Issue Comment Edited: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Patras Vlad edited comment on HHH-5352 at 1/18/11 7:21 AM:
-----------------------------------------------------------
When HHH-1480 was implemented it is obvious that {{org.hibernate.test.hql.HQLTest}} would
have failed.
So the developer added {{public static boolean REGRESSION_STYLE_CROSS_JOINS = false;}} to
{{org.hibernate.hql.ast.SqlGenerator}}.
This is set to {{true}} in {{prepareTest}} and to {{false}} in {{cleanupTest}}.
If you want {{HQLTest}} to fail just set {{REGRESSION_STYLE_CROSS_JOINS}} to {{false}}
again, it's only purpose is to make {{HQLTest}} pass.
Even the test case considers "cross join" and comma to be equivalent by ignoring
the change (it tells the query generator to use commas again just for testing purposes).
There is no test that actually checks if the generated sql returns the same thing after
the change.
For this purpose I modified {{org.hibernate.test.orphan.OrphanTest}} (it has suitable
entities).
The important bit is:
{code}
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = true;
session = openSession();
t = session.beginTransaction();
log.info("Running with comma");
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated to commas is SQl
and this will work as expected.
//the condition "where 1=1" is added so the queries are different, otherwise the
next one will be taken from cache.
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
1=1").list().size());
t.commit();
session.close();
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = false;
session = openSession();
t = session.beginTransaction();
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated a dialect
specific string, usually "cross join"
//this fails on H2 with "unsupported outer join condition" - it seems H2
doesn't even support this
//on MySQL and MS Sql the assert will fail because the query only returns one result
log.info("Running with cross join");
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
2=2").list().size());
t.commit();
session.close();
{code}
It is obvious from the test that when creating sql the old way
({{REGRESSION_STYLE_CROSS_JOINS}} is {{true}}) everything works as expected. But when
replacing commas with "cross join" ({{REGRESSION_STYLE_CROSS_JOINS}} is
{{false}}), the query dosn't return the expected results and even crashes on HyperDB
2.
was (Author: senoctar):
When HHH-1480 was implemented it is obvious that {{org.hibernate.test.hql.HQLTest}}
would have failed.
So the developer added {{public static boolean REGRESSION_STYLE_CROSS_JOINS = false;}} to
{{org.hibernate.hql.ast.SqlGenerator}}.
This is set to {{true}} in {{prepareTest}} and to {{false}} in {{cleanupTest}}.
If you want {{HQLTest}} to fail just set {{REGRESSION_STYLE_CROSS_JOINS}} to {{false}}
again, it's only purpose is to make {{HQLTest}} pass.
Even the test case considers "cross join" and comma to be equivalent by ignoring
the change (it tells the query generator to use commas again just for testing purposes).
There is no test that actually checks if the generated sql returns the same thing after
the change.
For this purpose I modified {{org.hibernate.test.orphan.OrphanTest}} (it has suitable
entities).
The important bit is:
{noformat}
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = true;
session = openSession();
t = session.beginTransaction();
log.info("Running with comma");
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated to commas is SQl
and this will work as expected.
//the condition "where 1=1" is added so the queries are different, otherwise the
next one will be taken from cache.
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
1=1").list().size());
t.commit();
session.close();
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = false;
session = openSession();
t = session.beginTransaction();
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated a dialect
specific string, usually "cross join"
//this fails on H2 with "unsupported outer join condition" - it seems H2
doesn't even support this
//on MySQL and MS Sql the assert will fail because the query only returns one result
log.info("Running with cross join");
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
2=2").list().size());
t.commit();
session.close();
{noformat}
It is obvious from the test that when creating sql the old way
({{REGRESSION_STYLE_CROSS_JOINS}} is {{true}}) everything works as expected. But when
replacing commas with "cross join" ({{REGRESSION_STYLE_CROSS_JOINS}} is
{{false}}), the query dosn't return the expected results and even crashes on HyperDB
2.
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3, 3.6.0
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
Fix For: 3.6.next, 4.0.0.Alpha1
Attachments: commaAgainstCrossJoin.patch
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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:24 a.m.
New subject: [Hibernate-JIRA] Issue Comment Edited: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Patras Vlad edited comment on HHH-5352 at 1/18/11 7:22 AM:
-----------------------------------------------------------
When HHH-1480 was implemented it is obvious that {{org.hibernate.test.hql.HQLTest}} would
have failed.
So the developer added {{public static boolean REGRESSION_STYLE_CROSS_JOINS = false;}} to
{{org.hibernate.hql.ast.SqlGenerator}}.
This is set to {{true}} in {{prepareTest}} and to {{false}} in {{cleanupTest}}.
If you want {{HQLTest}} to fail just set {{REGRESSION_STYLE_CROSS_JOINS}} to {{false}}
again, it's only purpose is to make {{HQLTest}} pass.
Even the test case considers "cross join" and comma to be equivalent by ignoring
the change (it tells the query generator to use commas again just for testing purposes).
There is no test that actually checks if the generated sql returns the same thing after
the change.
For this purpose I modified {{org.hibernate.test.orphan.OrphanTest}} (it has suitable
entities).
The important bit is:
{code}
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = true;
session = openSession();
t = session.beginTransaction();
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated to commas is SQl
and this will work as expected.
//the condition "where 1=1" is added so the queries are different, otherwise the
next one will be taken from cache.
log.info("Running with comma");
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
1=1").list().size());
t.commit();
session.close();
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = false;
session = openSession();
t = session.beginTransaction();
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated a dialect
specific string, usually "cross join"
//this fails on H2 with "unsupported outer join condition" - it seems H2
doesn't even support this
//on MySQL and MS Sql the assert will fail because the query only returns one result
log.info("Running with cross join");
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
2=2").list().size());
t.commit();
session.close();
{code}
It is obvious from the test that when creating sql the old way
({{REGRESSION_STYLE_CROSS_JOINS}} is {{true}}) everything works as expected. But when
replacing commas with "cross join" ({{REGRESSION_STYLE_CROSS_JOINS}} is
{{false}}), the query dosn't return the expected results and even crashes on HyperDB
2.
Note that a patch with the changes is attached.
was (Author: senoctar):
When HHH-1480 was implemented it is obvious that {{org.hibernate.test.hql.HQLTest}}
would have failed.
So the developer added {{public static boolean REGRESSION_STYLE_CROSS_JOINS = false;}} to
{{org.hibernate.hql.ast.SqlGenerator}}.
This is set to {{true}} in {{prepareTest}} and to {{false}} in {{cleanupTest}}.
If you want {{HQLTest}} to fail just set {{REGRESSION_STYLE_CROSS_JOINS}} to {{false}}
again, it's only purpose is to make {{HQLTest}} pass.
Even the test case considers "cross join" and comma to be equivalent by ignoring
the change (it tells the query generator to use commas again just for testing purposes).
There is no test that actually checks if the generated sql returns the same thing after
the change.
For this purpose I modified {{org.hibernate.test.orphan.OrphanTest}} (it has suitable
entities).
The important bit is:
{code}
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = true;
session = openSession();
t = session.beginTransaction();
log.info("Running with comma");
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated to commas is SQl
and this will work as expected.
//the condition "where 1=1" is added so the queries are different, otherwise the
next one will be taken from cache.
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
1=1").list().size());
t.commit();
session.close();
SqlGenerator.REGRESSION_STYLE_CROSS_JOINS = false;
session = openSession();
t = session.beginTransaction();
//when REGRESSION_STYLE_CROSS_JOINS is true, commas in hql are translated a dialect
specific string, usually "cross join"
//this fails on H2 with "unsupported outer join condition" - it seems H2
doesn't even support this
//on MySQL and MS Sql the assert will fail because the query only returns one result
log.info("Running with cross join");
assertEquals(2, session.createQuery("from Product, Mail m right join m.user where
2=2").list().size());
t.commit();
session.close();
{code}
It is obvious from the test that when creating sql the old way
({{REGRESSION_STYLE_CROSS_JOINS}} is {{true}}) everything works as expected. But when
replacing commas with "cross join" ({{REGRESSION_STYLE_CROSS_JOINS}} is
{{false}}), the query dosn't return the expected results and even crashes on HyperDB
2.
Note that a patch with the changes is attached.
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3, 3.6.0
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
Fix For: 3.6.next, 4.0.0.Alpha1
Attachments: commaAgainstCrossJoin.patch
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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
5:18 p.m.
New subject: [Hibernate-JIRA] Updated: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Gail Badner updated HHH-5352:
-----------------------------
Fix Version/s: (was: 4.0.0.Alpha1)
4.0.0.Alpha3
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3, 3.6.0
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
Fix For: 3.6.next, 4.0.0.Alpha3
Attachments: commaAgainstCrossJoin.patch
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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:23 p.m.
New subject: [Hibernate-JIRA] Updated: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Steve Ebersole updated HHH-5352:
--------------------------------
Fix Version/s: (was: 3.6.next)
3.6.3
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3, 3.6.0
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
Fix For: 3.6.3, 4.0.0.Alpha3
Attachments: commaAgainstCrossJoin.patch
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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
12:59 p.m.
New subject: [Hibernate-JIRA] Updated: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Steve Ebersole updated HHH-5352:
--------------------------------
Fix Version/s: (was: 3.6.3)
3.6.4
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3, 3.6.0
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
Fix For: 3.6.4, 4.0.0.Alpha3
Attachments: commaAgainstCrossJoin.patch
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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:59 p.m.
New subject: [Hibernate-JIRA] Closed: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Steve Ebersole closed HHH-5352.
-------------------------------
Resolution: Fixed
Fix Version/s: (was: 3.6.4)
(was: 4.0.0.Alpha3)
antlr-rework
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3, 3.6.0
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
Fix For: antlr-rework
Attachments: commaAgainstCrossJoin.patch
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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:59 p.m.
New subject: [Hibernate-JIRA] Commented: (HHH-5352) Misleading replacement of commas with cross joins
[
http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352?page=c...
]
Steve Ebersole commented on HHH-5352:
-------------------------------------
Please stop telling me what I am obviously aware of and what I am obviously not aware of
etc, thanks.
I did what is workable given the current codebase. Reordering the joins is the proper
thing to do, but thats not feasible in the current codebase.
Misleading replacement of commas with cross joins
-------------------------------------------------
Key: HHH-5352
URL: http://opensource.atlassian.com/projects/hibernate/browse/HHH-5352
Project: Hibernate Core
Issue Type: Bug
Affects Versions: 3.5.0-Beta-2, 3.5.0-Beta-3, 3.5.0-Beta-4, 3.5.0-CR-1, 3.5.0-CR-2,
3.5.0-Final, 3.5.1, 3.5.2, 3.5.3, 3.6.0
Environment: Hibernate 3.5.3
Ms SQL Server 2005
Reporter: Patras Vlad
Fix For: antlr-rework
Attachments: commaAgainstCrossJoin.patch
There was a new feature implemented in 3.5.0-Beta-2: HHH-1480, as a result, for many
dialects, the comma operator "," was replaced with "cross join". As
it's already obvious from the feature's description, this changes join precedence.
If the query contains outer joins (left or right) this replacement changes the results
(because outer join precedence is important).
This might not be interpreted as a bug if you know what SQL operator will be generated
when you place a comma in HQL, but it's misleading if you don't. A HQL query
like:
{noformat}select a from A a, B left join B.c c{noformat}
is not equivalent with the SQL query:
{noformat}select a.* from A.a, B b left join C c on b.cid = c.id{noformat}
because the actual SQL query is:
{noformat}select a.* from A.a cross join B b left join C c on b.cid = c.id{noformat}
The first SQL query would make a left join on B and C and then a cross join with the
result and A (and this is what we should expect). The second SQL query makes a cross join
on A and B and then a left join with the result and C (this is not expected since we had a
comma in HQL).
I understand the issues presented in HHH-1480, but they should be expected, i.e. a
developer SHOULD expect a faliure from a query like
{noformat}select a from A a, B b join a.c C{noformat}
because "a" is not visible in the join. Hibernate should not use a cross join
behind the scenes to allow such a query at the expense of providing misleading results for
others.
Maybe turn this into a feature/improvement or add another to allow explicit comma or
croos join in HQL, or support parenthesis in HQL.
The only workaround I can see for now is to re-order the query like this:
{noformat}select a from B left join B.c c, A a{noformat}
--
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
4957
days inactive
5240
days old
hibernate-issues@lists.jboss.org
14 comments
3 participants
participants (3)
-
Gail Badner (JIRA) -
Patras Vlad (JIRA)
-
Steve Ebersole (JIRA)