[ ANNOUNCEMENT ] jOOQ 3.11 Released With 4 New Databases, Implicit Joins, Diagnostics, and Much More

Discussion:

Lukas Eder

2018-06-07 15:05:28 UTC

Version 3.11.0 - June 7, 2018
================================================================================

New Databases Supported
-----------------------

At last, 4 new SQL dialects have been added to jOOQ! These are:

jOOQ Professional Edition

- Aurora MySQL Edition
- Aurora PostgreSQL Edition
- Azure SQL Data Warehouse

jOOQ Enterprise Edition

- Teradata

Implicit Joins
--------------

One of the really cool features in ORMs like Hibernate, Doctrine, and
others, is
the capability of using a relationship graph notation to access another
entity's
columns through what is often called "implicit joins".

Instead of explicitly joining a to-one relationship to access its columns:

SELECT author.first_name, author.last_name, book.title
FROM book
JOIN author ON book.author_id = author.id

We would like to be able to access those columns directly, using this
notation:

SELECT book.author.first_name, book.author.last_name, book.title
FROM book

The join is implied and should be added implicitly. jOOQ now allows for
this to
happen when you use the code generator:

ctx.select(BOOK.author().FIRST_NAME, BOOK.author().LAST_NAME, BOOK.TITLE)
.from(BOOK)
.fetch();

When rendering this query, the implicit join graph will be calculated on
the fly
and added behind the scenes to the BOOK table. This works for queries of
arbitrary complexity and on any level of nested SELECT.

More details in this blog post:
https://blog.jooq.org/2018/02/20/type-safe-implicit-join-through-path-navigation-in-jooq-3-11/

DiagnosticsListener SPI
-----------------------

A new DiagnosticsListener SPI has been added to jOOQ:
https://github.com/jOOQ/jOOQ/issues/5960

The purpose of this SPI is to sanitise your SQL language, JDBC and jOOQ API
usage. Listeners can listen to events such as:

- duplicateStatements (similar SQL is executed, bind variables should be
used)
- repeatedStatements (identical SQL is executed, should be batched or
rewritten)
- tooManyColumnsFetched (not all projected columns were needed)
- tooManyRowsFetched (not all fetched rows were needed)

The great thing about this SPI is that it can be exposed to clients through
the
JDBC API, in case of which the diagnostics feature can reverse engineer your
JDBC or even JPA generated SQL. Ever wanted to detect N+1 queries from
Hibernate? Pass those Hibernate-generated queries through this SPI.

Want to find missing bind variables leading to cursor cache contention or
SQLi?
Let jOOQ find similar SQL statements and report them. E.g.

- SELECT name FROM person WHERE id = 1
- SELECT name FROM person WHERE id = 2

Or also:

- SELECT name FROM person WHERE id IN (?, ?)
- SELECT name FROM person WHERE id IN (?, ?, ?)

Anonymous blocks
----------------

Many databases support anonymous blocks to run several statements in a
single
block scope. For example, Oracle:

DECLARE
l_var NUMBER(10);
BEGIN
l_var := 10;
dbms_output.put_line(l_var);
END;

jOOQ now supports the new org.jooq.Block API to allow for wrapping DDL and
DML
statements in such a block. This is a first step towards a future jOOQ
providing
support for:

- Abstractions over procedural languages
- CREATE PROCEDURE and CREATE FUNCTION statements
- Trigger support
- And much more

Parser
------

jOOQ's parser support is an ongoing effort. This release has added support
for
a lot of new SQL clauses and functions from various vendors and in various
DDL
and DML statements.

The parser is now also exposed through a public website and API, where SQL
can
be translated from one dialect to another:
https://www.jooq.org/translate

This website will help further drive jOOQ API development by helping to find
missing functionality that is used in real-world SQL.

Another way to access this API is through the new org.jooq.ParserCLI command
line tool. For example, run:

$ java -jar jooq-3.10.0.jar -f -t ORACLE -s "SELECT * FROM (VALUES(1),(2))
AS t(a)"

To get:

select *
from (
(
select null a
from dual
where 1 = 0
)
union all (
select *
from (
(
select 1
from dual
)
union all (
select 2
from dual
)
) t
)
) t;

Formal Java 10 Support
----------------------

jOOQ 3.11 is the first release that is formally integration tested with
Java 10.
To use jOOQ with Java 10, use the Java 8 distribution which has not yet been
modularised, but contains Automatic-Module-Name specification to be forward
compatible with future, modularised jOOQ distributions.

Additionally, package names between jOOQ, jOOQ-meta, and jOOQ-codegen have
been
cleaned up to prevent duplicate package names, and the JAXB dependency has
been
added explicitly to the various artefacts.

End of Scala 2.11 support in the jOOQ Open Source Edition
---------------------------------------------------------

Scala 2.10 and 2.11 are now only supported in the commercial distributions

Other great improvements
------------------------

- Finally, asterisks (SELECT * or SELECT t.*) are formally supported in the
API.
- Collations can now be specified on a variety of syntax elements
- The org.jooq.Comment type has been added, and DDL statements for it
- The DefaultBinding implementation has been rewritten for better peformance
- Several performance improvements in jOOQ's internals
- Many more DDL statements are supported including GRANT and REVOKE
- Support for the EXPLAIN statement
- FETCH n PERCENT ROWS and TOP n PERCENT clauses are supported
- Better org.jooq.Name and org.jooq.Named API for identifier handling
- Support for PostgreSQL 10
- Support for SQL Server 2017
- Support for DB2 11
- Upgraded MariaDB support for window functions, inv dist functions, WITH
- jOOU dependency updated to 0.9.3
- jOOR dependency updated to 0.9.8
- Server output (e.g. DBMS_OUTPUT) can now be fetched automatically, by jOOQ
- Code generation support for PL/SQL TABLE types
- SQL Keywords Can Now Be Rendered In Pascal Style If You Must
- Emulate PostgreSQL's ON CONFLICT clause using MERGE

