Duplicated ORDER BY Data and Conditions In Query Every Time Called - jooq

Question

I've noticed this before and long ago stopped having my Conditions be private static finals, but I'm scratching my head on this one because it's a bit more problematic, especially if I'm debugging a query. Here's the example (and I've seen this before in 3.3.x, although I'm currently at 3.7.3):
final SelectJoinStep<Record13<String, String, String, String, String, BigDecimal, BigDecimal, BigDecimal, String, BigDecimal, String, String, Byte>> query = getSelect()
.from(getFrom(coConditions,
ConditionUtils.buildCondition(cortConditions, removeCortBySpeciality),
ConditionUtils.buildCondition(cosConditions, removeCosBySensitivity), tuConditions,
uaConditions, enableBlackMajik));
final SortField<?>[] orders = new SortField[] {DSL.inline(Integer.valueOf(2)).asc(),
DSL.inline(Integer.valueOf(1)).asc(), DSL.inline(Integer.valueOf(6)).asc()};
if (cosConditions.isPresent()) {
User.logger.error(builder.renderInlined(query.where(cosConditions.get()).orderBy(orders)));
return query.where(cosConditions.get()).orderBy(orders);
}
User.logger.error(builder.renderInlined(query.orderBy(orders)));
return query.orderBy(orders);
Here's the SQL snippet from the logger call just showing the ORDER BY:
order by
2 asc,
1 asc,
6 asc
And here's the SQL snippet of the ORDER BY that is sent to the SQL server:
order by
2 asc,
1 asc,
6 asc,
2 asc,
1 asc,
6 asc
Now, to further show the fun, here's another code snippet written just to demonstrate the problem:
User.logger.error(builder.renderInlined(query.orderBy(orders)));
User.logger.error(builder.renderInlined(query.orderBy(orders)));
User.logger.error(builder.renderInlined(query.orderBy(orders)));
return query.orderBy(orders);
First logger call:
order by
2 asc,
1 asc,
6 asc
Second logger call:
order by
2 asc,
1 asc,
6 asc,
2 asc,
1 asc,
6 asc
Third logger call:
order by
2 asc,
1 asc,
6 asc,
2 asc,
1 asc,
6 asc,
2 asc,
1 asc,
6 asc
What the DB sees:
order by
2 asc,
1 asc,
6 asc,
2 asc,
1 asc,
6 asc,
2 asc,
1 asc,
6 asc,
2 asc,
1 asc,
6 asc
Now, again, I actually have noticed this kind of behaviour before with my Conditions, where each time I call a Condition it is replicated to the point where I build my conditions and only reference them once (static ones made for some fun). Does anyone know why I'm seeing this behaviour (and see like behaviour with Conditions)?

Answer 1

This is due to an API design flaw in jOOQ that jOOQ has been carrying around for quite a while and will be fixed with jOOQ 4.0 only (#2198).
In general, you cannot safely assume that the DSL API is immutable (although it should be). So, your consecutive calls to orderBy() will actually each add the ORDER BY column set, but you print only the first one, so you don't see that.
The current behaviour is explained here (scroll to "mutability"):
http://www.jooq.org/doc/latest/manual/sql-building/sql-statements/dsl-and-non-dsl