[ ANNOUNCEMENT ] 3.15.0 release with support for R2DBC, nested ROW, ARRAY, and MULTISET types, 5 new SQL dialects, CREATE PROCEDURE, FUNCTION, and TRIGGER support and much more

92 views
Skip to first unread message

Lukas Eder

unread,
Jul 6, 2021, 10:50:01 AMJul 6
to jOOQ User Group
Version 3.15.0 - July 6, 2021
================================================================================


R2DBC
-----

What a lot of users have been waiting for: jOOQ 3.15 is reactive, thanks to the
new native R2DBC integration. Recent versions already implemented the reactive
streams Publisher SPI, but now we're not cheating anymore. We're not longer
blocking. Just wrap your R2DBC ConnectionFactory configured jOOQ query in a Flux
(or any reactive streams API of your choice), and see what happens.

  Flux.from(ctx.select(BOOK.TITLE).from(BOOK));

Both blocking (via JDBC) and non-blocking (via R2DBC) can work side-by-side,
allowing users to quickly a query between the two execution models without any
changes to the query building logic.


Projecting ROW types, ARRAY of ROW Types, and MULTISETS
-------------------------------------------------------

After having implemented standard SQL/XML and SQL/JSON support in jOOQ 3.14,
another major milestone in taking SQL to the next level is now available as an
experimental feature: Nesting collections using the standard SQL MULTISET
operator.

The operator is currently emulated using SQL/XML or SQL/JSON. The resulting
documents are parsed again when fetching them from JDBC. Future versions will
also provide native support (Informix, Oracle), and emulations using ARRAY
(various dialects, including PostgreSQL).