The complete list can be seen here:
https://www.jooq.org/notes/?version=3.11

--
You received this message because you are subscribed to the Google Groups "jOOQ User Group" group.
To unsubscribe from this group and stop receiving emails from it, send an email to jooq-user+***@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

s***@gmail.com

2018-06-09 23:35:40 UTC

Permalink

Is there an upgrade or migration guide?

My build broke initially because the codegen classes have been moved, took
me a little while to figure out I needed to dig back in to the codegen
guide in the manual to figure out the new locations. That's the kind of
thing it's good to know up front instead of having to figure it out
yourself.

Post by Lukas Eder
Version 3.11.0 - June 7, 2018
================================================================================
New Databases Supported
-----------------------
jOOQ Professional Edition
- Aurora MySQL Edition
- Aurora PostgreSQL Edition
- Azure SQL Data Warehouse
jOOQ Enterprise Edition
- Teradata
Implicit Joins
--------------
One of the really cool features in ORMs like Hibernate, Doctrine, and
others, is
the capability of using a relationship graph notation to access another
entity's
columns through what is often called "implicit joins".
SELECT author.first_name, author.last_name, book.title
FROM book
JOIN author ON book.author_id = author.id
We would like to be able to access those columns directly, using this
SELECT book.author.first_name, book.author.last_name, book.title
FROM book
The join is implied and should be added implicitly. jOOQ now allows for
this to
ctx.select(BOOK.author().FIRST_NAME, BOOK.author().LAST_NAME, BOOK.TITLE)
.from(BOOK)
.fetch();
When rendering this query, the implicit join graph will be calculated on
the fly
and added behind the scenes to the BOOK table. This works for queries of
arbitrary complexity and on any level of nested SELECT.
https://blog.jooq.org/2018/02/20/type-safe-implicit-join-through-path-navigation-in-jooq-3-11/
DiagnosticsListener SPI
-----------------------
https://github.com/jOOQ/jOOQ/issues/5960
The purpose of this SPI is to sanitise your SQL language, JDBC and jOOQ API
- duplicateStatements (similar SQL is executed, bind variables should be
used)
- repeatedStatements (identical SQL is executed, should be batched or
rewritten)
- tooManyColumnsFetched (not all projected columns were needed)
- tooManyRowsFetched (not all fetched rows were needed)
The great thing about this SPI is that it can be exposed to clients
through the
JDBC API, in case of which the diagnostics feature can reverse engineer your
JDBC or even JPA generated SQL. Ever wanted to detect N+1 queries from
Hibernate? Pass those Hibernate-generated queries through this SPI.
Want to find missing bind variables leading to cursor cache contention or
SQLi?
Let jOOQ find similar SQL statements and report them. E.g.
- SELECT name FROM person WHERE id = 1
- SELECT name FROM person WHERE id = 2
- SELECT name FROM person WHERE id IN (?, ?)
- SELECT name FROM person WHERE id IN (?, ?, ?)
Anonymous blocks
----------------
Many databases support anonymous blocks to run several statements in a
single
DECLARE
l_var NUMBER(10);
BEGIN
l_var := 10;
dbms_output.put_line(l_var);
END;
jOOQ now supports the new org.jooq.Block API to allow for wrapping DDL and
DML
statements in such a block. This is a first step towards a future jOOQ
providing
- Abstractions over procedural languages
- CREATE PROCEDURE and CREATE FUNCTION statements
- Trigger support
- And much more
Parser
------
jOOQ's parser support is an ongoing effort. This release has added support
for
a lot of new SQL clauses and functions from various vendors and in various
DDL
and DML statements.
The parser is now also exposed through a public website and API, where SQL
can
https://www.jooq.org/translate
This website will help further drive jOOQ API development by helping to find
missing functionality that is used in real-world SQL.
Another way to access this API is through the new org.jooq.ParserCLI command
$ java -jar jooq-3.10.0.jar -f -t ORACLE -s "SELECT * FROM (VALUES(1),(2))
AS t(a)"
select *
from (
(
select null a
from dual
where 1 = 0
)
union all (
select *
from (
(
select 1
from dual
)
union all (
select 2
from dual
)
) t
)
) t;
Formal Java 10 Support
----------------------
jOOQ 3.11 is the first release that is formally integration tested with
Java 10.
To use jOOQ with Java 10, use the Java 8 distribution which has not yet been
modularised, but contains Automatic-Module-Name specification to be forward
compatible with future, modularised jOOQ distributions.
Additionally, package names between jOOQ, jOOQ-meta, and jOOQ-codegen have
been
cleaned up to prevent duplicate package names, and the JAXB dependency has
been
added explicitly to the various artefacts.
End of Scala 2.11 support in the jOOQ Open Source Edition
---------------------------------------------------------
Scala 2.10 and 2.11 are now only supported in the commercial distributions
Other great improvements
------------------------
- Finally, asterisks (SELECT * or SELECT t.*) are formally supported in
the API.
- Collations can now be specified on a variety of syntax elements
- The org.jooq.Comment type has been added, and DDL statements for it
- The DefaultBinding implementation has been rewritten for better peformance
- Several performance improvements in jOOQ's internals
- Many more DDL statements are supported including GRANT and REVOKE
- Support for the EXPLAIN statement
- FETCH n PERCENT ROWS and TOP n PERCENT clauses are supported
- Better org.jooq.Name and org.jooq.Named API for identifier handling
- Support for PostgreSQL 10
- Support for SQL Server 2017
- Support for DB2 11
- Upgraded MariaDB support for window functions, inv dist functions, WITH
- jOOU dependency updated to 0.9.3
- jOOR dependency updated to 0.9.8
- Server output (e.g. DBMS_OUTPUT) can now be fetched automatically, by jOOQ
- Code generation support for PL/SQL TABLE types
- SQL Keywords Can Now Be Rendered In Pascal Style If You Must
- Emulate PostgreSQL's ON CONFLICT clause using MERGE
https://www.jooq.org/notes/?version=3.11

