按顺序排列的 jOOQ 子查询

Question

I'm using a subquery in order by like this on MySQL 8 database:

select * from series 
order by (select max(competition.competition_date) from competition 
          where competition.series_id = series.id) desc

But I didn't find a way to do that with jOOQ.

I tried the following query but this does not compile:

dsl
   .selectFrom(SERIES)
   .orderBy(dsl.select(DSL.max(COMPETITION.COMPETITION_DATE))
               .from(COMPETITION).where(COMPETITION.SERIES_ID.eq(SERIES.ID)).desc())
   .fetch()

Are subqueries not supported in order by?

Answer 1

Select<R> extends Field<R>

There's a pending feature request #4828 to let Select<R> extend Field<R> . This seems tempting because jOOQ already supports nested records to some extent for those dialects that support it.

But I have some doubts whether this is really a good idea in this case, because no database I'm aware of (ie where I tried this) supports scalar subqueries that project more than one column. It's possible to use such subqueries in row value expression predicates, eg

(a, b) IN (SELECT x, y FROM t)

But that's a different story, because it's limited to predicates, and not arbitrary column expressions. And it is already supported in jOOQ, via the various DSL.row() overloads, eg

row(A, B).in(select(T.X, T.Y).from(T))

Select<Record1<T>> extends Field<T>

This is definitely desireable, because a SELECT statement that projects only one column of type T really is a Field<T> in SQL, ie a scalar subquery. But letting Select<Record1<T>> extend Field<T> is not possible in Java. There is no way to express this using Java's generics. If we wanted to do this, we'd have to "overload" the Select type itself and create

• Select1<T1> extends Select<Record1<T1>>
• Select2<T1, T2> extends Select<Record2<T1, T2>>
• etc.

In that case, Select1<T1> could be a special case, extending Field<T1> , and the other ones would not participate in such a type hierarchy. But in order to achieve this, we'd have to duplicate the entire Select DSL API per projection degree , ie copy it 22 times, which is probably not worth it. There are already 67 Select.*Step types in the jOOQ API , as of jOOQ 3.13. This makes it difficult to justify the enhancement even only for scalar subqueries, ie for Select1 .

Using DSL.field(Select<Record1<T>>) and related API

You've already found the right answer . While Select<Record1<T>> cannot extend Field<T> , we can accept Select<? extends Record1<T>> Select<? extends Record1<T>> in plenty of API, as an overload to the usual T|Field<T> overloads. This has been done occasionally, and might be done more thoroughly throughout the API: https://github.com/jOOQ/jOOQ/issues/7240 .

It wouldn't help you, because you want to call .desc() on a column expression (the Select ), rather than wrap pass it to a method, so we're back at Java's limitation mentioned before.

Kotlin and other languages

If you're using Kotlin or other languages that have some way of providing "extension functions", however, you could use this approach:

inline fun <T> Select<Record1<T>>.desc(): SortField<T> {
    return DSL.field(this).desc();
}

jOOQ might provide these out of the box in the future: https://github.com/jOOQ/jOOQ/issues/6256

Answer 2

Turning the subquery into a Field works:

dsl.selectFrom(SERIES)
   .orderBy(DSL.field(dsl.select(DSL.max(COMPETITION.COMPETITION_DATE)).from(COMPETITION)
                  .where(COMPETITION.SERIES_ID.eq(SERIES.ID))).desc())
   .fetch()