Imagine this query against the Sakila database (https://www.jooq.org/sakila):

var result =
ctx.select(
      FILM.TITLE,
      multiset(
        select(ACTOR.FIRST_NAME, ACTOR.LAST_NAME)
        .from(ACTOR)
        .join(FILM_ACTOR).using(ACTOR.ACTOR_ID)
        .where(FILM_ACTOR.FILM_ID.eq(FILM.FILM_ID))
      ).as("actors"),
      multiset(
        select(CATEGORY.NAME)
        .from(CATEGORY)
        .join(FILM_CATEGORY).using(CATEGORY.CATEGORY_ID)
        .where(FILM_CATEGORY.FILM_ID.eq(FILM.FILM_ID))
      ).as("films")
   )
   .from(FILM)
   .orderBy(FILM.TITLE)
   .fetch();
</pre>

You're really going to love Java 10's var keyword for these purposes. What's the
type of result? Exactly:

  Result<Record3<String, Result<Record2<String, String>>, Result<Record1<String>>>>

It contains:

+---------------------------+--------------------------------------------------+---------------+
|title                      |actors                                            |films          |
+---------------------------+--------------------------------------------------+---------------+
|ACADEMY DINOSAUR           |[(PENELOPE, GUINESS), (CHRISTIAN, GABLE), (LUCI...|[(Documentary)]|
|ACE GOLDFINGER             |[(BOB, FAWCETT), (MINNIE, ZELLWEGER), (SEAN, GU...|[(Horror)]     |
|ADAPTATION HOLES           |[(NICK, WAHLBERG), (BOB, FAWCETT), (CAMERON, ST...|[(Documentary)]|
 ...

Two collections were nested in a single query without producing any unwanted
cartesian products and duplication of data. And stay tuned, we've added more
goodies! See this article on how to map the above structural type to your
nominal types (e.g. Java 16 records) in a type safe way, without reflection!

More info here:



New Dialects
------------

We've added support for 5 (!) new SQLDialect's. That's unprecedented for any
previous minor release. The new dialects are:

- BIGQUERY
- EXASOL
- IGNITE
- JAVA
- SNOWFLAKE

Yes, there's an experimental "JAVA" dialect. It's mostly useful if you want to
translate your native SQL queries to jOOQ using https://www.jooq.org/translate,
and it cannot be executed. In the near future, we might add SCALA and KOTLIN as
well, depending on demand.

BigQuery and Snowflake were long overdue by popular vote. The expedited EXASOL
support has been sponsored by a customer, which is a great reminder that this is
always an option. You need something more quickly? We can make it happen, even
if the feature isn't very popular on the roadmap.

Many other dialects have been brought up to date, including REDSHIFT, HANA,
VERTICA, and two have been deprecated: INGRES and ORACLE10G, as these grow less
and less popular.


Drop Java 6/7 support for Enterprise Edition, require Java 11 in OSS Edition
----------------------------------------------------------------------------

We're cleaning up our support for old dependencies and features. Starting with
jOOQ 3.12, we offered Java 6 and 7 support only to jOOQ Enterprise Edition
customers. With jOOQ 3.15, this support has now been removed, and Java 8 is the
new baseline for commercial editions, Java 11 for the jOOQ Open Source Edition,
meaning the OSS Edition is now finally modular, and we get access to little
things like the Flow API (see R2DBC) and @Deprecate(forRemoval, since).

Upgrading to Java 8 allows for exciting new improvements to our internals, as we
can finally use default methods, lambdas, generalised target type inference,
effectively final, diamond operators, try-with-resources, string switches, and
what not. Improving our code base leads to dogfooding, and that again leads to
new features for you. For example, we've put a lot of emphasis on
ResultQuery.collect(), refactoring internals:

There are new auxiliary types, like org.jooq.Rows and org.jooq.Records for more
functional transformation convenience. More functions mean less loops, and also
less ArrayList allocations.

At the same time, we've started building a Java 17 ready distribution for
the commercial editions, which unlocks better record type support.


Refactoring of ResultQuery to work with DML
-------------------------------------------

With all the above goodies related to Java 8, and a more functional usage of
jOOQ, we've also finally refactored our DML statement type hierarchy (INSERT,
UPDATE, DELETE), to let their respective RETURNING clauses return an actual
ResultQuery. That means you can now stream(), collect(), fetchMap() and
subscribe() (via R2DBC) to your DML statements, and even put them in the WITH
clause (in PostgreSQL).


Massive improvements to the parser / translator use case
--------------------------------------------------------

jOOQ's secondary value proposition is to use its parser and translator, instead
of the DSL API, which is also available for free on our website:

With increasing demand for this product, we've greatly improved the experience:

- The ParsingConnection no longer experimental
- Batch is now possible
- We've added a cache for input/output SQL string pairs to heavily speed up the integration
- We're now delaying bind variable type inference to use actual PreparedStatement information. This produces more accurate results, especially when data types are not known to the parser.
- A new ParseListener SPI allows for hooking into the parser and extend it with custom syntax support for column, table, and predicate expressions.


CREATE PROCEDURE, FUNCTION, TRIGGER and more procedural instructions
--------------------------------------------------------------------

Over the recent releases, we've started working on procedural language
extensions for the commercial distributions. In addition to creating anonymous
blocks, we now also support all lifecycle management DDL for procedures,
functions, and triggers, which can contain procedural language logic.

This is great news if you're supporting multiple RDBMS and want to move some
more data processing logic to the server side in a vendor agnostic way.


Explicit JDBC driver dependencies to avoid reflection
-----------------------------------------------------

To get AOP ready, we're slowly removing internal reflection usage, meaning we're
experimenting with an explicit JDBC driver build-time dependency. This currently
affects:

- Oracle
- PostgreSQL
- SQL Server

Only drivers available from Maven Central have been added as dependency so far.


API Diff:
---------

See what's changed in terms of an API diff here:


Features and Improvements
-------------------------
#1729 - Add DSL.aggregate() and DSL.aggregateDistinct() as plain SQL AggregateFunctions
#1985 - Add support for the EXASOL database
#2620 - Add support for Google BigQuery
#3884 - Add support for the MULTISET operator
#4474 - Allow to form CTE from plain SQL or from ResultQuery
#4876 - Add Firebird 3.0 support for IDENTITY columns
#5179 - Add support for returning unique constraints from Meta Table<R>.getKeys()
#5310 - DataType.toString() should generate DDL type declaration fragment
#5507 - Add a new jooq-postgres-extensions module for PostgreSQL specific extension
#5757 - Support batch in DSLContext.parsingConnection()
#5810 - Emulate Teradata's QUALIFY clause for window function filtering
#6080 - Add support for multiple ROW nesting
#6277 - Add SQLDialect.JAVA to generate Java code from a SQL statement
#6347 - Add TableLike.get(X) kotlin operators as aliases for Table.field(X)
#6562 - Add a recursive CTE example to the manual
#6604 - Add multi Row[N] or Record[N] VALUES support
#6956 - Add support for { CREATE | DROP } TRIGGER commands
#7100 - Add <U> Field<T>.convert(Binding<T, U>), convert(Converter<T, U>), convert(Class<U>, Function<T, U>, Function<U, T>)
#7290 - Add DSL.chr(int)
#7421 - Stop rendering "FROM dual" in MySQL 8+ and MariaDB 10.4+
#7520 - Add code generator support for foreign keys in Teradata
#7536 - Implicit JOIN improvements
#7789 - Support Java 8 only in Professional and Enterprise Edition
#7900 - Add support for SQL Server style DATEDIFF(datepart, date, date)
#8166 - Add support for SELECT .. INTO <variables> for use inside statement blocks
#8230 - Add support for RAISE or SIGNAL in the procedural API
#8263 - Add syntax highlighting to /translate
#8284 - Emulate label-less iterate and leave in DB2, HSQLDB, MariaDB, MySQL
#8334 - ParsingConnection should cache frequent input / output SQL string pairs
#8469 - org.jooq.Meta should try parsing default expressions
#8495 - Avoid copying around lists and arrays in jOOQ's internals
#8500 - Review callers of Tools#field(T) in AbstractField
#8521 - Transform MySQL IN (SELECT .. LIMIT) to derived table
#8714 - Support SQL Server function SQUARE()
#8715 - Add support for the LOG10 function
#8775 - Record.get(n) etc, Javadoc could state if n starts from 0 or 1
#8821 - Add Settings.parseNamedParamPrefix to support dialect specific named parameter placeholders
#8888 - Improve HSQLDB Dual table implementation
#8973 - Create a troubleshooting page in the manual
#9038 - Add support for the PostgreSQL SPLIT_PART function
#9087 - Document CallbackExecuteListener
#9190 - Add support for CREATE FUNCTION and CREATE PROCEDURE
#9191 - Add support for DROP FUNCTION and DROP PROCEDURE
#9376 - Document <fluentSetters/> in the manual
#9472 - Add support for UUID generator functions, such as NEWID() or GEN_RANDOM_UUID()
#9627 - Add Settings.metaIncludeSystemIndexes
#9650 - Add support for the Snowflake database
#9728 - Add <comments/> configuration to allow for generating custom Javadoc on generated code
#9753 - Change DEFAULT rendering of CURRENT_DATE, CURRENT_TIME, and CURRENT_TIMESTAMP
#9767 - Built in SQL transformations
#9804 - Make TableOptions available through code generation to remaining dialects
#9854 - Add support for DB2 DIGITS() function
#9945 - Implement generated TIMESTAMP precision in code generation
#9953 - Add support for nested declarations in Firebird procedural logic
#10030 - Add a type annotation to all jOOQ API that accepts explicit string types
#10036 - Add support for BIT_AND_AGG(), BIT_OR_AGG(), BIT_XOR_AGG()
#10048 - Add logging to BatchCRUD when the number of generated SQL queries is too high
#10080 - Add a manual section about LATERAL and APPLY
#10118 - Add support for CockroachDB CREATE OR REPLACE VIEW
#10150 - Support JDK 14, 15, 16
#10175 - Add support for H2 and PostgreSQL array functions
#10181 - Improve parser performance
#10229 - Convert should be able to convert types into any type with a single argument constructor
#10243 - Add ParseListener SPI to parse custom syntax
#10287 - Add <pojosAsJavaRecordClasses/> to allow for generating Java POJOs as JDK records instead
#10349 - Add more Settings to enable / disable DefaultRecordMapper mapping algorithms
#10437 - Get HANA dialect support up to date
#10505 - Split up manual's JOIN section into different subsections
#10514 - Improve Settings.parseWithMetaLookups
#10522 - Emulate UPDATE .. SET row = (SELECT ...) using UPDATE .. FROM for uncorrelated subqueries
#10528 - Improve procedural language abstraction API
#10546 - Add { Schema, Meta } . { getUniqueKeys(), getForeignKeys(), getIndexes() }
#10551 - Add support for Apache Ignite
#10572 - Various parser bugs / missing features
#10626 - Add support for CockroachDB CREATE SCHEMA et. al
#10645 - Add SQLDialect.POSTGRES_13
#10690 - Use some newer JDK API when creating a distribution for JDK 17
#10724 - Get Redshift dialect support up to date
#10745 - SQLDialect Javadoc should explain the distinction between commercial and OSS dialects
#10775 - Add Rows.toRowList() and Rows.toRowArray() methods to create Row[N] arrays and lists
#10801 - Add JavaGenerator.printDaoConstructorAnnotations() to allow for custom annotations in generated DAO constructors
#10807 - Meta.migrateTo(Meta) should not produce any diff when timestamp default precision is specified
#10827 - Add a DSL.currentCatalog() function
#10829 - Exclude synthetic fields and keys from diff
#10844 - Implement MetaImpl.getSequences()
#10851 - Add <visibilityModifier/> to allow for generating explicit / implicit public visibility, as well as internal in KotlinGenerator
#10873 - Add alternative DSL.key(...).value(...) syntax to produce JSONEntry
#10883 - Add Table.getUniqueKeys()
#10893 - Add Javadoc link from SQLDialect to the new version support matrix page
#10898 - Add Settings.metaIncludeSystemSequences
#10899 - Add <includeSystemSequences/> to code generator configuration
#10909 - Enhance MCVE template to also include KotlinGenerator and ScalaGenerator out-of-the-box
#10913 - Add Database.getPrimaryKeys() and overloads to jOOQ-meta
#10927 - Add code generator support for SQLite CHECK constraints
#10932 - Support MySQL 8.0.16 CHECK constraints
#10936 - Add DataType.null_() and notNull() as synonyms for nullable(boolean)
#10952 - Add a DDL textarea to /translate
#10953 - Add additional JSONFormat options to optimise formatting of JSON in the presence of SQL/JSON result set content
#10962 - Remove Disqus from manual
#10963 - Parse DEFAULT nextval('<id>_seq'::regclass) as Serial data type
#10990 - Add support for MERGE in Informix
#10998 - Add <enumsAsScalaSealedTraits/> to let ScalaGenerator generate Java enums
#11002 - Remove the outdated manual section about dependencies
#11009 - Add support for the MySQL FIELD() function
#11023 - Throw more explicit DataTypeException when Convert fails to convert between JSON/JSONB/XML and a user-defined type
#11031 - Extract common API from Cursor | Record | RecordType | Result | Row | TableLike | UDT to new Fields type
#11061 - Parser should look up data types for bind variables from context
#11063 - Add TableOptions.function(String)
#11070 - Propagate type nullability through API
#11074 - Parser should be able to replace expressions for bind variables
#11076 - Add support for SQLDialect.MYSQL_5_6
#11082 - DSL.currentTimestamp(int) is missing
#11089 - Add parser support for COERCE(x AS <data type>)
#11091 - Avoid calling DSL.nullSafe() and similar all over the DSL API, move the calls to QueryPart constructors
#11093 - Use instance methods in parser implementation
#11097 - Add single argument DSL.function() overload
#11107 - Parser should parse 3-argument Oracle INSTR function
#11123 - Add Settings.mapConstructorProperties to allow for opting out of reading the ConstructorProperties annotation in DefaultRecordMapper
#11125 - Let AbstractQueryPart::configuration return Tools.CTX::configuration
#11131 - Make functional interfaces F0, F1, F2 public, internal, deprecated
#11136 - Add Name.qualifierQualified() to check if a Name's qualifier (if any) is qualified as well
#11154 - Add Javadoc to Map producing API (fetchMap(), fetchGroups()) about map iteration order guarantees
#11155 - Add documentation for using LiquibaseDatabase with Liquibase's YAML or JSON formats
#11157 - Add support for COVAR_SAMP and COVAR_POP aggregate and window functions
#11161 - Add formal support for SQL Server PIVOT clause
#11172 - Add support for SQLite's fts3 and fts4 virtual tables
#11176 - Add <includeSystemTables/> to exclude SQLite virtual table implementation tables from code generation
#11177 - Add further vendor-specific <includeSystemTables/> implementations
#11180 - Clarify unused logger warning message about what is obsolete
#11182 - Generate DAO.fetchByXYZ() methods for embeddable types
#11183 - Generate a record constructor taking a generated POJO
#11187 - Add DAO.fetch(Field<Z>, Collection<? extends Z>) overload
#11189 - Improve generated Javadoc formatting
#11190 - UPDATE .. RETURNING cannot be used Reactively
#11192 - Add Javadoc remark to code generation flags available to commercial editions only
#11194 - Add code generation configuration for Javadoc line wrapping
#11202 - Add documentation for the QUALIFY clause
#11231 - Support parsing Access ASC() or Firebird ASCII_VAL() functions
#11237 - Add SafeVarargs annotation to DSL.greatest() and DSL.least()
#11243 - Emulate FOR UPDATE .. WAIT n using SET LOCAL LOCK_TIMEOUT in PostgreSQL dialects
#11246 - Add support for TRIGGER pseudo columns DELETING, INSERTING, UPDATING
#11250 - Add a language context to the ParserContext and RenderContext
#11252 - Add support for SET LOCAL statements
#11253 - Add some convenience API for locally overriding Context.paramType(), Context.qualify(), and other flags
#11254 - Add lambda constructor in CustomField, CustomCondition, CustomQueryPart
#11269 - Add CreateTableConstraintStep.primaryKey(), unique(), check() convenience methods
#11279 - Support ALTER TABLE .. RENAME INDEX .. TO .. in SQL Server
#11318 - Add native support for the standard JSON function RETURNING clause
#11323 - Add HSQLDB procedural language support
#11333 - Add parser support for hash style comments (#) in MariaDB, MySQL
#11336 - Emulate CREATE OR REPLACE in MySQL using compound statements
#11338 - Add convenience for common bracing / formatting / indenting SQL rendering
#11344 - Add Context.declareParameters()
#11356 - Add support for CALL in procedural languages
#11358 - Add some CSS syntax highlighting to all <code> content in the manual
#11359 - Add support for INFORMIX procedural language
#11360 - Add CustomStatement
#11367 - Refactor internal ScopeMarkers functionality
#11369 - Emulate using expressions in Db2 DECLARE .. DEFAULT statements
#11373 - Add ParamOrVariable<T>, a common super type of Param<T> and Variable<T>
#11374 - Wrong algorithm to aggregate local variable declarations at the beginning of a block
#11379 - Update RecordListener documentation to explain this is about UpdatableRecords only, not bulk DML
#11382 - Add parser support for <explicit table>
#11383 - Add Configuration.commercial()
#11389 - Add parser support for PL/SQL style variable declarations in function / procedure headers
#11390 - Support parsing RETURN statement
#11393 - Add CockroachDB ENUM type support
#11394 - Support parsing Teradata's zeroifnull()
#11402 - Support parsing Teradata's UPDATE .. FROM .. SET syntax
#11403 - Support parsing Teradata's undocumented SELECT .. GROUP BY .. WHERE clause ordering
#11405 - Emulate procedural SELECT .. INTO variables in T-SQL
#11406 - Field.as(unquotedName("@i")) should produce T-SQL aliasing syntax
#11408 - Procedural DECLARE should support declaring multiple variables, for convenience
#11410 - Support HSQLDB's procedural destructuring assignment
#11420 - Support Parsing the MySQL version of the VALUES constructor
#11421 - Parser should throw exception if not all rows have the same degree in a VALUES constructor
#11422 - Add parser support for JSON_ARRAYAGG() and JSON_OBJECTAGG() as window functions
#11429 - Add missing parser support for EXECUTE IMMEDIATE
#11430 - Add parser support for ALTER TABLE .. DROP .. DROP syntax
#11432 - Support parsing Db2 style LISTAGG() without WITHIN GROUP clause
#11433 - Add parser support for ALTER TABLE .. ADD .. ADD syntax
#11436 - Support parsing UPDATE .. SET (row) = (row | subquery)
#11449 - Support parsing SQLite MIN() and MAX() functions
#11450 - Support parsing SQLite's IS [ NOT ] predicate
#11452 - Add parser support for MySQL's DATE_ADD and DATE_SUB functions
#11458 - Add support for the ANY_VALUE() aggregate function
#11461 - MetaTable does not contain table COMMENT (REMARKS)
#11470 - Add support for the CORR aggregate functions
#11472 - Document immutability of CSVFormat and related types
#11481 - Stop using the deprecated JSON_MERGE function in MariaDB 10.4+ and MySQL 8.0.19+
#11491 - Add a Settings.forceIntegerTypesOnZeroScaleDecimals
#11492 - Add jbang example to the manual
#11494 - Add parser support for OCTET_LENGTH alternative names
#11499 - [jOOQ/jOOQ#11492] Add jbang catalog
#11502 - Unknown table identifier when trying to look up CustomTable or TableImpl whose Schema doesn't reference its tables
#11504 - Default[UnsignedType]Bindings should delegate to integer bindings, rather than implement their own
#11507 - Add Log.isWarnEnabled()
#11508 - Emulate procedural RETURN (SELECT ..) statement where not supported
#11512 - ParsingConnection should infer bind variable type from PreparedStatement calls
#11520 - Add CallbackXYZListener implementations, and static convenience API on XYZListener
#11525 - Upgrade scala version to 2.13.5
#11530 - Add Configuration.setAppending() and Configuration.deriveAppending() methods to create derived configurations by appending listeners
#11531 - Add jsonEntry(X, Select<?>) overloads
#11536 - Document pom.xml plugin inheritance mechanism
#11543 - Emulate FOR UPDATE .. WAIT n using SET SESSION innodb_lock_wait_timeout in MySQL dialects
#11547 - Emulate statistical aggregate functions
#11549 - Add startup tips to be logged with the jOOQ logo
#11559 - Add parser support for ADD_YEARS, ADD_MONTHS, ADD_DAYS, ADD_HOURS, ADD_MINUTES, ADD_SECONDS
#11567 - Add Database.getSources(): Map<Definition, String> as an alternative way to produce source code for generated objects
#11572 - Add versioned dialects for COCKROACHDB 20, 21
#11578 - Add DSL.inlined(Field<T>): Field<T>
#11585 - Remove unnecessary restriction from sequences and domains "Must provide a qualified name of length 1 or 2"
#11587 - Fix ordering of TOP_LEVEL_CTE
#11601 - Add a manual section for trueCondition(), falseCondition(), and noCondition()
#11602 - Support parsing WITH in derived tables or scalar subqueries
#11603 - Add parser support for WITH nested inside WITH
#11606 - DefaultRenderContext(RenderContext) constructor should only copy flags
#11616 - Missing DB2 and Derby @Support on DROP SCHEMA .. RESTRICT
#11623 - Refactor a few internal checked exception throwing functional interfaces
#11626 - Add DefaultDataType.getDataType(SQLDialect, int) to lookup JDBC types
#11633 - ParsingConnection should batch translated statements without having to re-translate the statement several times
#11640 - Use ojdbc8 API internally
#11641 - Emulate SPLIT_PART
#11642 - Emulate OVERLAY in H2 using INSERT
#11645 - Add procedure support in the VerticaDatabase
#11647 - Add MySQL SUBSTRING_INDEX() support
#11648 - Add Db2, Derby, H2 support for POSITION(in, search, startIndex) via LOCATE
#11649 - Add parser support for Db2's LOCATE_IN_STRING function
#11650 - Get SQLDialect.VERTICA up to date
#11654 - Add code generation support for CHECK constraints in Vertica
#11655 - Emulate statistical window functions in Vertica
#11656 - Add support for a TO_HEX(number) function
#11660 - Emulate CONNECT BY LEVEL < x and CONNECT BY ROWNUM < x
#11666 - Expand unqualified asterisk when combined with other projection expressions and when not supported
#11672 - Function and QueryPartCollectionView formatting improvements
#11674 - Add native support for NVL2 where supported
#11684 - Add a CacheProvider SPI to allow for overriding the default ConcurrentHashMap
#11688 - Remove experimental remarks from all parser related API
#11694 - Support parsing TO_DATE(string) and TO_TIMESTAMP(string)
#11699 - Support parsing Oracle comparison operators with whitespace in between
#11700 - Add R2DBC support
#11707 - SQUARE() should be emulated using POWER() if the argument is not a SimpleQueryPart
#11711 - Use floating point literals for inline DOUBLE, FLOAT, and REAL literals
#11712 - Support parsing the ** exponentiation operator
#11718 - Annotate DSL API with @CheckReturnValue to help detect when calling execute() etc is forgotten
#11719 - Add support for TO_DATE() in SQL Server
#11729 - Create a Java 17 distribution
#11737 - Add dialect version support for H2
#11738 - Add optional, provided dependency on mssql-jdbc, ojdbc, pgjdbc to avoid reflection
#11743 - Support parsing Teradata cast syntax
#11744 - Support the Teradata DATE function
#11755 - Extract AttachableQueryPart from Query
#11757 - Add Settings.renderCoalesceToEmptyStringInConcat
#11763 - Upgrade shaded jOOR dependency to 0.9.14
#11772 - Convert should support conversions between ByteBuffer and byte[]
#11774 - Add a <priority/> to <forcedType/>
#11778 - DefaultRecordMapper should reflect on Class.getRecordComponents()
#11779 - Upgrade XJC to com.sun.xml.bind:jaxb-xjc:2.3.4
#11780 - Include identity-generated system sequences in PostgreSQL generated code
#11784 - Add code generation support for Firebird 3.0 stored functions
#11787 - Add an <includeSystemUDTs/> flag to turn on/off the generation of system UDTs
#11788 - Add QualifiedRecord and RecordQualifier to unify the Table|UDT and TableRecord|UDTRecord type hierarchy
#11794 - Improve MappingException message when no RecordMapper implementation could be found
#11799 - Refactor some internals to re-use a new functional mapping method
#11800 - Fields.field() methods should add better documentation about what it means when null is returned
#11801 - Move some Tools content such as Tools.Cache to the top level
#11803 - Support = ANY and != ALL quantified comparison predicates of degree > 1 for MySQL
#11804 - Add Records class with common record mapping utilities
#11808 - Make sure the SQL in MetaSQL is dialect version specific
#11809 - Add SQLDialect.isVersioned()
#11810 - RecordMapper<R, E> should extend Function<R, E>
#11812 - Let Row[N]<T1, T2, ..., TN> extend SelectField<Record[N]<T1, T2, ..., TN>>
#11813 - Add Row[N]<T1, T2, ..., TN>.mapping(Class<R>, Function[N]<T1, T2, ..., TN, R>) to create a SelectField<R> reference
#11815 - Change DSLContext.fetchValue(Field<T>) to DSLContext.fetchValue(SelectField<T>)
#11816 - Add missing ConstraintTypeStep.primaryKey(Collection<? extends Field<?>>) and related overloads
#11817 - Add Converter.from(Class<T>, Class<U>, Function<T, U>) and Converter.to(Class<T>, Class<U>, Function<U, T>) to create one-way converters
#11821 - Support parsing Teradata INSERT without VALUES
#11822 - Translator should offer specifying a default schema / search path
#11826 - Remove serialVersionUID from jOOQ's internals
#11829 - Add DataType.row() to track nested ROW types and allow access to their Field<?>[]
#11831 - Support parsing array(select)
#11838 - Add Settings.namePathSeparator
#11843 - Add parser / render support for COUNTIF()
#11844 - Support parsing Teradata eq, ne, gt, ge, lt, le operators
#11845 - Transform Teradata style implicit join syntax in the parser
#11850 - Get SQLDialect.TERADATA up to date
#11851 - Add Settings.renderImplicitWindowRange handling different default window RANGE clause defaults
#11854 - Generate identity column information in Teradata
#11855 - Support parsing CT as Teradata alias for CREATE TABLE
#11860 - Generate FOREIGN KEY meta data in Teradata
#11861 - Emulate LISTAGG in Teradata using XMLAGG
#11863 - Add SingleStore native support for multi row inserts
#11871 - Document missing ExecuteListener::resultEnd event when ResultQuery::collect and other methods are used
#11879 - Define rawtype API compatibility strategy
#11880 - Implement improved INSERT .. ON DUPLICATE KEY UPDATE emulation via MERGE
#11884 - Refer to DSL.val() in Javadoc to raise awareness
#11897 - ClassCastException when calling Convert.convert(Object, Class) with a collection
#11905 - Update Hibernate dependency in jooq-meta-extensions-hibernate
#11908 - Use the @Deprecate(forRemoval = true, since = "...") flags in the API
#11925 - Emulate DELETE .. USING where some equivalent native syntax is available
#11926 - Add parser support for DELETE .. JOIN and UPDATE .. JOIN
#11927 - Add a Javadoc remark about performance to all the fetch() methods that map results
#11931 - Support translating DATEADD from Snowflake to BigQuery
#11932 - CLI APIs should log more helpful error messages on NoClassDefFoundError
#11938 - Support parsing Snowflake style DATEADD() function with date part as string literal
#11943 - Add native OFFSET support to Db2 11.1
#11960 - Add support for Redshift YEAR TO MONTH interval literals
#11961 - Get Redshift dialect up to date
#11964 - Add new DefaultBinding(Binding<T, U>) constructor
#11979 - Add Configuration.deriveSettings(Function<Settings, Settings>)
#11985 - Add HANA support for REGEXP_REPLACE
#11992 - Pull up Fields super type declaration from Select<R> to ResultQuery<R>
#12002 - Support parsing HSQLDB CALL <expression> statement
#12011 - BindingGetResultSetContext<T> should offer field(): Field<T> methods
#12028 - Add MULTISET_AGG aggregate and window function support
#12030 - Support creating MULTISET predicates
#12035 - Upgrade kotlin dependency to 1.5
#12042 - Improve error message in MockFileDatabase from "Invalid SQL" to something more descriptive
#12043 - Add DataType.isMultiset()
#12046 - Add support for XMLSERIALIZE
#12053 - Add disclaimers about mocking also to Javadoc
#12055 - Highlight new manual menu items in each version
#12061 - Improve XML path notation in section jooq-in-7-steps-step3
#12065 - Add manual section about scalar subqueries
#12071 - Add an internal means of ad-hoc table mapping
#12079 - Avoid auxiliary in-memory table when emulating DML RETURNING in SQL Server, if not strictly necessary
#12092 - MySQL queries running GROUP_CONCAT() or JSON_ARRAYAGG() should auto-increase the default group_concat_max_len
#12093 - Add <includeExcludePackageRoutines/> to let code generator <includes/> and <excludes/> match package procedures and functions
#12110 - Move Sakila database to own repository


Breaking changes
----------------
#3185 - Let InsertResultStep<R>, UpdateResultStep<R>, DeleteResultStep<R> extend ResultQuery<R>
#7863 - Link Oracle %ROWTYPE references to their corresponding table types
#9280 - Unsupport Scala 2.10
#9288 - Offer Result.intoMap(), intoGroups(), intoSet() functionality as Collector
#9715 - Render DSL.currentDate() as TRUNC(CURRENT_DATE) in Oracle
#10803 - Remove jOOQ-refaster from distributions
#10809 - Dialect specific data type is reported from Meta, instead of SQLDataType
#10884 - Change jOOQ-meta Relations.getUniqueKeys() to return unique keys only
#10918 - XMLasDOMBinding and AbstractXMLasObjectBinding should implement Binding<XML, T>, not Binding<String, T>
#10937 - Add Settings.renderDefaultNullability
#11053 - Pull up PostgresDSL.array() to DSL.array()
#11115 - Table.getSchema() should not return the generated schema for aliased generated tables
#11164 - Remove ResultQuery::fetchLater and ResultQuery.fetchLazy(int)
#11196 - Drop support for Java 6 and 7 in jOOQ Enterprise Edition
#11207 - AbstractBinding empty base implementations should throw exception
#11218 - KotlinGenerator generates Record[N]<T1, T2, ..., TN> for PK types in DAOs, instead of Record[N]<T1?, T2?, ..., TN?>
#11242 - Remove deprecated on(Boolean), where(Boolean), having(Boolean), etc
#11286 - Use org.jooq.Meta to discover SQLite primary key, unique key, and foreign key names in code generator
#11495 - Remove pre 3.5 deprecated API
#11498 - DSLContext.connection() and connectionResult() shouldn't produce null Connection when detached
#11511 - Stop casting SQLDataType.OTHER to VARCHAR
#11625 - GeneratorStrategy references package-private AbstractGenerator.Language class
#11720 - XResultStep<R> should not extend X<R> for X<R> = Insert<R> | Update<R> | Delete<R>
#11802 - Add new Transformation enum for Settings with values ALWAYS, WHEN_NEEDED, NEVER
#11892 - Add Settings.fetchIntermediateResult
#11901 - Implement more optimal ResultQuery.forEach() method
#11980 - MockConfiguration set() and derive() calls return delegate instead of MockConfiguration
#12023 - JSONB equals, hashCode, toString() should be formatting agnostic


Deprecations
----------------
#8611 - Some MySQL encryption functions were removed in MySQL 8.0.x
#10796 - Deprecate the empty dialect specific DSL classes
#11092 - Deprecate DSL.nullSafe() and related protected methods, and move them to Tools
#11129 - Log a warning when users call deprecated Param.setValue(), setConverted(), setInline()
#11329 - Deprecate XYZFinalStep types
#11505 - Deprecate DateToLocalDateConverter, TimeToLocalTimeConverter, TimestampToLocalDateTimeConverter
#11506 - Log deprecation warning when Serialization of jOOQ API is triggered
#11515 - Deprecate INGRES dialect
#11618 - Deprecate JDBC41Connection, JDBC41Statement, JDBC41ResultSet
#11797 - Deprecate Oracle 10g support
#11898 - Deprecate org.jooq.tools.Convert, the public API
#11902 - Deprecate RecordHandler


Bug Fixes
---------
#2815 - Bad SQL rendered in MySQL, when selecting from DUAL with ORDER BY
#3619 - Result.intoGroups() and intoMap() do not run through RecordListener
#5851 - VALUES constructor generates wrong SQL if one row contains a null bind variable
#5865 - Avoid allocation of new internal ConvertAll instances
#6252 - Infinity values not correctly escaped with PostgreSQL
#7201 - Incorrect emulation of SELECT DISTINCT .. FETCH NEXT .. ROWS WITH TIES
#7648 - Issue with insertion with DEFAULT value with H2 and onDuplicateKeyIgnore
#7721 - OFFSET .. FETCH should not be emulated in Oracle 18c anymore even when projection has duplicate column names
#8509 - Equals on fields not symmetric
#8554 - Improve documentation regarding nullable forced types
#8762 - Improve performance of implicit join algorithm
#8875 - Field.getDataType().defaultValue() value is 'null' instead of actual value.
#8917 - INSERT .. RETURNING emulation doesn't work on SQL Server when returning expressions or aliases
#9067 - StackOverflowError generating code from Postgresql XML schema with ARRAY columns
#9206 - Wrong implementation of DayToSecond#equals() and YearToMonth#equals()
#9475 - Support parsing number literals with exponent
#9553 - Parser cannot parse WITH in EXISTS() and other subqueries
#10019 - Fetched result is not logged when using collect(), only with fetch()
#10245 - Blocking subscriber.onComplete called after subscriber.onError
#10527 - Fix known limitations of embeddable types
#10529 - Ignore <records>false</records> for UDTRecords
#10668 - Parser should ignore TRUNC() call when parsing TRUNC(CURRENT_DATE) or TRUNC(SYSDATE)
#10697 - Address known issues of Settings.transformTableListsToAnsiJoin
#10699 - Parser cannot parse set operations combining SELECT * with SELECT <column list>
#10716 - Fix known issues of Settings.transformRownum
#10760 - Wrong emulation of INSERT .. RETURNING for embeddables on SQL Server
#10761 - KotlinGenerator produces invalid syntax for PostgreSQL enum types
#10762 - Wrong XSD schema in org.jooq.Constants#XSD_CODEGEN in version 3.14.0
#10767 - Kotlin code generator generates Record with invalid kotlin syntax when a column is named "value" and <recordsImplementingRecordN/> is true
#10768 - Compilation errors in KotlinGenerator generated classes when tables have array types
#10769 - Cannot convert from UUID to JSON in H2's JSON_OBJECT() and related functions
#10771 - KotlinGenerator creates incorrect @Generated annotation
#10774 - Remove @Nullable annotation from ResultQuery.fetchSingleInto(Class) and Record.into(Class)
#10778 - Fix compilation errors for Oracle Packages, UDTs, ArrayRecords, Queues, Links in KotlinGenerator
#10779 - Compilation error in KotlinGenerator generated DAOs for data type TINYINT
#10782 - Wrong code generated for <jpaAnnotations/> Table annotations with KotlinGenerator
#10783 - KotlinGenerator does not annotate properties with <jpaAnnotations/>
#10787 - KotlinGenerator and ScalaGenerator don't produce correct POJO.toString(), equals(), hashCode() methods for array types
#10788 - DSL.jsonbArray() generates json_build_array() call in PostgreSQL, instead of jsonb_build_array()
#10793 - Most package-info Javadocs refer to Sybase ASE
#10797 - Applying a forcedType prevents identity(true) from being generated
#10804 - NullPointerException when calling MetaImpl.snapshot() on a PostgreSQL schema with function based indexes
#10805 - Kotlin POJOs with array properties must implement equals() and hashCode()
#10808 - Converter using primitive types fails when used in UDT array in PostgreSQL
#10812 - Compilation error in KotlinGenerator generated code when <enumConverter/> flag is turned on
#10813 - Meta.migrateTo(Meta) produces constraint rename operations for MySQL PRIMARY KEY constraints
#10817 - MetaImpl should not produce explicit DEFAULT NULL value
#10821 - Code generation fails in PostgreSQL when grants for enum types are missing
#10822 - Meta.migrateTo(Meta) should not produce DROP SCHEMA "" calls
#10824 - Stop using information_schema.table_constraints in PostgresDatabase
#10825 - Missing INFORMIX dialect in CTE support annotations
#10828 - Record.get(Field) doesn't work for embeddable table fields when non field-replacing embeddables are projected explicitly
#10830 - There should be no diff between implicit and explicit ASC ordering in index definitions
#10834 - Wrong columns requested from Connection.prepareStatement(String, String[]) when running INSERT .. RETURNING with embeddables in HSQLDB and Oracle
#10835 - KotlinGenerator should produce open classes
#10837 - KotlinGenerator produces invalid syntax for enums with special characters
#10839 - DefaultConverterProvider should be Serializable
#10849 - Deadlock on lazy initialisation of Tables in Scala
#10852 - Parser fails to parse schema qualified type in CREATE TYPE .. AS ENUM commands
#10856 - Avoid querying information_schema.columns.datetime_precision in older versions of MySQL 5.7
#10858 - <includeSystemIndexes/> doesn't work correctly on MySQL 8.0.22
#10864 - Don't create a diff between DECIMAL and NUMERIC types, where they are just aliases
#10867 - KotlinGenerator should quote identifiers containing $
#10869 - KotlinGenerator should escape $ in string literals
#10871 - Add `yield` to kotlin keywords for use in KotlinGenerator
#10877 - Compilation error in ScalaGenerator generated code when table has column "CLASS"
#10882 - Code examples contain excess or missing semi colons
#10887 - ALTER TABLE code examples shows wrong multi column addition syntax
#10889 - Meta.filterPrimaryKeys() is not implemented correctly
#10895 - Attaching configuration to unbound ResultQuery does not work when executed async
#10900 - Compilation error in KotlinGenerator generated code, when OTHER data type columns have a default value
#10904 - KotlinGenerator produces compilation error in generated interfaces when <jpaAnnotations/> is set
#10910 - java.lang.ClassCastException: class java.lang.Class cannot be cast to class java.lang.reflect.ParameterizedType when custom data type extends List
#10915 - Wrong code generated by KotlinGenerator for <validationAnnotations/>
#10920 - PostgreSQL supports XMLTABLE only after version 10
#10923 - KotlinGenerator produces compilation errors in UDT Records when <recordsImplementingRecordN/> is true
#10931 - LIMIT without OFFSET is emulated using window functions when value is not a bind variable
#10934 - Unnecessary ORDER BY (SELECT 0) clause generated in SQL Server when using TOP
#10939 - Wrong SQL generated for IIF() emulation in MySQL
#10940 - <includeSystemCheckConstraints/> fails with missing FROM-clause entry for table "alias_18649163" on PostgreSQL
#10944 - Code generator warning message should refer to deprecated <customType/> only if customType configuration is present
#10949 - Missing data type display in ParserCLI help listing
#10951 - JPAConverter may cause DataTypeException if it does not detect the proper <T, U> types using reflection
#10954 - Unqualified field lookup in ON DUPLICATE KEY UPDATE clause doesn't work
#10956 - Add missing documentation about throwing of DataDefinitionException in relevant API
#10964 - Parser should support plural form of DatePart where applicable
#10968 - Ambiguous field identifier when parsing unions with unqualified columns and parseWithMetaLookups
#10970 - Unknown field identifier when parsing ORDER BY clauses referencing field aliases with parseWithMetaLookups
#10972 - jOOQ-checker does not work with error prone 2.4.0
#10974 - Support ARRAY_AGG in H2
#10979 - XMLDatabase does not produce parameters for overloaded routines
#10983 - Wrong Oracle style to ANSI JOIN transformation result, depending on predicate order
#10989 - Wrong SQL generated for INSERT .. SELECT .. ON DUPLICATE KEY IGNORE emulation using NOT EXISTS
#10992 - Wrong SQL generated when outer and correlated subquery share implicit join path
#10997 - Compilation error in KotlinGenerator generated code when enum literals conflict with modifier keywords
#11000 - Parser cannot look up column from tables by same name from different schemas
#11011 - Subquery IS [ NOT ] NULL predicate should avoid RVE emulation for degree = 1
#11014 - JSON_TABLE emulation in PostgreSQL broken
#11016 - Kotlin POJO generator produces wrong equals/hashCode for binary types
#11017 - KotlinGenerator should generate equals(other: Any?), not equals(obj: Any?) on pojos
#11021 - Avoid synthetic ORDER BY clause in window functions if not strictly necessary
#11022 - The NAME keyword in XMLELEMENT(NAME <name>) should be optional for the parser
#11025 - Wrong variable binding for boolean values in Oracle and Db2 JSON_OBJECT(), JSON_ARRAY() and others
#11032 - Compilation errors for <implicitJoinPathsToOne/> when referenced table is called RECORD_TYPE
#11041 - Bug in documentation for JSON_TABLE
#11042 - Add support for parsing INSERT .. WITH .. SELECT
#11043 - NullPointerException when parsing WITH .. INSERT .. SELECT without explicit INSERT column list
#11045 - Support parsing table aliases in DELETE statements
#11047 - Code generator does not produce indexes for quoted identifiers in PostgreSQL
#11050 - Parser doesn't support derived column lists in MERGE
#11051 - DSL.array(Select) produces bad formatting
#11055 - RenderQuotedNames.ALWAYS does not work correctly for stored functions
#11056 - Wrong nullability annotations on Parser.parseSelect() and others, when parsing blank strings
#11057 - KotlinGenerator should generate kotlin.Deprecated annotation instead of java.lang.Deprecated
#11062 - Remove deprecated Param.setValue(), setConverted(), setInline() calls from manual
#11066 - Tests failed for jooq-spring-boot-example
#11078 - Override CatalogImpl.equals()
#11086 - Wrong SQL generated when DomainDataType is loaded before base SQLDataType for SQLDialect.DEFAULT
#11095 - KotlinGenerator should take ParameterDefinition nullability into consideration
#11101 - Misleading error message when something goes wrong in the code generator
#11103 - NullPointerException when custom JavaGenerator subclasses don't call JavaWriter.printPackageSpecification()
#11105 - NullPointerException when GenerationTool is not properly initialised
#11116 - Cache implicit join path references
#11118 - Nested records produced by DefaultRecordMapper do not pass through RecordListener lifecycle
#11132 - ParseWithMetaLookups produces wrong projection on self join
#11134 - ParseWithMetaLookups looks up columns in Meta that cannot possibly appear in query
#11139 - ParseWithMetaLookups propagates wrong type from derived table
#11143 - ParserWithMetaLookups reports ambiguous column in correlated subquery, when there is none
#11148 - Regression calling Record1<JSON>.into(OtherTableRecord)
#11150 - Omitting parts of the foreign key in onKey(TableField…) doesn't produce the expected result
#11165 - Converter should use Jackson kotlin module if available when mapping JSON to kotlin data classes
#11166 - Wrong SQL generated for Informix STDDEV_SAMP and VAR_SAMP
#11168 - DataType.convert(Object...) and convert(Collection<?>) don't work for converted data types
#11179 - Compilation errors in generated DAOs when embeddables use <replacesFields/>
#11185 - Compilation errors in generated embeddable pojos if the embeddable is located in a "synthetic" schema
#11191 - Generated code of a routine with TIMESTAMP parameter has too little precision
#11200 - Multithread deadlock: org.jooq.impl.AbstractField references subclass org.jooq.impl.Val in static initializer
#11201 - MetaTable::getReferences and MetaUniqueKey::getReferences do not take into account inverseSchemaCatalog
#11213 - Error mapping a jsonObject field: Cannot convert from LinkedHashMap
#11216 - JDBCUtils.dialect() should recognise MariaDB versioned SQLDialect
#11220 - Manual produces wrong Javadoc link for java.beans package
#11223 - Prevent parsing the same flag twice in CREATE SEQUENCE and ALTER SEQUENCE
#11224 - DROP TEMPORARY TABLE doesn't generate TEMPORARY keyword in MariaDB
#11226 - Broken JDK Javadoc links in the PDF version of the manual
#11228 - Settings.isMapConstructorParameterNamesInKotlin doesn't work for kotlin inline classes
#11233 - Parser throws IllegalArgumentException instead of ParserException when date_trunc() is parsed with invalid DatePart
#11235 - Parser fails when union subquery contains correlated subquery
#11238 - FILTER or OVER clause does not work on JSON_ARRAYAGG() or JSON_OBJECTAGG() functions in H2, MySQL, and PostgreSQL style dialects
#11239 - Generated order of check constraints does not respect Database::getOrderProvider
#11244 - SelectQuery.setForUpdate and similar methods do not clear flag when value is false
#11247 - VariableImpl should render qualified name
#11255 - Meta.getTables() does not include PostgreSQL foreign data wrapper tables
#11258 - NullPointerException in MetaImpl.snapshot() when foreign key column order doesn't match unique key column order
#11259 - NullPointerException when using table valued function without explicit parameters
#11261 - Interpreter cannot find unique key if foreign key references columns in different order
#11265 - Internal DataKey.DATA_PREPEND_SQL functionality should be cumulative
#11270 - Wrong support annotation for FIREBIRD ALTER TABLE .. RENAME
#11273 - Behavior of MockResultSet.close() differs from ResultSet.close() javadoc
#11275 - NullPointerException when using InsertSetStep.set(Map) on plain SQL table with plain SQL field names
#11277 - Wrong Support annotation for Derby DROP { INDEX | TABLE } IF EXISTS
#11280 - Add native support for CREATE INDEX .. INCLUDE in Db2
#11281 - Wrong SQLSTATE handled in Db2's CREATE INDEX IF NOT EXISTS
#11284 - Wrong emulation of CREATE UNIQUE INDEX .. INCLUDE
#11287 - NullPointerException in AbstractMeta.copyFK for SQLite when a foreign key references a unique key
#11290 - Parser parses PRIMARYKEY as PRIMARY KEY
#11292 - AbstractMeta.getForeignKeys() and other key / index producing methods don't handle namespacing correctly for named keys
#11295 - POSITION(in, search, startIndex) emulation returns wrong result when search was not found
#11299 - SQLite's DSL.extract() emulation should render an explicit CAST(STRFTIME(...) AS INT)
#11302 - Wrong Support annotation on ALTER TABLE .. RENAME CONSTRAINT
#11304 - ExecuteContext.exception() should accept null exceptions and translate them to an unspecified DataAccessException
#11307 - PostgreSQL MetaImpl based DataTypes are missing length of array element type
#11309 - ArrayDataType.toString() should indicate that it's an array type
#11317 - Wrong documentation of RenderQuotedNames.EXPLICIT_DEFAULT_UNQUOTED
#11319 - JDBCDatabase produces empty string as default value everywhere
#11325 - PostgreSQL routines with long names are excluded by code generator
#11334 - Field.getDataType(Configuration) resets nullability
#11341 - intoXML() throws NPE exception
#11343 - Simplify JSONConverterProvider example in the manual
#11345 - Memory leak regression in DefaultDataType cache
#11347 - Wrong syntax generated when WITH clause is empty in DSL
#11348 - BooleanDataKey.DATA_FORCE_STATIC_STATEMENT only forces inlining of bind values, not static statement execution
#11350 - Missing H2 support on WithStep::selectOne and similar methods
#11361 - Wrong emulation of the procedural FOR loop with index
#11366 - Collect nested DECLARE statements in Firebird and pull them up to the top level block
#11370 - Occasionally repeated BEGIN BEGIN blocks from emulations around DECLARE
#11376 - Implicit joins don't work inside of procedural logic
#11377 - DML statements should enter a ScopeStack scope
#11387 - NullPointerException when using Enums
#11388 - java.lang.IllegalStateException: Cannot create a DerivedColumnList from a qualified name
#11398 - Wrong emulation of JSON_OBJECTAGG in Db2 and other dialects  for String values
#11417 - Parser::parseStatements parses DECLARE <decl> BEGIN <stmt> END; into bad structure
#11427 - Parser doesn't accept INSERT .. SELECT .. ON CONFLICT
#11435 - Support parsing quoted identifiers containing escaped quotes
#11437 - Passing an empty array or collection to returningResult() does not match the behaviour of returning()
#11442 - Plain SQL templates improperly recognise "?<>" as a PostgreSQL operator
#11443 - BatchedPreparedStatement doesn't work if statement is re-used
#11446 - Bad formatting for UPDATE .. ROW = ROW statements
#11447 - Missing CockroachDB support on WITH RECURSIVE method Support annotations
#11462 - LoaderOptionsStep.commitAfter() is not implemented correctly
#11466 - DataType::identity Support annotation should list dialects that support identity types
#11468 - CustomTable.getUniqueKeys() should return super.getUniqueKeys() not super.getKeys()
#11474 - Cannot parse JSON[B]_AGG() FILTER or OVER clause
#11475 - Translator should avoid bind variable casts in the absence of schema information
#11477 - Missing ABSENT ON NULL declarations in JSON_OBJECT emulated by FOR JSON
#11484 - FILTER clause does not work on JSON_ARRAYAGG() or JSON_OBJECTAGG() functions in Db2 and Oracle dialects
#11486 - Bad extra derived table generated when INSERT .. SELECT references target table from correlated subquery in MariaDB, MySQL
#11517 - Support annotation wrong for Derby on DROP VIEW IF EXISTS
#11521 - ClassCastException when ResultQuery.fetchArray() returns no rows
#11522 - Wrong precision generated for SQL Server SMALLDATETIME data type
#11535 - Parser parses incorrect FOR UPDATE OF syntax, depending on dialect
#11560 - java.lang.ClassCastException: class org.jooq.impl.ResultImpl cannot be cast to class java.sql.ResultSet when mocking Oracle SYS_REFCURSOR procedure
#11564 - Add a way for emulated table expressions to auto-alias themselves
#11566 - JDBCDatabase doesn't yet distinguish between TableType.TABLE and VIEW and others
#11576 - DefaultMetaTableDefinition doesn't consider DataType.identity() flag
#11579 - Add internal Cascade enum type
#11580 - fetchParent() doesn't work properly with foreign key referencing just a part from a composed primary key
#11582 - Avoid auxiliary derived table in SQLite GENERATE_SERIES emulation
#11586 - Put TOP_LEVEL_CTE marker at DML statement beginning, not SELECT, in SQL Server
#11591 - Misleading Javadoc about Settings.isInsertUnchangedRecords
#11596 - ArrayTable doesn't pass derived column list to ArrayTableEmulation
#11605 - DropTableStep.cascade() and restrict() have wrong dialects in Support annotation
#11614 - Fix @Support on ALTER TABLE .. RENAME INDEX
#11621 - Parser wrongly recognises VERSIONS table alias as keyword
#11629 - Cannot parse MariaDB FOR LOOP syntax
#11630 - Cannot parse empty blocks
#11631 - Boolean field expected when parsing NOT(?)
#11632 - Parser fails when parsing nested not unary operator without parentheses
#11634 - XMLFormat.quoteNested() is not being considered in Result.intoXML()
#11638 - Missing DERBY @Support on DSL.date(), DSL.time(), DSL.timestamp() methods
#11639 - Support parsing DROP SEQUENCE .. RESTRICT
#11644 - Invert defaults for internal Tools.visitSubquery() parentheses flag
#11651 - Add parser support for VERTICA IDENTITY column type
#11652 - Vertica has native support for DECODE
#11658 - PostgresDatabase doesn't produce CHAR type length for CHAR(n)[] array types
#11661 - ROWNUM transformation doesn't work in the presence of DISTINCT
#11663 - Wrong order of WINDOW / QUALIFY clauses
#11667 - Oracle MetaTable fields do not have identity information
#11673 - Emulate NVL using COALESCE instead of CASE, where possible
#11683 - REPLACE should inline empty string parameter, not use val
#11689 - Code generator regression for SQL Server defaulted parameters
#11695 - Support parsing "! =" and "< >" and other operators containing white space in Oracle
#11701 - Bad inlining of Infinity or NaN in PostgreSQL
#11704 - Support floating point NaN and (-)Infinity values in other dialects
#11705 - Add parser support for Firebird's BLOB SUB_TYPE syntax
#11709 - Oracle typed REF CURSOR produce wrong code
#11721 - Wrong precision for H2 timestamp when using domains
#11732 - PostgreSQL ON CONFLICT .. WHERE <index_predicate> generates not valid SQL
#11733 - Column "INFORMATION_SCHEMA.COLUMNS.INTERVAL_TYPE" not found in H2 1.4.197
#11740 - Stop using deprecated ojdbc API
#11747 - TO_CHAR(x) without format is not natively supported in PostgreSQL
#11749 - Oracle UPDATE .. RETURNING emulation doesn't work for boolean data type rewrites
#11760 - NullPointerException instead of DetachedException when executing a detached Routine
#11762 - Regression when using plain SQL H2 array types
#11767 - ROWNUM transformation should avoid creating derived tables if possible
#11769 - NPE when ParsingConnection is not attached to an actual connection
#11783 - Named parameter mapping doesn't work with missing or excess source column values
#11790 - Oracle DUAL table incorrectly quoted by RenderQuotedNames.ALWAYS
#11791 - <recordsImplementingRecordN/> no longer works in Scala
#11818 - Avoid new Integer(...) calls in JSON Parser
#11819 - Coerce should delegate all QueryPartInternal calls to the wrapped field
#11832 - Typo in AggregateFunction.keepDenseRankLastOrderBy() Javadoc
#11841 - Work around Simba for BigQuery's lack of NULL bind variable support
#11847 - Regression in Teradata where DUAL is no longer quoted
#11852 - DUAL emulation in Teradata MERGE .. USING DUAL doesn't work
#11857 - Emulate CASE WHEN EXISTS in Teradata
#11866 - MemSQL computed columns of type int aren't generated correctly
#11870 - MiniJAXB cannot read code generation's regexFlags content (an xs:list type)
#11873 - Code generation error when generating code for Redshift
#11876 - Regression in OracleDatabase for sequences with large MAXVALUE
#11883 - jOOQ 3.13 manual refers to not-yet existing jsonEntry(String, Field)
#11893 - DefaultConverterProvider isn't able to look up value to single-arg constructor conversions
#11895 - ResultQuery.fetchStream() fetches entire resultset at once
#11904 - ORDER BY <field index> should resolve nested record emulation
#11912 - KotlinGenerator generates invalid code when column names X and isX clash
#11918 - Add Settings.renderOptionalXYZ support to ParserCLI
#11921 - Wrong position reported for parser meta lookup failures
#11924 - Incorrect SQL generated for multi table DELETE with JOIN in MySQL
#11930 - Wrong result displayed for SQRT(4) function call in the manual
#11934 - Constants.MINOR_VERSION was not updated in 3.14
#11936 - Manual section using-jooq-with-jdbctemplate shouldn't use deprecated JdbcTemplate method
#11953 - Parser grammar does not reflect both possible positions of FROM FIRST / LAST and IGNORE / RESPECT NULLS
#11954 - Date Add and Date Sub conversion not working for Redshift dialect
#11958 - BOOL_AND() and BOOL_OR() emulation does not correctly implement FILTER clause
#11973 - JDBCUtils.dialect(Connection) recognises MYSQL_8_0, not MYSQL_8_0_19
#11977 - PostgresDatabase should ignore unknown functions when parsing index column expressions
#11987 - Parser doesn't support date time arithmetic in DATE_TRUNC arguments
#12007 - Column "INFORMATION_SCHEMA.COLUMNS.DOMAIN_SCHEMA" and "INFORMATION_SCHEMA.COLUMNS.DOMAIN_NAME" not found in H2 1.4.197
#12013 - Support parsing HSQLDB post-fix IF EXISTS in DROP statements
#12019 - ORA-06550 when calling a PL/SQL procedure with a %ROWTYPE parameter that has DATE fields when dateAsTimestamp=true
#12020 - Result.formatXML() and formatJSON() do not correctly format nested records
#12026 - Result.formatXML() re-declares xmlns on each level for nested results
#12044 - Correctly emulate XMLAGG(...) FILTER (WHERE ...) in Db2, Oracle, Teradata
#12050 - CAST must not generate length, precision, scale in Oracle PL/SQL context
#12054 - Wrong comment in manual meta section about the manual
#12064 - Informix can't handle bind values as arguments to NVL() or COALESCE()
#12070 - JSON_OBJECT and JSON_ARRAY functions should generate a Name, not a Keyword
#12072 - Work around Oracle bug where a CASE expression without ELSE clause in JSON_ARRAYAGG causes ORA-40590: invalid format
#12078 - SQL Server UpdatableRecord.refresh() is unnecessary when calling UpdatableRecord.store()
#12080 - Generate a FORMAT JSON clause in Oracle's JSON_OBJECT if contents are of type JSON
#12085 - Work around Oracle's JSON_ARRAYAGG() bugs when aggregate inputs should be DISTINCT
#12086 - Nested JSON_OBJECT() emulation is wrong in SQL Server
#12088 - UDT.getQualifiedName() does not produce package qualification for a package UDT
#12091 - Manual section data-types-oracle-date uses deprecated API
#12094 - Meta.ddl() produces TIMESTAMP instead of DATE for columns with dateAsTimestamp=true active
#12105 - Work around Db2 Reply.fill() - insufficient data (-1). Message: Insufficient data. when fetching JSON_ARRAY
#12106 - Manual section about limit-clause contains broken link about Oracle ROWNUM filtering performance

Reply all
Reply to author
Forward
0 new messages