Lukas Eder

2018-06-11 08:11:12 UTC

Permalink

Hello,

Thank you very much for pointing this out.

The name change has been mentioned in the release notes, once under the
Java 10 support section, and then again in the breaking changes section:
https://www.jooq.org/notes

I think we could create a new page that filters only on the breaking
changes sections of each release, and call that "migration guide". Will
look into it.

As pointed out also in a different discussion, there will also be a
specific error message pointing out the package rename if someone upgrades
from jOOQ 3.10 or less and has "org.jooq.util" package references in their
configurations. See:

- https://github.com/jOOQ/jOOQ/issues/7556
- https://groups.google.com/d/msg/jooq-user/-ILukM1EvlM/yExZ5KPKAgAJ

Thanks,
Lukas

Post by s***@gmail.com
Is there an upgrade or migration guide?
My build broke initially because the codegen classes have been moved, took
me a little while to figure out I needed to dig back in to the codegen
guide in the manual to figure out the new locations. That's the kind of
thing it's good to know up front instead of having to figure it out
yourself.

Post by Lukas Eder
Version 3.11.0 - June 7, 2018
================================================================================
New Databases Supported
-----------------------
jOOQ Professional Edition
- Aurora MySQL Edition
- Aurora PostgreSQL Edition
- Azure SQL Data Warehouse
jOOQ Enterprise Edition
- Teradata
Implicit Joins
--------------
One of the really cool features in ORMs like Hibernate, Doctrine, and
others, is
the capability of using a relationship graph notation to access another
entity's
columns through what is often called "implicit joins".
SELECT author.first_name, author.last_name, book.title
FROM book
JOIN author ON book.author_id = author.id
We would like to be able to access those columns directly, using this
SELECT book.author.first_name, book.author.last_name, book.title
FROM book
The join is implied and should be added implicitly. jOOQ now allows for
this to
ctx.select(BOOK.author().FIRST_NAME, BOOK.author().LAST_NAME, BOOK.TITLE)
.from(BOOK)
.fetch();
When rendering this query, the implicit join graph will be calculated on
the fly
and added behind the scenes to the BOOK table. This works for queries of
arbitrary complexity and on any level of nested SELECT.
https://blog.jooq.org/2018/02/20/type-safe-implicit-join-through-path-navigation-in-jooq-3-11/
DiagnosticsListener SPI
-----------------------
https://github.com/jOOQ/jOOQ/issues/5960
The purpose of this SPI is to sanitise your SQL language, JDBC and jOOQ API
- duplicateStatements (similar SQL is executed, bind variables should be
used)
- repeatedStatements (identical SQL is executed, should be batched or
rewritten)
- tooManyColumnsFetched (not all projected columns were needed)
- tooManyRowsFetched (not all fetched rows were needed)
The great thing about this SPI is that it can be exposed to clients
through the
JDBC API, in case of which the diagnostics feature can reverse engineer your
JDBC or even JPA generated SQL. Ever wanted to detect N+1 queries from
Hibernate? Pass those Hibernate-generated queries through this SPI.
Want to find missing bind variables leading to cursor cache contention or
SQLi?
Let jOOQ find similar SQL statements and report them. E.g.
- SELECT name FROM person WHERE id = 1
- SELECT name FROM person WHERE id = 2
- SELECT name FROM person WHERE id IN (?, ?)
- SELECT name FROM person WHERE id IN (?, ?, ?)
Anonymous blocks
----------------
Many databases support anonymous blocks to run several statements in a
single
DECLARE
l_var NUMBER(10);
BEGIN
l_var := 10;
dbms_output.put_line(l_var);
END;
jOOQ now supports the new org.jooq.Block API to allow for wrapping DDL
and DML
statements in such a block. This is a first step towards a future jOOQ
providing
- Abstractions over procedural languages
- CREATE PROCEDURE and CREATE FUNCTION statements
- Trigger support
- And much more
Parser
------
jOOQ's parser support is an ongoing effort. This release has added
support for
a lot of new SQL clauses and functions from various vendors and in
various DDL
and DML statements.
The parser is now also exposed through a public website and API, where
SQL can
https://www.jooq.org/translate
This website will help further drive jOOQ API development by helping to find
missing functionality that is used in real-world SQL.
Another way to access this API is through the new org.jooq.ParserCLI command
$ java -jar jooq-3.10.0.jar -f -t ORACLE -s "SELECT * FROM
(VALUES(1),(2)) AS t(a)"
select *
from (
(
select null a
from dual
where 1 = 0
)
union all (
select *
from (
(
select 1
from dual
)
union all (
select 2
from dual
)
) t
)
) t;
Formal Java 10 Support
----------------------
jOOQ 3.11 is the first release that is formally integration tested with
Java 10.
To use jOOQ with Java 10, use the Java 8 distribution which has not yet been
modularised, but contains Automatic-Module-Name specification to be forward
compatible with future, modularised jOOQ distributions.
Additionally, package names between jOOQ, jOOQ-meta, and jOOQ-codegen
have been
cleaned up to prevent duplicate package names, and the JAXB dependency
has been
added explicitly to the various artefacts.
End of Scala 2.11 support in the jOOQ Open Source Edition
---------------------------------------------------------
Scala 2.10 and 2.11 are now only supported in the commercial distributions
Other great improvements
------------------------
- Finally, asterisks (SELECT * or SELECT t.*) are formally supported in
the API.
- Collations can now be specified on a variety of syntax elements
- The org.jooq.Comment type has been added, and DDL statements for it
- The DefaultBinding implementation has been rewritten for better peformance
- Several performance improvements in jOOQ's internals
- Many more DDL statements are supported including GRANT and REVOKE
- Support for the EXPLAIN statement
- FETCH n PERCENT ROWS and TOP n PERCENT clauses are supported
- Better org.jooq.Name and org.jooq.Named API for identifier handling
- Support for PostgreSQL 10
- Support for SQL Server 2017
- Support for DB2 11
- Upgraded MariaDB support for window functions, inv dist functions, WITH
- jOOU dependency updated to 0.9.3
- jOOR dependency updated to 0.9.8
- Server output (e.g. DBMS_OUTPUT) can now be fetched automatically, by jOOQ
- Code generation support for PL/SQL TABLE types
- SQL Keywords Can Now Be Rendered In Pascal Style If You Must
- Emulate PostgreSQL's ON CONFLICT clause using MERGE
https://www.jooq.org/notes/?version=3.11

