Upgrade jOOQ 3.19.18 -> 3.20.2 #1559
Open
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
|
Suggested commit message: |
Stephan202
reviewed
Feb 21, 2025
There was a problem hiding this comment.
The release notes LGTM, but this version now requires JDK 21.
One possible fix is this:
diff --git a/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/ExplicitArgumentEnumerationTest.java b/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/ExplicitArgumentEnumerationTest.java
index 1ac3e047..a22b8388 100644
--- a/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/ExplicitArgumentEnumerationTest.java
+++ b/error-prone-contrib/src/test/java/tech/picnic/errorprone/bugpatterns/ExplicitArgumentEnumerationTest.java
@@ -4,9 +4,12 @@ import com.google.errorprone.BugCheckerRefactoringTestHelper;
import com.google.errorprone.BugCheckerRefactoringTestHelper.TestMode;
import com.google.errorprone.CompilationTestHelper;
import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledForJreRange;
+import org.junit.jupiter.api.condition.JRE;
final class ExplicitArgumentEnumerationTest {
@Test
+ @DisabledForJreRange(max = JRE.JAVA_20 /* jOOQ requires JDK 21+ */)
void identification() {
CompilationTestHelper.newInstance(ExplicitArgumentEnumeration.class, getClass())
.addSourceLines(
diff --git a/pom.xml b/pom.xml
index cf7471cc..9d8d4293 100644
--- a/pom.xml
+++ b/pom.xml
@@ -1109,6 +1109,7 @@
</banDynamicVersions>
<dependencyConvergence />
<enforceBytecodeVersion>
+ <ignoredScopes>test</ignoredScopes>
<maxJdkVersion>${version.jdk}</maxJdkVersion>
</enforceBytecodeVersion>
<requireEncoding>
... but then ideally we move the jOOQ test to a separate JUnit test, and because we do run a full build against JDK 17, the ignoredScopes setting doesn't feel super right.
Maybe we should just do it, but OTOH: if we "simply" raise our baseline to JDK 21, then we can also start writing more JDK 21-specific Refaster rules and checks, and kick the can of more sophisticated multi-version support down the road. WDYT @rickie?
Picnic-DevPla-Bot
force-pushed
the
renovate/jooq-3.x
branch
2 times, most recently
from
78c6524 to
be32b73
Compare
Picnic-DevPla-Bot
changed the title
Picnic-DevPla-Bot
force-pushed
the
renovate/jooq-3.x
branch
from
be32b73 to
6ac4666
Compare
1 task
Picnic-DevPla-Bot
force-pushed
the
renovate/jooq-3.x
branch
2 times, most recently
from
39df2c4 to
361349c
Compare
Picnic-DevPla-Bot
force-pushed
the
renovate/jooq-3.x
branch
3 times, most recently
from
d75648f to
660cc30
Compare
See: - https://www.jooq.org/notes - https://github.com/jOOQ/jOOQ/releases/tag/version-3.20.2 - https://github.com/jOOQ/jOOQ/releases/tag/version-3.20.1 - https://github.com/jOOQ/jOOQ/releases/tag/version-3.20.0 - https://github.com/jOOQ/jOOQ/releases/tag/version-3.19.21 - https://github.com/jOOQ/jOOQ/releases/tag/version-3.19.20 - https://github.com/jOOQ/jOOQ/releases/tag/version-3.19.19
Picnic-DevPla-Bot
changed the title
Picnic-DevPla-Bot
force-pushed
the
renovate/jooq-3.x
branch
from
660cc30 to
e481c59
Compare
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This PR contains the following updates:
3.19.18->3.20.2Release Notes
jOOQ/jOOQ (jOOQ)
v3.20.2: 3.20.2Version 3.20.2 - March 11, 2025
This is a 3.20 patch release with minor improvements and bug fixes
Features and Improvements
#18063 - Add MySQL and MariaDB support for ALTER TABLE .. SET NOT NULL / DROP NOT NULL
#18106 - DiagnosticsListener Javadoc should link to manual
Bug Fixes
#18049 - Include fields and values lengths in "The number of values must match the number of fields" error message
#18053 - Meta.migrateTo() drops column before dropping its foreign keys or indexes
#18056 - ClassCastException in ArrayConverter when working with primitive typed int.class component type
#18060 - ArrayStoreException when using Converter<T[][], U[][]> with empty arrays
#18079 - DiagnosticsListener::duplicateStatements event isn't triggered for DiagnosticsConnection.ON setting
#18085 - DiagnosticsConnection.ON does not retain the internally created DiagnosticsConnection's caches
#18099 - PostgreSQL nested row isn't attached to Configuration when used with ad-hoc converter
#18102 - Record::key produces unattached records
#18115 - <globalObjectNames/> should explicitly declare String type in KotlinGenerator, for usage with explicit API compiler flag
#18117 - <globalObjectNames/> should generate const val in KotlinGenerator or ScalaGenerator, for annotation usage
#18124 - Work around ORA-00929: missing period when fully qualifying JSON columns
v3.20.1: 3.20.1Version 3.20.1 - February 21, 2025
This is a 3.20 patch release with minor improvements and bug fixes
Bug Fixes
#18035 - Scala 3.5 problem when calling AbstractTable::getIdentity from generated code
#18038 - Generated POJO equals() and hashCode() implementations shouldn't exclude non-primary key columns by default
v3.20.0: 3.20.0Version 3.20.0 - February 19, 2025
New dialects:
jOOQ 3.20 ships with 2 new experimental dialects:
ClickHouse is a fast-moving SQL dialect with a historic vendor-specific syntax that is gradually migrated to a more standards compliant alternative, which is why our support is still experimental. A lot of behaviours differ from what one would expect elsewhere, including NULL handling, which is very different from standard SQL. Future jOOQ versions will continue deepening this integration.
Databricks offers a very promising SQL dialect with a lot of functionality, which we're going to cover in full with the next version jOOQ 3.21. An initial version of the dialect is shipped already in 3.20 as an experimental dialect. 3.20 will continue to receive bug fixes and Databricks improvements as we work with early adopting customers.
DuckDB improvements
We continue supporting various DuckDB SQL features, including:
New modules
In order to better integrate with Reactor, probably the most popular reactive streams API on the JVM, we've added a new jOOQ-reactor-extensions module, which offers an implementation of the new
SubscriberProviderSPI, a new SPI in the Configuration that helps make jOOQ's R2DBC specific internals Reactor Context aware.The jOOQ-beans-extensions module now hosts our support for the
@ConstructorPropertiesannotation in theDefaultRecordMapper, an annotation that is located in the JDK'sjdk.desktopmodule. This allows us to move the heavy module dependency out of jOOQ's core library, which is useful for those applications that want to omit shipping the complete JDK and keep low footprints.The jOOQ-jpa-extensions module now hosts our support for the various JPA annotations like
@Column,@Table, also in theDefaultRecordMapper, effectively removing the optionaljakarta.persistencedependency from the core library, as well as offering alternative implementations of annotation based mapping.Support for Oracle type hierarchies
Oracle is the most sophisticated ORDBMS implementation, with a rich set of object-oriented PL/SQL language features. jOOQ 3.20 finally adds support for PL/SQL OBJECT type hierarchies both in our code generator as well as in the runtime library, making jOOQ an even strong match for your PL/SQL language usage
This is a commercial only feature.
Better spatial support
A lot of additional spatial functions have been added to jOOQ's spatial support. These efforts also include many improvements to the DuckDB and Oracle spatial implementations.
For more information, refer to:
This is a commercial only feature.
DECFLOAT support
A variety of dialects offer an additional decimal floating point data type,
DECFLOAT, in addition to the binary floating point typesREAL(32 bit),DOUBLE PRECISION(64 bit), andFLOAT(variable sized). Our neworg.jooq.Decfloattype allows for capturing these types in our code generator and runtime.Synonym support
A variety of dialects support the concept of a
SYNONYMorALIASwhere an alternative name can be given to any object type. jOOQ 3.20 supports these synonyms both in the code generator as well as the DDL API. Future jOOQ versions may continue to improve synonymsupport, e.g. by generating type aliases in Kotlin or Scala.
For more information, refer to:
This is a commercial only feature.
Hidden columns
Just like a few dialects support hidden or invisible columns, this is now possible in jOOQ as well, at the client side. Hiding columns effectively removes them from:
selectFrom()and similar callsAt the same time, the columns are still available for explicit references. This feature can be useful for schema evolution purposes, where data of deprecated columns is kept around for historic purposes. It works well together with the column deprecation feature of the code generator:
For more information about hidden columns, refer to:
This is a commercial only feature.
Kotlin 2 and Scala 3 support
Starting from jOOQ 3.20, we formally support both Kotlin 2 and Scala 3 and fully integration tests both the core libraries as well as the code generator and extension libraries on these language versions. For Scala support, please also consider our support matrix:
JDK baselines
The jOOQ Open Source Edition 3.20 increases its baseline to JDK 21. Support for older JDKs is available int he commercial distributions, see:
Record dirty tracking
jOOQ has long supported record dirty tracking in its
UpdatableRecordallowing for a simple way of performing CRUD. WithjOOQ 3.20, it will be possible for users to override the default behaviour of the dirty flag from a "touched" semantics to a "modified" semantics, effectively sending only actual modifications to the database.
For more information, refer to:
DML join improvements
jOOQ 3.20 now supports the useful
DELETE .. USINGandUPDATE .. FROMsyntaxes on all RDBMS through a new set of SQL transformations that allow for these vendor specific JOIN syntaxes to be used in DML statements even in the absence ofMERGEstatement support.At the same time,
MERGEitself also received an upgrade, including:BY SOURCEandBY TARGETsupportWHEN NOT MATCHED AND ..clause supportFor more information, refer to:
Code generation improvements
A lot of problems related to the generation of interfaces, immutablePojos, UDTs, etc. have been addressed in this release, making generated code more sound for various configuration edge cases where these features are combined.
Manual search
We have (at last!) added in-page search functionality to our user manual, so users can better find information on our website.
For a complete list other, minor improvements, see the below change notes:
Features and Improvements
#644 - Add support for Oracle TYPE .. UNDER type hierarchies
#2309 - Add search to manual pages
#4819 - Document the fact that org.jooq.Binding does not necessarily have to implement a complete org.jooq.Converter
#5394 - Add Settings.recordDirtyTracking to prefer Record.modified() over Record.touched() for dirty tracking operations
#5844 - IndexOutOfBoundsException when calling PostgreSQL table valued function returning empty result, with <tableValuedFunction/> turned off
#7104 - Add DSL.stringAgg() and stringAggDistinct()
#7406 - Add code generation support for SETOF UDT returning functions in PostgreSQL
#7531 - Support UNION .. LIMIT in Teradata
#7539 - Add support for Clickhouse
#8705 - Add code generation configuration to generate primary key based equals() and hashCode() on POJOs
#9557 - Add support for ALTER TABLE .. DROP CONSTRAINT IF EXISTS
#9574 - Add org.jooq.Synonym
#9736 - Add runtime model for foreign key ON DELETE and ON UPDATE actions
#10059 - Add support for SQL Server MERGE .. WHEN NOT MATCHED BY { SOURCE | TARGET }
#10574 - Add PascalCaseGeneratorStrategy to improve user experience for T-SQL schemas implemented in PascalCase
#10715 - Add support for multiple MERGE .. WHEN NOT MATCHED AND { condition }
#10776 - Add GeneratorStrategy::getJavaMemberOverride, getJavaSetterOverride, getJavaGetterOverride, getJavaMethodOverride
#11158 - Emulate UPDATE .. JOIN with UPDATE .. FROM where not supported natively
#11371 - Generate UDT.getSupertype() and UDT.getSubtypes()
#11375 - <globalObjectNames/> Should produce a file containing enum literals for each enum type
#11886 - Avoid parentheses when rendering associative concatenation chains
#12073 - Emulate combination of JSON_ARRAYAGG() FILTER clause and NULL ON NULL clause
#12180 - Add support for Scala 3
#12361 - Emulate simple cases of the data change delta table in Firebird, MariaDB, SQL Server
#12462 - Overload DSL.function() to accept arguments also as Collection<? extends Field<?>>
#12494 - Add additional Record.modified() and Record.touched() methods, deprecate Record.changed()
#12605 - Add support for Firebird 4 TIME[STAMP] WITH TIME ZONE data types
#12736 - Continue support for spatial extensions
#13304 - Every manual section that makes use of classpath resources should briefly explain how to use classpath resources in the code generator
#13411 - Add <hidden/>, a <forcedType/> flag that removes columns from projections by default
#13412 - Emulate UPDATE .. FROM with multiple tables or joins
#14398 - Avoid rendering parentheses on left associative operations
#14402 - Add experimental support for Databricks SQL
#14490 - Add a jOOQ-reactor-extensions module offering reactor specific extensions
#14552 - Add more "Don't Do This" content to the manual
#14610 - Get HANA dialect support up to date
#14676 - Document Fields::field behaviour in the manual
#14775 - Add Settings to turn off client side computed column including audit columns
#14806 - Upgrade checkerframework to 3.19.0 to better support JDK 17
#14827 - Add support for the JSON_KEY_EXISTS() function
#14894 - Remove examples in favour of our demo
#15012 - Get BigQuery dialect up to date
#15177 - Make JDK 21 the baseline for the jOOQ Open Source Edition
#15222 - Improve exception message when SEEK field list size doesn't match ORDER BY field list size
#15251 - Add support for synthetic DEFAULT expressions
#15346 - Add a Settings.fetchTrimmedCharValues flag to auto-trim CHAR results from certain RDBMS
#15528 - Add a section to the manual about experimental and internal API
#15637 - Emulate DELETE .. USING with MERGE, where available
#15723 - Generate comments also on other PostgreSQL object types
#15732 - Improve on DuckDB support
#15830 - Add support for the Oracle 23ai multi row INSERT .. VALUES statement
#15906 - Continue work on public query object model API
#15968 - Add section in Maven code generation manual page about multiple executions
#15970 - Manual page about implicit join type settings should document Settings.renderImplicitJoinToManyType
#15979 - Visually separate active / eol / snapshot versions on website
#15987 - pom.xml files should use https links instead of http links
#15989 - AbstractJoin.toString() should render SQL with tables declared, not referenced
#15999 - Add a section to the manual showing usage of EXCLUDED with INSERT .. ON DUPLICATE KEY UPDATE
#16002 - Add new code generation flag to omit @NotNull / @Nullable annotations on write-only nullable types
#16009 - Document <includeTriggers> on codegen-database-include-object-types
#16012 - Add Javadoc to discourage using any Fields.field(x, Class<T>) method if there's an Fields.field(x, DataType<T>) overload, as well as inline(T), value(T), and val(T)
#16031 - SQLPerformanceWarning should log hint about gathering dictionary statistics in OracleDatabase
#16044 - org.jooq.tools.Convert should delegate to org.jooq.impl.Convert, instead of duplicating implementations
#16071 - Add MAX_BY() and MIN_BY() aggregate functions
#16087 - Improve manual section about jOOQ-codegen-gradle
#16093 - Add matcher strategies for method overrides
#16101 - Support binary versions of supported string functions
#16110 - Add documentation sections for BIT_LENGTH and OCTET_LENGTH functions
#16112 - Mark tags as releases in GitHub repo
#16117 - Upgrade dependencies
#16121 - Add Context.scopeParts(Class<Q>): Iterable<Q> to allow for iterating over the values that are currently in scope
#16135 - Add a code generation flag that applies the <hidden/> forcedType for RDBMS hidden fields
#16136 - Meta::ddl should include hidden columns in DDL exports
#16138 - Let AbstractRecord, AbstractRow implement FieldsTrait
#16139 - Upgrade Spring dependency from jOOQ-meta-extensions-hibernate to 6.1.3 due to CVE-2024-22233
#16178 - Implement <includeInvisibleColumns/> in more dialects
#16216 - Add parser support for SQLite's undocumented inline AUTOINCREMENT syntax
#16227 - Add JSON_ARRAY_LENGTH() function support
#16274 - Document ARRAY_APPEND and ARRAY_PREPEND functions
#16287 - Upgrade DuckDB dialect to DuckDB 0.10.2
#16289 - Support COMMENT ON in DuckDB 0.10.0
#16307 - Add parser support for MySQL YEAR_MONTH style interval literals
#16308 - Support parsing ORDER BY clause of STRING_AGG function
#16318 - Allow for specifying inputs to the gradle CodegenTask in order to participate in incremental builds
#16363 - Upgrade pgjdbc to 42.7.3
#16416 - Split CREATE SEQUENCE section of the manual to document flags individually
#16418 - Add <ignoreUnused/> flag to a few code generation elements, for better reuse
#16432 - Add support for the CBRT() and ROOT() functions
#16436 - Document DSL.jsonGetElement() index being 0 based
#16442 - Support parsing function alternatives to operators
#16448 - Add auto converter support between primitive and non-primitive arrays
#16483 - Add Settings.renderNullifEmptyStringForBindValues to emulate Oracle behaviour on other RDBMS
#16484 - Document Settings.renderCoalesceToEmptyStringInConcat
#16486 - Add native support for SEMI JOIN / ANTI JOIN in DuckDB
#16492 - Add code generation support for FOREIGN KEYs in DuckDB
#16498 - Render standard SQL DATE literal on MySQL, instead of JDBC date literal
#16499 - Add support for lambda accepting array functions
#16501 - GeneratorStrategy::getJavaMemberOverride should be called with Mode.DAO for all member-specific fetchByXYZ methods generated in a DAO
#16509 - Avoid more internal COALESCE calls when unnecessary via AbstractField::isNullable
#16515 - Add named parameters to QOM.ArrayReplace, QOM.ArrayRemove, QOM.ArrayPrepend, QOM.ArrayAppend
#16518 - Support CockroachDB 22.1 ON CONFLICT .. ON CONSTRAINT
#16520 - Add AlterTableStep.add(TableElement) overload
#16521 - DefaultRecordUnmapper should be able to unmap a JDBC Struct
#16522 - Add alternative setNonKeyToExcluded(), setNonPrimaryKeyToExcluded(), and setNonConflictingKeyToExcluded() methods to UPSERT syntax
#16524 - Add support for MySQL's BIN_TO_UUID and UUID_TO_BIN functions
#16531 - Document missing Parser::parseSelect and Parser::parseStatement methods in manual
#16563 - Support delimiter expressions in LISTAGG() and GROUP_CONCAT()
#16592 - Add OrderedAggregateFunction::orderBy as a synonym for withinGroupOrderBy
#16594 - Add BigQuery support for ARRAY_AGG
#16600 - Add a <commentsOnDomains/> flag
#16601 - Add more <comment/> support to jooq-meta.xsd
#16607 - Add DataType.hasFixedLength()
#16608 - Add a documentation example in the manual page about matcher rule showing how to remove prefixes / suffixes
#16615 - Support BigQuery's ALTER COLUMN SET OPTIONS as a COMMENT ON COLUMN implementation
#16620 - Add parser support for the T-SQL DDL ALTER TABLE .. WITH CHECK clause
#16628 - Rename SQLDialect.ORACLE23C to ORACLE23AI
#16629 - Support CTE column aliasing for plain SQL templates where this isn't supported
#16633 - Add broader DELETE .. USING and UPDATE .. FROM support, using the same emulation as that for DML ORDER BY .. LIMIT
#16638 - Let DataAccessException::sqlStateClass be based on HANA error codes for SQLStateClass 22 or 23
#16639 - Add HANA support for LATERAL, CROSS APPLY, OUTER APPLY
#16640 - Add HANA support for COLLATE
#16643 - Add parser support for SQLite's TOTAL() aggregate function
#16644 - Add parser support for Teradata's MAXIMUM() and MINIMUM() synonyms for MAX() and MIN()
#16666 - Add SQLite support for GROUP_CONCAT(DISTINCT ..)
#16670 - Add jakarta.annotation.Generated as possible GeneratedAnnotationType
#16690 - Support Kotlin 2.0
#16695 - Create subsections for the ORDER BY clause
#16696 - Add a new Settings to override the reflection cache sizes
#16732 - Support references to UPDATE .. FROM tables from SET clause in dialects that support UPDATE .. JOIN
#16751 - Emulate JSON_OBJECTAGG() with FILTER in Oracle
#16752 - Add a SQLDialect.MARIADB_11_2 dialect
#16754 - Add JSON function support in BigQuery
#16759 - Add support for BigQuery PERCENTILE_CONT, PERCENTILE_DISC window functions
#16760 - Support DEFAULT expression in BigQuery INSERT and UPDATE
#16767 - Add DataType.autoIncrement() and DataType.generatedByDefaultAsIdentity() as a synonyms for DataType.identity(true)
#16768 - Parse and ignore SQL Server CREATE TABLE column constraint index options
#16784 - Add manual page for readonly related Settings flags
#16805 - Clarify EmbeddableRecord Javadoc
#16825 - The code generation initScript property should be able to read from the file system
#16827 - Add Source.resolve(String) to allow for varied, string based input sources
#16830 - Add DuckDB spatial support
#16836 - Add support for DuckDB 1.0.0
#16839 - ArrayDataType.getRow() and ArrayDataType.getRecordType() should delegate to underlying elementType
#16841 - Add native support for Oracle23ai BOOLEAN typed field expressions from conditions
Breaking changes
#7668 - DAO fetch methods should use GeneratorStrategy::getJavaMemberName with Mode.DAO instead of getJavaClassName
#10297 - HANA's TINYINT correspond to UByte, not Byte
#10880 - Add support for the Db2, H2, Firebird 4 DECFLOAT data type (HANA: SMALLDECIMAL)
#12851 - Add support for CREATE SEQUENCE .. AS <data type>
#15941 - Remove pre 3.9 deprecated API and pre 3.9 documentation
#15966 - Remove mandatory dependency from compileJava to jOOQ-codegen-gradle tasks
#16084 - Wrong order of MiniJAXB.append() calls in jOOQ-codegen-gradle
#16092 - JavaGenerator::generateRecordSetter0 uses wrong Mode.POJO for GeneratorStrategy::getJavaMemberName call
#16344 - QOM.Count.$field() should return null instead of internal asterisk representation
#16444 - Remove experimental sealed type declarations from API again
#16494 - Remove SQLite specific rendering of quoted identifiers, to behave like other dialects
#16500 - Move jakarta.persistence related logic of DefaultRecordMapper into a new jooq-jpa-extensions module
#16539 - DDL statements should produce DATETIME data type for SQLDataType.TIMESTAMP in MySQL
#16598 - Generate backticks for quoted identifiers in SQLite, instead of double quotes
#16801 - Change PERCENT_RANK hypothetical set function to return BigDecimal instead of Integer
#16821 - Don't delay jOOQ-codegen-gradle's configuration until execution by default
Deprecations
#7585 - Move java.desktop related logic of DefaultRecordMapper into a new jooq-beans-extensions module
#16810 - Deprecate DataType.convert()
#16815 - Deprecate internal, protected AbstractRecord.from(Record) method
Bug Fixes
#579 - Add Settings.renderAutoAliasedDerivedTableExpressions to auto alias unnamed field expressions in derived tables
#2902 - SQLite's binding of BigDecimal through PreparedStatement.setString() doesn't work for predicates
#3791 - Invalid SQL generated when UNION subselects contain ORDER BY
#7263 - Parser should accept qualified field references in MERGE .. INSERT statement
#7467 - Wrong SQL generated in SQL Server when using UNION .. LIMIT without OFFSET
#8209 - Invalid code when generating both POJOs and interfaces with UDTs
#8517 - Row[N].eq(Row[N]) should apply data type bindings if necessary
#9814 - MappedSchema.withInput("").withOutput("abc") prepends schema qualification to derived table references
#10585 - ParserImpl.KEYWORDS_IN_SELECT and other such lists should be tries for improved performance
#11126 - Avoid calling AbstractQueryPart::equals
#11519 - NullPointerException in SchemaMapping due to race condition in SchemaMapping cache
#11716 - Using embedded domains with POJO generation results in duplicate getters
#12243 - name(null, "") should equal to name("")
#12485 - Use PreparedStatement.setObject(int, Object, Types.OTHER) instead of setString(int, String) to bind array bind values in PostgreSQL
#12637 - Compilation error in generated code when UDT attribute name conflicts with getter procedure
#13225 - Add Javadoc to all XJC-generated "withers" and setters of boolean types
#13425 - Correctly emulate UPDATE .. FROM .. ORDER BY
#13533 - SQL Server MULTISET subquery ORDER BY clause doesn't work with UNION
#13665 - Cannot project unnamed MULTISET or ROW from derived table
#14005 - Code generator produces wrong ordering of DataType properties for nullable and defaulted array types
#14307 - Emulate LIMIT 0 where not supported
#14866 - Incorrect conversion of LocalDateTime to LocalDate during daylight saving time
#14965 - Wrong emulation of DISTINCT ON with UNION
#15085 - Confusing error message when reading a non-existing Field from a Record containing accidentally nested row types
#15159 - SQLExceptionLoggerListener logs wrong message on table with IDENTITY column and UNIQUE key
#15189 - Wrong WITH TIES emulation when combined with QUALIFY if QUALIFY is supported natively
#15322 - Meta.ddl() ignores data type for sequences
#15325 - Meta.ddl() includes synonyms or aliases as tables for some dialects
#15636 - Wrong SQL generated when specifying explicit path joins in UPDATE .. FROM and DELETE .. USING
#15762 - Exception in MetaImpl when encountering string literal default expressions in MariaDB 10.1
#15892 - Fix known limitations of embeddable types
#15933 - Maximum consumed results reached when Hikari close a SQL Server connection, leading to excessive logging
#15934 - Code generator and MetaImpl return CREATE DEFAULT statement instead of just the default expression
#15936 - Implicit path correlation produces correlation predicate in ON clause rather than WHERE clause in some cases
#15942 - KeepNamesGeneratorStrategy generates ambiguous path names if implicitJoinPathTableSubtypes is activated
#15943 - SQLite requires parenthesised DEFAULT expressions in DDL
#15944 - jOOQ-codegen-gradle should resolve relative directories with respect to the gradle project, not the running process
#15946 - Compilation error in KotlinGenerator generated code with KeepNamesGeneratorStrategy and generated implicit join paths
#15958 - YugabyteDB doesn't support ALTER TABLE .. DROP CONSTRAINT IF EXISTS
#15965 - Regression in LiquibaseDatabase when omitting the database.liquibaseSchemaName value
#15967 - Implicit path correlation shouldn't generate correlation predicate if correlation isn't in scope
#15974 - Cannot look up tasks.named("jooqCodegen") from gradle scripts
#15975 - Wrong statement generated for MySQL when leading unqualified asterisk is used with plain SQL template table
#15978 - Cannot verify www.jooq.org's certificate on ubuntu-latest (Github Actions)
#15980 - Regression in PostgreSQL query using 'x' = ANY (ARRAY [(SELECT ARRAY ['x'])]) style quantified comparison predicate on multi dimensional arrays
#15982 - Comparison predicates and quantified comparison predicates should hint array type to org.jooq.impl.Array for empty expression array casts
#15991 - Cannot project TableAsField if table contains embeddables in PostgreSQL
#15992 - Version release statement not updated on /download
#15993 - RenderTable.WHEN_MULTIPLE_TABLES only works with table lists, not with joins
#15996 - RenderTable.WHEN_MULTIPLE_TABLES doesn't work correctly in correlated subqueries
#15998 - RenderTable.WHEN_AMBIGUOUS_COLUMNS doesn't cover all ambiguous column name cases
#16000 - Wrong code generation configuration example
#16003 - Misleading XSD warnings logged when working with MiniJAXB
#16006 - Compilation error in KotlinGenerator generated code when GeneratorStrategy produces identifiers conflicting with property access syntax of AbstractRoutine getters
#16008 - Code generator fails when generating triggers because TriggerExecution value is null
#16013 - ClassCastException during invocation of double-wrapped ConvertedDataType
#16029 - Regression: NullPointerException in KotlinGenerator generated code when InlineDerivedTable constructor calls TableImpl.where(null)
#16036 - Join paths don't work when embeddable keys or domains on keys are present
#16037 - ScalaGenerator produces duplicate paths for cyclic foreign key relationships
#16039 - Compilation error in JavaGenerator generated code when <pojosAsJavaRecordClasses> is active and a table references a UDT
#16043 - DATE column in Oracle is null when fetched through multiset
#16054 - Regression: Table metadata calculation for Oracle does not work after 3.19.0
#16059 - MetaSQL lookups are done with SQLDialect.family(), not SQLDialect
#16072 - Compilation error in ScalaGenerator generated code of UpdatableRecord subclasses when using scalac 3
#16074 - Compilation error in ScalaGenerator generated code of generated DAOs when using scalac 3
#16075 - Remove unnecessary runtimeClasspath dependency of the jOOQ-codegen-gradle plugin
#16080 - Syntax error in generated SQL of ALTER INDEX or ALTER SCHEMA statement, when identifiers aren't quoted
#16083 - jOOQ-gradle-plugin multi execution configuration shouldn't require an explicit default configuration
#16090 - Unnecessary static type registry warning when inlining custom converted enum value
#16094 - Compilation error in ScalaGenerator generated Keys.scala class when using GeneratorStrategy
#16105 - Wrong Javadoc in RTRIM() and LTRIM()
#16111 - Generated implicit join alias collision when child table foreign keys share the same name
#16113 - jOOQ-codegen-gradle fails with UnknownDomainObjectException when java plugin isn't applied first
#16114 - Settings.returnDefaultOnUpdatableRecord and Settings.returnComputedOnUpdatableRecord don't work for replacing embeddables
#16133 - jOOQ-codegen-gradle doesn't consider basedir property for its OutputDirectory
#16179 - QuantifiedSelect wrapping array doesn't correctly convert array component types
#16180 - %ROWTYPE UDT types generate invalid system columns when underlying table references object types
#16188 - jOOQ-codegen-gradle should lazily evaluate its configuration
#16195 - Overall performance improvement in AbstractNamed.hashCode() specialisations by avoiding Name::append
#16203 - Remove internal AbstractContext::toggle utilities
#16209 - AbstractScope::dsl, ::settings, ::dialect, and ::family should avoid unnecessary null-checks on Configuration
#16213 - Manual gradle codegen examples use wrong property name for boolean properties when using jOOQ-codegen-gradle with kotlin
#16215 - BatchCRUD implementation should extract bind values with SQL string in one go
#16232 - Wrong Support annotation on CREATE TRIGGER for INFORMIX
#16237 - IndexOutOfBoundsException in DerbyDatabase when <includeExcludeColumns/> excludes a column from an index
#16241 - Meta::ddl generates incorrect queries for SQL Server (max) lengths
#16246 - Avoid allocating DataMap in short lived Scope implementations
#16254 - JavaGenerator doesn't generate serialVersionUID in Path classes
#16258 - Avoid allocating Collections.nCopies in ScopeStack
#16262 - Avoid allocating JoinNode in scope registration of tables if unnecessary
#16266 - Avoid constructing DSL.name() for constant internal names
#16270 - Refactor QualifiedName to improve performance
#16275 - Remove unnecessary up-to-date prevention in jOOQ-codegen-gradle plugin
#16279 - Result::formatXML should omit type attribute on columns whose type is unknown
#16290 - Wrong SQL generated for CREATE TABLE in non-default schemas for DuckDB
#16297 - MULTISET equality is ORDER dependent in dialects without support for correlated derived tables
#16302 - Can't parse MySQL ALTER TABLE .. DROP .., DROP .. syntax
#16310 - Wrong SQL generated when nesting predicates on subqueries projecting embeddables within MULTISET
#16315 - Memory leak in DefaultCacheProvider when large amounts of arbitrary projections are mapped with DefaultRecordMapper
#16316 - Regression: Gradle plugin thinks it's up to date when it's not
#16319 - SelectIsNull renders invalid SQL when SELECT projection is embeddable
#16326 - DSLContext.fetchCount(Select) produces wrong SQL when query projects embeddables
#16330 - NumberFormatException in parser when encountering double value with implicit 0 exponent
#16332 - jOOQ parser parses indexed parameters as named
#16334 - UUID bind values should be auto-cast to avoid issues with lack of auto-conversion support in PostgreSQL, HSQLDB
#16336 - Parser shouldn't fail with NumberFormatException
#16340 - DefaultRenderContext::peekIndex doesn't contain correct bind index
#16345 - DSL.count() doesn't return QOM.Count type
#16346 - DSL.count(SelectFieldOrAsterisk) shouldn't wrap ordinary Field in SQLField
#16347 - Parser fails with StringIndexOutOfBoundsException when encountering invalid PostgreSQL unicode literal
#16367 - Cast NULL literal in subquery SELECT projection in PostgreSQL
#16368 - Parser always parses NULL literal of type BOOLEAN
#16378 - Add arity check to synthetic foreign key configuration to avoid wrong generated code when FK / UK columns mismatch
#16379 - Compilation error in generated Indexes.java when index references embeddables that replace their underlying fields
#16385 - Add some WARN logs when synthetic key objects aren't matched
#16392 - Regression in fetchCount execution when argument query uses plain SQL tables
#16393 - Empty derived column lists generate wrong SQL syntax
#16405 - Parser doesn't support GROUPING SETS with <ordinary grouping set> specification
#16409 - Improve Javadoc and log DEBUG message on RETURNING clauses, stressing that they can't return any rows for tables without identity in some dialects
#16420 - Code generation tool - Generate : liquibase.exception.MigrationFailedException on column type VARCHAR2(255 CHAR) (Oracle)
#16425 - Static type registry deprecation warning shouldn't appear when using the INSERT valuesOfRows() clause with converted data types
#16427 - DefaultDataType.getDataType logger should add more details about how to fix the problem
#16450 - SEEK doesn't work correctly when there are multiple noField() arguments and ORDER BY is uniform and Settings.renderRowConditionForSeekClause is true
#16452 - Fix other cases where org.jooq.impl.Val uses "inferred data type," but cannot actually lazily infer the type
#16456 - ParsingConnection should not rely on org.jooq.impl.Val identity to match user bind value indexes with rendered indexes
#16459 - Wrong AbstractField::parenthesised overrides in CURRENT_SCHEMA, CURRENT_USER
#16469 - Work around CockroachDB's lack of support for the POWER() function accepting integer arguments
#16470 - Meta::ddl produces incorrect DDL for SQLite, when there are FOREIGN KEY constraints
#16479 - SQL Server's CREATE cannot fully qualify a sequence name
#16493 - Intercept SQLFeatureNotSupportedException caused by DatabaseMetaData::getImportedKeys and other calls
#16503 - Improve compilation speeds of generated QOM types
#16510 - Avoid PostgreSQL empty array cast when explicit cast is given
#16523 - Dead link in manual section "jooq-and-java-8"
#16535 - Parser fails to parse TIME[STAMP] WITH TIME ZONE literals
#16547 - Wrong SEMI JOIN example in manual section "dont-do-this-sql-select-distinct"
#16551 - Get MemSQL dialect up to date
#16552 - Work around lack of support for INSERT .. SELECT .. UNION [ ALL ] SELECT in SingleStore
#16560 - Cannot configure matchers using jOOQ-codegen-gradle plugin
#16567 - Restore caching of resolvedType in AbstractTypedElementDefinition
#16569 - DELETE .. ORDER BY .. LIMIT on partitioned tables without unique constraint uses non-unique ctid for self joins
#16576 - SAXParseException warnings when using jOOQ-codegen-gradle or any other MiniJAXB.unmarshal() usage
#16581 - Time zone information lost when fetching TIMETZ[] value in PostgreSQL
#16585 - Work around HSQLDB bug where wrong LocalTime value is fetched when using bind values of type LocalTime[]
#16602 - Wrong cast type name when casting value to NCLOB in Firebird
#16616 - Fix order of NOT NULL and DEFAULT clauses in BigQuery CREATE TABLE statements
#16627 - Update using multi-column set clause with DSL.row and custom type logs warn on deprecated static type registry
#16631 - Error when running DELETE .. USING .. LIMIT in MySQL
#16632 - Wrong emulation of DELETE .. USING .. LIMIT where DELETE .. LIMIT is not natively supported
#16634 - HANA UPDATE statement always repeats target table, even if unnecessary
#16646 - BlobBinding and ClobBinding should fall back to byte[] and String binding also in HANA
#16651 - TableRecords should refresh() themselves for HANA dialect, when any non-identity value should be fetched after an insert
#16655 - MULTISET nested projection's ContextConverters don't receive correct ConverterContext
#16662 - Wrong source code generated when newline escape sequence of long view source is split into two
#16675 - SQLite "Cannot parse or interpret sql for table" error with both unique columns and foreign key constraints
#16679 - Wrong title in manual section "alter-table-drop-foreign-key"
#16685 - Add missing section to the manual about DISTINCT predicate of degree > 1
#16686 - Error in CockroachDBDatabase when running SHOW INDEXES for table valued function
#16691 - Work around KT-68407 compiler error in generated AbstractSpringDAOImpl class in kotlin 2.0
#16702 - Settings.transformPatternsUnnecessaryScalarSubquery produces wrong SQL when subquery column is aliased
#16705 - Pattern replacement activates RETURNING clause of DELETE / UPDATE statements
#16708 - Settings.transformPatternsUnnecessaryScalarSubquery produces wrong SQL when subquery column is an embeddable
#16725 - Avoid operator associativity rendering logic if operator isn't nested
#16734 - Redundant policy related logic in UpdateQueryImpl
#16739 - Internal SelectQueryImpl::copy behaviour may produce inconsistent copy of WINDOW clause
#16745 - Wrong SQL rendered for MS Access CONCAT function with more than 2 arguments
#16755 - Work around BigQuery's SELECT without FROM clause cannot use aggregation limitation
#16762 - Parser meta lookup fails for DUAL table
#16769 - Work around BigQuery ORDER BY clause limitation where identifiers cannot be resolved if the table and the column share the same name
#16773 - Work around BigQuery limitation of using: HAVING clause on a non-aggregate query
#16777 - Support BigQuery's QUALIFY .. WINDOW keyword order
#16782 - NullPointerException in MetaImpl when looking up a dropped table from a disabled foreign key in MySQL
#16786 - Fix null treatment syntax of window functions in BigQuery
#16792 - Inconsistent formatting of HSQLDB DUAL table emulation
#16796 - Incorrect emulation of inverse distribution functions with FILTER clause
#16797 - Parser error when trying to parse hypothetical set function with FILTER clause
#16834 - Wrong DataAccessException to IntegrityConstraintViolationException translation for DuckDB
#16837 - Wrong DuckDB binary literals generated when inlining bind values
#16842 - jOOQ-codegen-gradle 3.19.10 assumes presence of a "main" source set, which isn't always the case
#16844 - Correctly