--
You received this message because you are subscribed to the Google Groups
"jOOQ User Group" group.
To unsubscribe from this group and stop receiving emails from it, send an
For more options, visit https://groups.google.com/d/optout.

Lukas Eder

2018-06-11 08:28:07 UTC

Permalink

For the record, I have now also documented this change on Stack Overflow,
which should help find this issue more easily:
https://stackoverflow.com/q/50793357/521799

Post by Lukas Eder
Hello,
Thank you very much for pointing this out.
The name change has been mentioned in the release notes, once under the
https://www.jooq.org/notes
I think we could create a new page that filters only on the breaking
changes sections of each release, and call that "migration guide". Will
look into it.
As pointed out also in a different discussion, there will also be a
specific error message pointing out the package rename if someone upgrades
from jOOQ 3.10 or less and has "org.jooq.util" package references in their
- https://github.com/jOOQ/jOOQ/issues/7556
- https://groups.google.com/d/msg/jooq-user/-ILukM1EvlM/yExZ5KPKAgAJ
Thanks,
Lukas

Post by s***@gmail.com
Is there an upgrade or migration guide?
My build broke initially because the codegen classes have been moved,
took me a little while to figure out I needed to dig back in to the codegen
guide in the manual to figure out the new locations. That's the kind of
thing it's good to know up front instead of having to figure it out
yourself.

Post by Lukas Eder
Version 3.11.0 - June 7, 2018
================================================================================
New Databases Supported
-----------------------
jOOQ Professional Edition
- Aurora MySQL Edition
- Aurora PostgreSQL Edition
- Azure SQL Data Warehouse
jOOQ Enterprise Edition
- Teradata
Implicit Joins
--------------
One of the really cool features in ORMs like Hibernate, Doctrine, and
others, is
the capability of using a relationship graph notation to access another
entity's
columns through what is often called "implicit joins".
SELECT author.first_name, author.last_name, book.title
FROM book
JOIN author ON book.author_id = author.id
We would like to be able to access those columns directly, using this
SELECT book.author.first_name, book.author.last_name, book.title
FROM book
The join is implied and should be added implicitly. jOOQ now allows for
this to
ctx.select(BOOK.author().FIRST_NAME, BOOK.author().LAST_NAME, BOOK.TITLE)
.from(BOOK)
.fetch();
When rendering this query, the implicit join graph will be calculated on
the fly
and added behind the scenes to the BOOK table. This works for queries of
arbitrary complexity and on any level of nested SELECT.
https://blog.jooq.org/2018/02/20/type-safe-implicit-join-through-path-navigation-in-jooq-3-11/
DiagnosticsListener SPI
-----------------------
https://github.com/jOOQ/jOOQ/issues/5960
The purpose of this SPI is to sanitise your SQL language, JDBC and jOOQ API
- duplicateStatements (similar SQL is executed, bind variables should be
used)
- repeatedStatements (identical SQL is executed, should be batched or
rewritten)
- tooManyColumnsFetched (not all projected columns were needed)
- tooManyRowsFetched (not all fetched rows were needed)
The great thing about this SPI is that it can be exposed to clients
through the
JDBC API, in case of which the diagnostics feature can reverse engineer your
JDBC or even JPA generated SQL. Ever wanted to detect N+1 queries from
Hibernate? Pass those Hibernate-generated queries through this SPI.
Want to find missing bind variables leading to cursor cache contention
or SQLi?
Let jOOQ find similar SQL statements and report them. E.g.
- SELECT name FROM person WHERE id = 1
- SELECT name FROM person WHERE id = 2
- SELECT name FROM person WHERE id IN (?, ?)
- SELECT name FROM person WHERE id IN (?, ?, ?)
Anonymous blocks
----------------
Many databases support anonymous blocks to run several statements in a
single
DECLARE
l_var NUMBER(10);
BEGIN
l_var := 10;
dbms_output.put_line(l_var);
END;
jOOQ now supports the new org.jooq.Block API to allow for wrapping DDL
and DML
statements in such a block. This is a first step towards a future jOOQ
providing
- Abstractions over procedural languages
- CREATE PROCEDURE and CREATE FUNCTION statements
- Trigger support
- And much more
Parser
------
jOOQ's parser support is an ongoing effort. This release has added
support for
a lot of new SQL clauses and functions from various vendors and in
various DDL
and DML statements.
The parser is now also exposed through a public website and API, where
SQL can
https://www.jooq.org/translate
This website will help further drive jOOQ API development by helping to find
missing functionality that is used in real-world SQL.
Another way to access this API is through the new org.jooq.ParserCLI command
$ java -jar jooq-3.10.0.jar -f -t ORACLE -s "SELECT * FROM
(VALUES(1),(2)) AS t(a)"
select *
from (
(
select null a
from dual
where 1 = 0
)
union all (
select *
from (
(
select 1
from dual
)
union all (
select 2
from dual
)
) t
)
) t;
Formal Java 10 Support
----------------------
jOOQ 3.11 is the first release that is formally integration tested with
Java 10.
To use jOOQ with Java 10, use the Java 8 distribution which has not yet been
modularised, but contains Automatic-Module-Name specification to be forward
compatible with future, modularised jOOQ distributions.
Additionally, package names between jOOQ, jOOQ-meta, and jOOQ-codegen
have been
cleaned up to prevent duplicate package names, and the JAXB dependency
has been
added explicitly to the various artefacts.
End of Scala 2.11 support in the jOOQ Open Source Edition
---------------------------------------------------------
Scala 2.10 and 2.11 are now only supported in the commercial
distributions
Other great improvements
------------------------
- Finally, asterisks (SELECT * or SELECT t.*) are formally supported in
the API.
- Collations can now be specified on a variety of syntax elements
- The org.jooq.Comment type has been added, and DDL statements for it
- The DefaultBinding implementation has been rewritten for better peformance
- Several performance improvements in jOOQ's internals
- Many more DDL statements are supported including GRANT and REVOKE
- Support for the EXPLAIN statement
- FETCH n PERCENT ROWS and TOP n PERCENT clauses are supported
- Better org.jooq.Name and org.jooq.Named API for identifier handling
- Support for PostgreSQL 10
- Support for SQL Server 2017
- Support for DB2 11
- Upgraded MariaDB support for window functions, inv dist functions, WITH
- jOOU dependency updated to 0.9.3
- jOOR dependency updated to 0.9.8
- Server output (e.g. DBMS_OUTPUT) can now be fetched automatically, by jOOQ
- Code generation support for PL/SQL TABLE types
- SQL Keywords Can Now Be Rendered In Pascal Style If You Must
- Emulate PostgreSQL's ON CONFLICT clause using MERGE
https://www.jooq.org/notes/?version=3.11

s***@gmail.com

2018-06-11 09:42:28 UTC

Permalink

Upvoted the Q&A on StackOverflow.

I'd assumed the renamed package thing was relevant to the Java 10 users -
personally, I don't plan on upgrading past Java 8 for a long while yet, so
I filtered the whole section out.

I didn't get as far as the breaking changes section - I quit scrolling down
through the "Features & Improvements" section after a couple of pages. It
might be helpful to move the breaking changes section to the top,
especially when the improvements section is so long (first world problems).

Post by Lukas Eder
For the record, I have now also documented this change on Stack Overflow,
https://stackoverflow.com/q/50793357/521799

Post by s***@gmail.com
Is there an upgrade or migration guide?
My build broke initially because the codegen classes have been moved,
took me a little while to figure out I needed to dig back in to the codegen
guide in the manual to figure out the new locations. That's the kind of
thing it's good to know up front instead of having to figure it out
yourself.

Post by Lukas Eder
Version 3.11.0 - June 7, 2018
================================================================================
New Databases Supported
-----------------------
jOOQ Professional Edition
- Aurora MySQL Edition
- Aurora PostgreSQL Edition
- Azure SQL Data Warehouse
jOOQ Enterprise Edition
- Teradata
Implicit Joins
--------------
One of the really cool features in ORMs like Hibernate, Doctrine, and
others, is
the capability of using a relationship graph notation to access another
entity's
columns through what is often called "implicit joins".
SELECT author.first_name, author.last_name, book.title
FROM book
JOIN author ON book.author_id = author.id
We would like to be able to access those columns directly, using this
SELECT book.author.first_name, book.author.last_name, book.title
FROM book
The join is implied and should be added implicitly. jOOQ now allows for
this to
ctx.select(BOOK.author().FIRST_NAME, BOOK.author().LAST_NAME, BOOK.TITLE)
.from(BOOK)
.fetch();
When rendering this query, the implicit join graph will be calculated
on the fly
and added behind the scenes to the BOOK table. This works for queries of
arbitrary complexity and on any level of nested SELECT.
https://blog.jooq.org/2018/02/20/type-safe-implicit-join-through-path-navigation-in-jooq-3-11/
DiagnosticsListener SPI
-----------------------
https://github.com/jOOQ/jOOQ/issues/5960
The purpose of this SPI is to sanitise your SQL language, JDBC and jOOQ API
- duplicateStatements (similar SQL is executed, bind variables should
be used)
- repeatedStatements (identical SQL is executed, should be batched or
rewritten)
- tooManyColumnsFetched (not all projected columns were needed)
- tooManyRowsFetched (not all fetched rows were needed)
The great thing about this SPI is that it can be exposed to clients
through the
JDBC API, in case of which the diagnostics feature can reverse engineer your
JDBC or even JPA generated SQL. Ever wanted to detect N+1 queries from
Hibernate? Pass those Hibernate-generated queries through this SPI.
Want to find missing bind variables leading to cursor cache contention
or SQLi?
Let jOOQ find similar SQL statements and report them. E.g.
- SELECT name FROM person WHERE id = 1
- SELECT name FROM person WHERE id = 2
- SELECT name FROM person WHERE id IN (?, ?)
- SELECT name FROM person WHERE id IN (?, ?, ?)
Anonymous blocks
----------------
Many databases support anonymous blocks to run several statements in a
single
DECLARE
l_var NUMBER(10);
BEGIN
l_var := 10;
dbms_output.put_line(l_var);
END;
jOOQ now supports the new org.jooq.Block API to allow for wrapping DDL
and DML
statements in such a block. This is a first step towards a future jOOQ
providing
- Abstractions over procedural languages
- CREATE PROCEDURE and CREATE FUNCTION statements
- Trigger support
- And much more
Parser
------
jOOQ's parser support is an ongoing effort. This release has added
support for
a lot of new SQL clauses and functions from various vendors and in
various DDL
and DML statements.
The parser is now also exposed through a public website and API, where
SQL can
https://www.jooq.org/translate
This website will help further drive jOOQ API development by helping to find
missing functionality that is used in real-world SQL.
Another way to access this API is through the new org.jooq.ParserCLI command
$ java -jar jooq-3.10.0.jar -f -t ORACLE -s "SELECT * FROM
(VALUES(1),(2)) AS t(a)"
select *
from (
(
select null a
from dual
where 1 = 0
)
union all (
select *
from (
(
select 1
from dual
)
union all (
select 2
from dual
)
) t
)
) t;
Formal Java 10 Support
----------------------
jOOQ 3.11 is the first release that is formally integration tested with
Java 10.
To use jOOQ with Java 10, use the Java 8 distribution which has not yet been
modularised, but contains Automatic-Module-Name specification to be forward
compatible with future, modularised jOOQ distributions.
Additionally, package names between jOOQ, jOOQ-meta, and jOOQ-codegen
have been
cleaned up to prevent duplicate package names, and the JAXB dependency
has been
added explicitly to the various artefacts.
End of Scala 2.11 support in the jOOQ Open Source Edition
---------------------------------------------------------
Scala 2.10 and 2.11 are now only supported in the commercial distributions
Other great improvements
------------------------
- Finally, asterisks (SELECT * or SELECT t.*) are formally supported in
the API.
- Collations can now be specified on a variety of syntax elements
- The org.jooq.Comment type has been added, and DDL statements for it
- The DefaultBinding implementation has been rewritten for better peformance
- Several performance improvements in jOOQ's internals
- Many more DDL statements are supported including GRANT and REVOKE
- Support for the EXPLAIN statement
- FETCH n PERCENT ROWS and TOP n PERCENT clauses are supported
- Better org.jooq.Name and org.jooq.Named API for identifier handling
- Support for PostgreSQL 10
- Support for SQL Server 2017
- Support for DB2 11
- Upgraded MariaDB support for window functions, inv dist functions, WITH
- jOOU dependency updated to 0.9.3
- jOOR dependency updated to 0.9.8
- Server output (e.g. DBMS_OUTPUT) can now be fetched automatically, by jOOQ
- Code generation support for PL/SQL TABLE types
- SQL Keywords Can Now Be Rendered In Pascal Style If You Must
- Emulate PostgreSQL's ON CONFLICT clause using MERGE
https://www.jooq.org/notes/?version=3.11

--
You received this message because you are subscribed to the Google
Groups "jOOQ User Group" group.
To unsubscribe from this group and stop receiving emails from it, send
For more options, visit https://groups.google.com/d/optout.

Lukas Eder

2018-06-11 09:52:37 UTC

Permalink

Thanks for the feedback.

I don't agree we should put the breaking changes at the top. The top is
reserved for the "good news", not the "bad news" :)

Having a dedicated breaking changes page is more useful, especially to
those that plan to upgrade e.g. from 3.6 to 3.10 directly, as they have an
aggregated view of what changed in between all those minor releases.

Thanks,
Lukas

Post by s***@gmail.com
Upvoted the Q&A on StackOverflow.
I'd assumed the renamed package thing was relevant to the Java 10 users -
personally, I don't plan on upgrading past Java 8 for a long while yet, so
I filtered the whole section out.
I didn't get as far as the breaking changes section - I quit scrolling
down through the "Features & Improvements" section after a couple of
pages. It might be helpful to move the breaking changes section to the
top, especially when the improvements section is so long (first world
problems).

Post by Lukas Eder
For the record, I have now also documented this change on Stack Overflow,
https://stackoverflow.com/q/50793357/521799

Post by s***@gmail.com
Is there an upgrade or migration guide?
My build broke initially because the codegen classes have been moved,
took me a little while to figure out I needed to dig back in to the codegen
guide in the manual to figure out the new locations. That's the kind of
thing it's good to know up front instead of having to figure it out
yourself.

Post by Lukas Eder
Version 3.11.0 - June 7, 2018
================================================================================
New Databases Supported
-----------------------
jOOQ Professional Edition
- Aurora MySQL Edition
- Aurora PostgreSQL Edition
- Azure SQL Data Warehouse
jOOQ Enterprise Edition
- Teradata
Implicit Joins
--------------
One of the really cool features in ORMs like Hibernate, Doctrine, and
others, is
the capability of using a relationship graph notation to access
another entity's
columns through what is often called "implicit joins".
SELECT author.first_name, author.last_name, book.title
FROM book
JOIN author ON book.author_id = author.id
We would like to be able to access those columns directly, using this
SELECT book.author.first_name, book.author.last_name, book.title
FROM book
The join is implied and should be added implicitly. jOOQ now allows
for this to
ctx.select(BOOK.author().FIRST_NAME, BOOK.author().LAST_NAME, BOOK.TITLE)
.from(BOOK)
.fetch();
When rendering this query, the implicit join graph will be calculated
on the fly
and added behind the scenes to the BOOK table. This works for queries of
arbitrary complexity and on any level of nested SELECT.
https://blog.jooq.org/2018/02/20/type-safe-implicit-join-through-path-navigation-in-jooq-3-11/
DiagnosticsListener SPI
-----------------------
https://github.com/jOOQ/jOOQ/issues/5960
The purpose of this SPI is to sanitise your SQL language, JDBC and jOOQ API
- duplicateStatements (similar SQL is executed, bind variables should
be used)
- repeatedStatements (identical SQL is executed, should be batched or
rewritten)
- tooManyColumnsFetched (not all projected columns were needed)
- tooManyRowsFetched (not all fetched rows were needed)
The great thing about this SPI is that it can be exposed to clients
through the
JDBC API, in case of which the diagnostics feature can reverse engineer your
JDBC or even JPA generated SQL. Ever wanted to detect N+1 queries from
Hibernate? Pass those Hibernate-generated queries through this SPI.
Want to find missing bind variables leading to cursor cache contention
or SQLi?
Let jOOQ find similar SQL statements and report them. E.g.
- SELECT name FROM person WHERE id = 1
- SELECT name FROM person WHERE id = 2
- SELECT name FROM person WHERE id IN (?, ?)
- SELECT name FROM person WHERE id IN (?, ?, ?)
Anonymous blocks
----------------
Many databases support anonymous blocks to run several statements in a
single
DECLARE
l_var NUMBER(10);
BEGIN
l_var := 10;
dbms_output.put_line(l_var);
END;
jOOQ now supports the new org.jooq.Block API to allow for wrapping DDL
and DML
statements in such a block. This is a first step towards a future jOOQ
providing
- Abstractions over procedural languages
- CREATE PROCEDURE and CREATE FUNCTION statements
- Trigger support
- And much more
Parser
------
jOOQ's parser support is an ongoing effort. This release has added
support for
a lot of new SQL clauses and functions from various vendors and in
various DDL
and DML statements.
The parser is now also exposed through a public website and API, where
SQL can
https://www.jooq.org/translate
This website will help further drive jOOQ API development by helping to find
missing functionality that is used in real-world SQL.
Another way to access this API is through the new org.jooq.ParserCLI command
$ java -jar jooq-3.10.0.jar -f -t ORACLE -s "SELECT * FROM
(VALUES(1),(2)) AS t(a)"
select *
from (
(
select null a
from dual
where 1 = 0
)
union all (
select *
from (
(
select 1
from dual
)
union all (
select 2
from dual
)
) t
)
) t;
Formal Java 10 Support
----------------------
jOOQ 3.11 is the first release that is formally integration tested
with Java 10.
To use jOOQ with Java 10, use the Java 8 distribution which has not yet been
modularised, but contains Automatic-Module-Name specification to be forward
compatible with future, modularised jOOQ distributions.
Additionally, package names between jOOQ, jOOQ-meta, and jOOQ-codegen
have been
cleaned up to prevent duplicate package names, and the JAXB dependency
has been
added explicitly to the various artefacts.
End of Scala 2.11 support in the jOOQ Open Source Edition
---------------------------------------------------------
Scala 2.10 and 2.11 are now only supported in the commercial distributions
Other great improvements
------------------------
- Finally, asterisks (SELECT * or SELECT t.*) are formally supported
in the API.
- Collations can now be specified on a variety of syntax elements
- The org.jooq.Comment type has been added, and DDL statements for it
- The DefaultBinding implementation has been rewritten for better peformance
- Several performance improvements in jOOQ's internals
- Many more DDL statements are supported including GRANT and REVOKE
- Support for the EXPLAIN statement
- FETCH n PERCENT ROWS and TOP n PERCENT clauses are supported
- Better org.jooq.Name and org.jooq.Named API for identifier handling
- Support for PostgreSQL 10
- Support for SQL Server 2017
- Support for DB2 11
- Upgraded MariaDB support for window functions, inv dist functions, WITH
- jOOU dependency updated to 0.9.3
- jOOR dependency updated to 0.9.8
- Server output (e.g. DBMS_OUTPUT) can now be fetched automatically, by jOOQ
- Code generation support for PL/SQL TABLE types
- SQL Keywords Can Now Be Rendered In Pascal Style If You Must
- Emulate PostgreSQL's ON CONFLICT clause using MERGE
https://www.jooq.org/notes/?version=3.11

You received this message because you are subscribed to the Google Groups
"jOOQ User Group" group.
To unsubscribe from this group and stop receiving emails from it, send an
For more options, visit https://groups.google.com/d/optout.

g***@gmail.com

2018-10-19 16:31:05 UTC

Permalink

I see the release notes here say that Java 10 is supported, is it just an
oversight that this page hasn't been updated to reflect this?

https://www.jooq.org/download/

Support for Java 6, 7, and 8

Lukas Eder

2018-10-19 16:41:58 UTC

Permalink

Thanks a lot for pointing that out. The website is outdated. The release
notes are correct. We'll fix that ASAP.

Post by g***@gmail.com
I see the release notes here say that Java 10 is supported, is it just an
oversight that this page hasn't been updated to reflect this?
https://www.jooq.org/download/
Support for Java 6, 7, and 8

Post by Lukas Eder
Version 3.11.0 - June 7, 2018
================================================================================
New Databases Supported
-----------------------
jOOQ Professional Edition
- Aurora MySQL Edition
- Aurora PostgreSQL Edition
- Azure SQL Data Warehouse
jOOQ Enterprise Edition
- Teradata
Implicit Joins
--------------
One of the really cool features in ORMs like Hibernate, Doctrine, and
others, is
the capability of using a relationship graph notation to access another
entity's
columns through what is often called "implicit joins".
SELECT author.first_name, author.last_name, book.title
FROM book
JOIN author ON book.author_id = author.id
We would like to be able to access those columns directly, using this
SELECT book.author.first_name, book.author.last_name, book.title
FROM book
The join is implied and should be added implicitly. jOOQ now allows for
this to
ctx.select(BOOK.author().FIRST_NAME, BOOK.author().LAST_NAME, BOOK.TITLE)
.from(BOOK)
.fetch();
When rendering this query, the implicit join graph will be calculated on
the fly
and added behind the scenes to the BOOK table. This works for queries of
arbitrary complexity and on any level of nested SELECT.
https://blog.jooq.org/2018/02/20/type-safe-implicit-join-through-path-navigation-in-jooq-3-11/
DiagnosticsListener SPI
-----------------------
https://github.com/jOOQ/jOOQ/issues/5960
The purpose of this SPI is to sanitise your SQL language, JDBC and jOOQ API
- duplicateStatements (similar SQL is executed, bind variables should be
used)
- repeatedStatements (identical SQL is executed, should be batched or
rewritten)
- tooManyColumnsFetched (not all projected columns were needed)
- tooManyRowsFetched (not all fetched rows were needed)
The great thing about this SPI is that it can be exposed to clients
through the
JDBC API, in case of which the diagnostics feature can reverse engineer your
JDBC or even JPA generated SQL. Ever wanted to detect N+1 queries from
Hibernate? Pass those Hibernate-generated queries through this SPI.
Want to find missing bind variables leading to cursor cache contention or
SQLi?
Let jOOQ find similar SQL statements and report them. E.g.
- SELECT name FROM person WHERE id = 1
- SELECT name FROM person WHERE id = 2
- SELECT name FROM person WHERE id IN (?, ?)
- SELECT name FROM person WHERE id IN (?, ?, ?)
Anonymous blocks
----------------
Many databases support anonymous blocks to run several statements in a
single
DECLARE
l_var NUMBER(10);
BEGIN
l_var := 10;
dbms_output.put_line(l_var);
END;
jOOQ now supports the new org.jooq.Block API to allow for wrapping DDL
and DML
statements in such a block. This is a first step towards a future jOOQ
providing
- Abstractions over procedural languages
- CREATE PROCEDURE and CREATE FUNCTION statements
- Trigger support
- And much more
Parser
------
jOOQ's parser support is an ongoing effort. This release has added
support for
a lot of new SQL clauses and functions from various vendors and in
various DDL
and DML statements.
The parser is now also exposed through a public website and API, where
SQL can
https://www.jooq.org/translate
This website will help further drive jOOQ API development by helping to find
missing functionality that is used in real-world SQL.
Another way to access this API is through the new org.jooq.ParserCLI command
$ java -jar jooq-3.10.0.jar -f -t ORACLE -s "SELECT * FROM
(VALUES(1),(2)) AS t(a)"
select *
from (
(
select null a
from dual
where 1 = 0
)
union all (
select *
from (
(
select 1
from dual
)
union all (
select 2
from dual
)
) t
)
) t;
Formal Java 10 Support
----------------------
jOOQ 3.11 is the first release that is formally integration tested with
Java 10.
To use jOOQ with Java 10, use the Java 8 distribution which has not yet been
modularised, but contains Automatic-Module-Name specification to be forward
compatible with future, modularised jOOQ distributions.
Additionally, package names between jOOQ, jOOQ-meta, and jOOQ-codegen
have been
cleaned up to prevent duplicate package names, and the JAXB dependency
has been
added explicitly to the various artefacts.
End of Scala 2.11 support in the jOOQ Open Source Edition
---------------------------------------------------------
Scala 2.10 and 2.11 are now only supported in the commercial distributions
Other great improvements
------------------------
- Finally, asterisks (SELECT * or SELECT t.*) are formally supported in
the API.
- Collations can now be specified on a variety of syntax elements
- The org.jooq.Comment type has been added, and DDL statements for it
- The DefaultBinding implementation has been rewritten for better peformance
- Several performance improvements in jOOQ's internals
- Many more DDL statements are supported including GRANT and REVOKE
- Support for the EXPLAIN statement
- FETCH n PERCENT ROWS and TOP n PERCENT clauses are supported
- Better org.jooq.Name and org.jooq.Named API for identifier handling
- Support for PostgreSQL 10
- Support for SQL Server 2017
- Support for DB2 11
- Upgraded MariaDB support for window functions, inv dist functions, WITH
- jOOU dependency updated to 0.9.3
- jOOR dependency updated to 0.9.8
- Server output (e.g. DBMS_OUTPUT) can now be fetched automatically, by jOOQ
- Code generation support for PL/SQL TABLE types
- SQL Keywords Can Now Be Rendered In Pascal Style If You Must
- Emulate PostgreSQL's ON CONFLICT clause using MERGE
https://www.jooq.org/notes/?version=3.11