Version 3.19.0 - December 15, 2023
================================================================================ New dialects ------------ It's been a few releases since we've added support for new dialects, but finally some very interesting RDBMS of increasing popularity have joined the jOOQ family including: - DuckDB (experimental support) - Trino These dialects are available in all jOOQ editions. New dialect versions -------------------- In addition to these entirely new dialects, big new CockroachDB and Oracle versions have shipped: - CockroachDB 23 - Oracle 23c We've added support for many new Oracle features, including: - Domains - UPDATE .. FROM - IF [ NOT ] EXISTS - Table value constructor - SELECT without FROM As well as CockroachDB features, including: - Triggers - Stored functions - UDTs - Materialized views - LATERAL - New native DML clauses - NULLS FIRST and NULLS LAST Join path improvements ---------------------- Implicit to-one path joins have been with jOOQ since version 3.11. Now, we've greatly improved this very useful feature by adding support for: - Explicit path joins, allowing for more fine grained control of the path join type: https://www.jooq.org/doc/3.19/manual/sql-building/sql-statements/select-statement/explicit-path-join/ - To-many path joins, including many-to-many paths for implicit and explicit joins going from parent to children: https://www.jooq.org/doc/3.19/manual/sql-building/sql-statements/select-statement/implicit-to-many-join/ - Implicit path correlation, allowing to greatly simplify correlated subqueries, including the powerful MULTISET correlated subqueries: https://www.jooq.org/doc/3.19/manual/sql-building/sql-statements/select-statement/implicit-path-correlation/ - Join elimination, allowing to skip unnecessary path segments of a join path This is best shown by example: <pre> // Before 3.19: ctx.select(ACTOR.FIRST_NAME, ACTOR.LAST_NAME) .from(ACTOR) .where(exists( selectOne() .from(FILM_ACTOR) .where(FILM_ACTOR.ACTOR_ID.eq(ACTOR.ACTOR_ID)) .and(FILM_ACTOR.film().TITLE.like("A%")) )) .fetch(); // After 3.19: ctx.select(ACTOR.FIRST_NAME, ACTOR.LAST_NAME) .from(ACTOR) .where(exists( selectOne() .from(ACTOR.film()) .where(ACTOR.film().TITLE.like("A%")) )) .fetch(); </pre> This feature is available in all jOOQ editions. Gradle plugin ------------- One of the longest awaited features is an official jooq-codegen-gradle plugin, that offers a tight integration with gradle's task system while being released in the same release cadence as jOOQ itself. Our new gradle plugin supports all of the code generation features in both an idiomatic groovy or kotlin DSL More information here: https://www.jooq.org/doc/3.19/manual/code-generation/codegen-gradle/ This feature is available in all jOOQ editions. Commercial maven repository --------------------------- A feature that many of our paying customers have wanted for a long time has finally been implemented: our commercial maven repository at https://repo.jooq.org, where all historic and new commercial only jOOQ artifacts as well as snapshot versions will be hosted, in addition to our ZIP file download website: https://www.jooq.org/download/versions This feature is available only in commercial jOOQ editions. Policies -------- Similar to PostgreSQL's powerful POLICY feature, or Oracle's Virtual Private Database, jOOQ 3.19 allows for declaring policies that act as automatic filters on some of your tables, to allow for a simple and thorough row level security implementation. For example, with a policy on the multi tenancy capable CUSTOMER table, a query like this: <pre> ctx.select(CUSTOMER.ID, CUSTOMER.NAME) .from(CUSTOMER) .fetch(); </pre> Might in fact run a SQL statement like this, instead: <pre> SELECT CUSTOMER.ID, CUSTOMER.NAME FROM CUSTOMER WHERE CUSTOMER.TENANT_ID = 42 </pre> Not just queries, but all DML statements are rewritten to disallow any inaccessible data from being written / read. More information here: https://www.jooq.org/doc/3.19/manual/sql-building/queryparts/policies/ This feature is available only in commercial jOOQ editions. UDT paths --------- In addition to adding User Defined Type (UDT) support to CockroachDB and Informix, we've improved our code generator support for UDTs in a way for attribute paths to be made accessible to client code in a type safe way. So, with types like these: <pre> CREATE TYPE country AS ( iso_code TEXT ); CREATE TYPE name AS ( first_name TEXT, last_name TEXT ); CREATE TYPE address AS ( street TEXT, ..., country COUNTRY ); CREATE TABLE customer ( id INT PRIMARY KEY, name NAME, address ADDRESS ); </pre> You can now destructure the UDTs directly in your SQL query like this: <pre> ctx.select( CUSTOMER.NAME.FIRST_NAME, CUSTOMER.NAME.LAST_NAME, CUSTOMER.ADDRESS.COUNTRY.ISO_CODE) .from(CUSTOMER) .fetchOne(); </pre> More information here: https://www.jooq.org/doc/3.19/manual/sql-building/column-expressions/user-defined-type-attribute-paths/ This feature is available in all jOOQ editions. Trigger meta data ----------------- The code generator can now reverse engineer trigger meta data from most RDBMS that support triggers. This meta data can be helpful at runtime, e.g. to render improved RETURNING support in the absence of triggers, in dialects where triggers require special emulations (e.g. SQLite or SQL Server). This feature is available only in commercial jOOQ editions. Hierarchies ----------- A new Collector has been added to recursively collect a flat representation of hierarchical data into an object hierarchy. This plays very well with our MULTISET nested collection support. For more details, see this blog post: https://blog.jooq.org/how-to-turn-a-list-of-flat-elements-into-a-hierarchy-in-java-sql-or-jooq/ This feature is available in all jOOQ editions. Java 8 support removed from jOOQ Express and Professional Editions ------------------------------------------------------------------ Like other leading platforms, we're moving on to help with the adoption of newer JDK versions. Our Java 8 support will be discontinued for the jOOQ Express Edition and jOOQ Professional Edition. If you require Java 8 support, you can upgrade to the jOOQ Enterprise Edition, which will continue supporting Java 8 for another few minor releases, or stay on jOOQ 3.18, which will also receive bug fixes for another while. This change affects only commercial jOOQ editions. For a complete list other, minor improvements, see the below change notes. Features and Improvements ------------------------- #228 - Enhance API to provide access to UDT members #2356 - Support PostgreSQL multi table TRUNCATE statement #2536 - DAO should copy the inserted identity value back to the POJO on DAO.insert(P) #2682 - Add org.jooq.Policy, to support shared-schema multi-tenancy and row level security #3751 - Support UDT object names in MatcherStrategy #3862 - Improve Javadoc on DSLContext.executeInsert(), executeUpdate(), and executeDelete() about optimistic locking not applying #4092 - Add a section to the manual showing how to bind LOBs via org.jooq.Binding #5210 - Add code generation option to generate string constants for all object names #6028 - Add JSONFormat.NullFormat to offer different NULL encoding options #6182 - Support renaming Keys and Indexes with matcher strategy #6542 - Add some gifs to the README.md on Github, also for examples #6587 - Add InsertQuery.setRecordForUpdate(Record) #8012 - Override Table.where(Condition) methods in generated tables #8474 - Add support for CREATE TYPE AS <member list> #8617 - Add org.jooq.Generated annotation with RUNTIME retention for generated code #9483 - Add support for { CREATE | ALTER | DROP } MATERIALIZED VIEW #9635 - Add DSL.noTable() for optional, dynamic joins #9906 - Offer a public Maven repository for commercial distributions #10096 - LiquibaseDatabase should create database.liquibaseSchemaName, if configured #10504 - Update manual to show also Gradle/Kotlin configuration examples #11248 - Add Trigger runtime meta model #11251 - Add emulation support for IF [ NOT ] EXISTS to MySQL for DDL on INDEX and VIEW objects #11263 - Add KeyColumnUsage.positionInUniqueConstraint to the InformationSchema for use with XMLDatabase #11485 - Support for Trino DB #11584 - Add parser support for SQL Server CREATE TYPE and DROP TYPE #11944 - Add Firebird 4.0 native support for DELETE .. ORDER BY and UPDATE .. ORDER BY #12052 - Add experimental DuckDB support #12083 - Work around missing support for REMARKS on DatabaseMetaData.getColumns() #12270 - Add Javadoc hints about Record.changed() values to InsertValuesStep[N].valuesOfRecords(...) #12341 - Add a Records::intoHierarchy Collector to turn Result into tree representations #12493 - Support INSERTING, UPDATING, DELETING in PostgreSQL via TG_OP #12747 - Add support for Informix UDTs #12985 - Create an official jooq-codegen-gradle plugin #13065 - Document the InlineDerivedTable feature #13295 - Allow for specifying both <name> and <binding> / <converter> in <forcedType> #13301 - Allow kotlin pojos to not have defaulted constructor parameters #13639 - Add support for to-many path expressions #13786 - Parser should support TIMESTAMP 'YYYY-MM-DD' and TIME 'HH:MM' literals #13912 - Simplify SQL Server's RETURNING emulation in the absence of triggers #13947 - Support CockroachDB 23 user defined functions #14011 - Add SQLDialect.ORACLE23C #14429 - Builds should log their build date with the logo #14551 - Add more startup tips to be logged with the jOOQ logo #14614 - Implicit JOIN improvements #14756 - Continue work on public query object model API #14777 - Add <E, R : Record1<E>>ResultQuery<R>.fetchValue(): E? extension method to kotlin #14790 - Add DataType.isUUID() #14799 - Add support for TRY_CAST() #14800 - Error when PostgreSQL anonymous block contains dollar quoted string token #14803 - BlobBinding and ClobBinding should fall back to byte[] and String binding if unavailable #14808 - Add more documentation after 3.18 release #14814 - Split Aliased tables section of the manual into subsections #14818 - Add a remark on the Converter Javadoc that implementations must be able to handle NULL #14840 - Apply Settings.batchSize also to other batch API #14876 - Add warnings to manual and Javadoc about ON KEY ambiguity caveats #14895 - Add Javadoc to DAO::insert and DAO::update regarding Settings.returnRecordToPojo #14914 - Add DSL.domain(Name, DataType<T>) and overloads #14932 - Add a jooq.codegen.propertyOverride system property to GenerationTool #14933 - Add the missing DSLContext.fetchValue(TableField, Condition) and other overloads #14934 - Upgrade liquibase-core to 4.21.0 #14953 - Add Javadoc hints about implementation of JSONB::toString, JSONB::hashCode, and JSONB::equals #14967 - Reactive batch implementations should throw UnsupportedOperationException with a message #14975 - Upgrade Jackson to 2.15.0 #14985 - Allow for specifying explicit path joins #14988 - Emulate LATERAL (TableImpl | JoinTable) where not supported #14992 - Join elimination for implicit join paths #14993 - Add a new <matchers/> subelement <foreignKeys/> #14998 - Add code generation flag <implicitJoinPathUnusedConstructors/> to offer an option to stop generating unused implicit join path constructors #15002 - Add native support for NULLS FIRST and NULLS LAST in CockroachDB 23 #15003 - Add SQLDialect.COCKROACHDB_23 #15006 - Support Oracle 23c's new 64k IN list limit #15023 - Add a section to the manual about SQL translation #15024 - Improve Javadoc of lookupLiteral() for generated enums #15025 - Generate annotations on generated EnumType::getLiteral method, if so configured #15050 - Add support for generic org.jooq.log.<logger>=threshold system properties #15051 - Add JooqLogger.isErrorEnabled() #15060 - Add DataType.isOther() #15065 - Upgrade maven plugins #15070 - MiniJAXB should support reading simple elements as attributes #15072 - Add error message to maven-install.sh which doesn't work with Maven 3.9.0 due to MNG-7679 #15075 - maven-install and maven-deploy shell scripts should use -e flag to report more error info #15093 - Add API support for ( UNION | INTERSECT | EXCEPT ) DISTINCT #15103 - Add DSLContext.transactionCoroutine overload accepting CoroutineContext #15117 - Recognise :yugabytedb: JDBC URLs in JDBCUtils #15126 - Add SQLDialect.SQLITE_3_40 #15142 - Support parsing T-SQL's named DEFAULT constraints in CREATE TABLE #15143 - Add native support for CockroachDB 23 DELETE .. USING clause #15144 - Add native support for DELETE .. LIMIT and DELETE .. ORDER BY in CockroachDB #15145 - Add runtime support for CockroachDB 23 UDTs #15148 - Add CockroachDB support for LATERAL #15156 - Add Context.inScope(QueryPart): boolean #15160 - Add parser support for Teradata specific analytic functions #15171 - Upgrade various dependencies #15181 - Remove manual section about interning #15186 - Add a section about operator precedence to the manual #15188 - SelectQueryImpl::toSQLReferenceLimitWithWindowFunctions should use QUALIFY to emulate WITH TIES where possible #15207 - Add a configuration flag to avoid generating DefaultCatalog and DefaultSchema #15209 - Support ad-hoc compilation of programmatic GeneratorStrategy objects in the code generator #15210 - Add code generation flags to avoid overrides of as() methods or rename() methods #15212 - Add <genericConverter/> and <genericBinding/> to allow for passing T and U types to custom Converter and Binding instances #15213 - Support ad-hoc compilation of programmatic Generator or Database objects in the code generator #15230 - Add support for MySQL DECIMAL/FLOAT/DOUBLE/REAL UNSIGNED types in Meta and code generation #15239 - Add Settings.parseMetaViewSource to allow for opting out of parsing view source in MetaImpl #15248 - Add documentation about the nullability of kotlin generated properties in the presence of DEFAULT or IDENTITY expressions #15249 - Add ExecuteContext.skipUpdateCounts to allow for setting the AbstractContext.skipUpdateCounts flag in an ExecuteListener #15258 - Manual section about the QUALIFY clause should reference the QUALIFY transformation section #15261 - Add Javadoc to plain SQL DSL.field() constructors recommending to use code generation or at least pass a DataType #15275 - Update jakarta.xml.bind:jakarta.xml.bind-api from 3.0.0 to 4.0.0 #15276 - Add code generation support for synthetic enums #15277 - Add Replacers.transformPatterns(Configuration) public API to give access to the internal Replacer #15279 - EnumConverter should support org.jooq.EnumType as U type #15281 - Generated code should import user defined types in data type definitions #15293 - Various Meta DDL related issues #15307 - Emulate CREATE SCHEMA with CREATE USER .. NO AUTHENTICATION in Oracle 18c #15315 - Upgrade pgjdbc to 42.6.0 #15316 - Add support for SQLite 3.35 RETURNING #15323 - Add native support for Db2 XML type in DDL, code generator, etc. #15347 - Support single-statement trigger bodies on RDBMS that only support SQL triggers #15350 - Add SQLDialect.H2_2_2_220 #15351 - Add PostgreSQL support for CREATE TRIGGER and DROP TRIGGER #15354 - Emulate REFERENCING clause in CREATE TRIGGER in dialects that don't support it natively #15356 - Add Replacers.mappingTable(Function<? super Table<?>, ? extends Table<?>) #15357 - Add manual sections for built-in Replacers #15372 - Make EACH an optional keyword in FOR EACH ROW / FOR EACH STATEMENT in the parser #15400 - Add a jOOQ-meta-kotlin module for kotlin extensions to the jOOQ-meta module #15401 - Add extension functions for Settings, InformationSchema, MigrationsType #15413 - "Ambiguous match found" warning log should reference qualified field name, if available #15419 - Add support for CockroachDB 21 MATERIALIZED VIEWS #15442 - Upgrade dependencies #15452 - Add parser support for Redshift's DATE_PART_YEAR() function #15453 - Manual section about data type conversion should contain an example showing how to attach a converter to a DataType or Field #15455 - Add InsertSetStep.set(Collection<? extends Record>) and set(Record...) #15464 - Add matcher strategy to name path Table subclasses #15465 - Create manual subsections for matcher strategy #15468 - INSERT .. ON CONFLICT .. DO NOTHING emulation should use MERGE in Firebird 3, HANA #15488 - DefaultRecordMapper should be able to reflectively map multisets into Sets of POJOs #15499 - Upgrade jOOR dependency to 0.9.15 #15509 - Add a log message whenever an exception occurs with the SQLDialect.DEFAULT #15510 - Upgrade scala.version to 2.13.11 #15514 - Upgrade Liquibase to 4.23.1 #15531 - Meta.ddl() exports broken DDL for materialized views #15546 - Add Database.getComments(): Map<Definition, String> #15551 - Add runtime UDT mapping #15554 - JavaWriter should have a Mode reference #15588 - Add support for ALTER TYPE IF EXISTS #15591 - Remove unnecessary line breaks in formatted DDL #15592 - Add missing Asterisk and QualifiedAsterisk.except(Collection<? extends Field<?>>) overloads #15593 - Add support for and emulate CREATE OR REPLACE MATERIALIZED VIEW and other objects #15594 - Add CockroachDB support for CREATE VIEW IF NOT EXISTS #15607 - Add support for COMMENT ON MATERIALIZED VIEW #15608 - Upgrade H2 to 2.2.224 #15611 - Add a disclaimer tip to the DAO section #15620 - Upgrade third party libraries for JDK 21 build #15627 - Add parser support for functions without parameter names #15632 - Support InlineDerivedTables in DML #15635 - Add a Context::scopePart property #15644 - Add Policy::inherited to specify whether child tables should inherit a parent table's policies #15657 - Add link to explanation blog article about inline values from manual #15682 - Emulate INSERT .. DEFAULT VALUES for dialects where no DEFAULT expression exists for DML #15684 - Add support for POSITION() in Informix via INSTR #15685 - Emulate DEFAULT expression in multi row INSERT .. VALUES, where that is emulated with INSERT .. SELECT #15712 - Add documentation about some client side features not working with plain SQL templating #15719 - Remove experimental status of transform patterns and computed columns #15731 - Add a section to the manual highlighting the commercial only or experimental features #15745 - TableDefinition.getTable() should return better meta data #15754 - Add RenderImplicitJoinType.SCALAR_SUBQUERY to allow for configuring the DML implicit join path behaviour also for SELECT #15755 - Add Settings.renderImplicitJoinToManyType: RenderImplicitJoinType to govern the implicit to-many join style #15783 - Add Javadoc to the Query::bind methods indicating that they bind values in the rendered order, not the input order #15807 - Add support for JOIN algorithm hints #15808 - Support H2's USE INDEX hint #15815 - Add more emulation support for ALTER TABLE .. DROP CONSTRAINT IF EXISTS #15822 - Support parsing dynamic intervals in MySQL DATE_ADD() and DATE_SUB() expressions #15824 - Add parser support for STRING_AGG() #15825 - Support parsing a few Oracle DBMS_LOB functions #15835 - Remove workaround for ojdbc bug where JSON_ARRAY() couldn't combine bind parameter marker with FORMAT JSON #15843 - Deprecation log warning about <dateAsTimestamp/> should link to relevant manual section #15844 - Add support for MD5 in SNOWFLAKE dialect #15845 - Upgrade Jackson dependency to 2.16 #15847 - Upgrade com.oracle.database.r2dbc:oracle-r2dbc to version 1.2.0 #15860 - Get SNOWFLAKE dialect up to date #15862 - Remove unnecessary managed JDBC drivers from parent pom.xml #15864 - Add support for PostgreSQL DROP TRIGGER .. ON <table name> #15897 - Offer Java 8 support only in the jOOQ Enterprise Edition #15939 - Add a Don't do This: SELECT DISTINCT section to the manual Breaking changes ---------------- #13694 - Remove pre 3.8 deprecated API and pre 3.8 documentation #14306 - Avoid second ExecuteContext for native implementations of RETURNING #15005 - Add org.jooq.Path<R>, a type to model join paths #15046 - Let SchemaImpl and TableImpl avoid traversal and replacement recursion #15201 - Experimental migrations API changes #15303 - Meta.ddl() generates broken DDL for columns of unknown types #15394 - Exception thrown inside blocking TransactionPublishable gets wrapped by DataAccessException unlike when thrown from non-blocking TransactionPublishable #15476 - Internal DefaultDataType.getDataType(SQLDialect, String) should parse precision and scale and return it #15487 - Turn off <recordsImplementingRecordN/> by default #15634 - Distinguish between Context::qualify and Context::qualifySchema #15872 - QOM.CreateTrigger and related API should work with new org.jooq.Trigger type Deprecations ---------------- #15196 - Deprecate inconsistent DSL.jsonObject(Field...) and DSL.jsonbObject(Field...) overloads #15286 - Add Javadoc to discourage using any m(Class<T>) method if there's an m(DataType<T>) overload #15583 - UDTImpl should use Name instead of String in constructor Bug Fixes --------- #7941 - Allow for using EnumType not referencing any Schema to be used in PostgreSQL #8283 - BatchCRUD does not update optimistic locking version and timestamp values in UpdatableRecord #8439 - PostgreSQL: array(<domain over UUID>) causes exception #8930 - Fix known issues of PL/SQL BOOLEAN type in SQL emulation #10107 - DDLDatabase throws parse error 'DEFAULT custom_function_name()' #10234 - Unable to rename table with qualified target table name #11205 - ORA-38104: Columns referenced in the ON Clause cannot be updated #11311 - HSQLDB MetaImpl based DataTypes are missing length of array element type #11975 - Fix known limitations of embeddable types #12098 - Fix known limitations of the QUALIFY SQL transformation #12456 - Ambiguous match found when using aliases with implicit join and joining the same table twice #12547 - Internal patchIso8601Timestamp() isn't safe for 5 digit years #13171 - Confusing (outdated) gradle examples in manual #13541 - Various runtime errors when using features in dialects that do not support them #13680 - Remove workaround for H2 process hanging when using FINAL TABLE (MERGE ...) #14256 - Syntax error when from current_timestamp when precision bind value is specified for Postgres #14764 - Avoid dialect version lookup in AbstractDatabase, if unnecessary #14769 - <clinit> race conditions in jOOQ internals #14771 - NullPointerException when using plain SQL identity and additional column in INSERT .. RETURNING #14776 - Javadoc contains warning boxes #14780 - Correctly annotate SIMILAR TO operator #14785 - Compilation error in KotlinGenerator generated code when <kotlinNotNullRecordAttributes/> and <recordsGeneratingRecordN/> are both active #14791 - SQLDialect version check throws NumberFormatException in Percona DB #14801 - JavaGenerator creates broken code for arrays when kotlinNotNullPojoAttributes is true #14802 - [#14801] Fix Java String generation for non-nullable arrays #14817 - Nullable kotlin records break columns with default values #14830 - Compilation error in generated code when table valued function returns table with client side computed columns and <recordsImplementingRecordN/> is active #14833 - Version support check shouldn't log error message for MockConnection #14839 - PL/SQL procedure returns wrong result when combining boolean and record type as input #14841 - ERROR: type "blob" does not exist when casting NULL as a domain converted as user defined type using class literal #14843 - Switch links from /doc/dev to /doc/latest for recently added diagnostics #14845 - Upgrade Spring to mitigate CVE-2023-20861 #14849 - ROLLUP, CUBE should generate Keyword, not Name #14853 - Kotlin Code generator generates invalid code for embeddables in POJOs when immutable interfaces is activated #14855 - Compilation error in generated code for embeddable properties when reducing visibility to internal, and generating interfaces #14872 - Regression when using INSERT .. RETURNING pre MariaDB 10.5 #14875 - Inconsistent implementation of TableImpl::equals and TableImpl::hashCode when comparing generated tables with plain SQL ones #14882 - Generate nullable annotations also on record constructor, when <pojosAsJavaRecordClasses/> is set #14883 - Regression: KotlinGenerator produces superfluous public keyword for overriding methods #14890 - QUALIFY transformation should unalias columns again #14902 - Work around Oracle 23c regression when nesting aggregate JSON functions in MULTISET #14906 - Internal API leaks into client code via generated table's join(TableLike<?>, JoinType) method #14908 - Missing parentheses when second subquery in set operation contains deep nesting #14916 - Compilation error with embedded domains and postgres types #14923 - Explicitly set locale to English in maven-javadoc-plugin #14924 - Explicitly set locale to English in maven-javadoc-plugin #14930 - jOOQ-meta should avoid redundancies between getTables0() and sources() methods to fetch view sources #14937 - Support NULL bind values of type Interval in R2DBC integration #14938 - Unstable ordering of Derby generated foreign keys #14942 - Manual section about code generation configuration contains wrong comment about LiquibaseDatabase #14944 - Wrong warning logged regarding CockroachDB version support #14949 - Upgrade spring-core dependency to mitigate CVE-2023-20863 #14960 - No-arg DefaultConfiguration() constructor clones default settings twice #14991 - KotlinGenerator produces wrong code with kotlinNotNullPojoAttributes when multiple references to an embeddable have different nullability #14995 - OffsetDateTimeRange javadoc should reference tstzrange not tsrange #14996 - #14995 fix OffsetDateTimeRange javadoc #14997 - Use awaitSingle instead of awaitFirstOrNull in transactionCoroutine to correctly sequence transaction script #15007 - Change DSL.multisetAgg() overload accepting Field<?>...|Collection<? extends Field<?>> to work with SelectField<?> instead #15008 - Cannot pass Table reference to row() constructor in array or list #15013 - GROUPING() support was only added in MySQL 8 #15015 - A few MySQL 5.6 related fixes #15022 - SchemaImpl and CatalogImpl $replace() and $traverse() methods shouldn't recurse into Name or Comment parts #15028 - R2DBC bind value related exceptions produce misleading error message #15035 - Support NULL bind values of type Year in R2DBC integration #15039 - The exported DDL of the table for POSTGRES_15 dialect is missing a default value #15042 - Support NULL bind values of type UUID in R2DBC integration #15048 - DDLDatabase defaultNameCase=lower doesn't work with ENUM types #15052 - JooqLogger log methods don't check if log level is enabled #15056 - Parser meta lookup fails when using qualified asterisk on a table alias #15088 - Misleading error message when ON KEY finds ambiguous keys #15095 - Generate property access syntax in KotlinGenerator generated tables #15096 - Ambiguous type name warning for non-ambiguous type name in OracleDatabase #15097 - Compilation error in Oracle generated code for package type in PL/SQL RECORD constructor #15104 - InlineDerivedTable should wrap query lazily #15114 - Upgrade sqlite dependency to 3.42.0.0 to mitigate CVE-2023-32697 #15115 - Improve error message when unversioned, row based optimistic locking doesn't work with DAOs and POJOs #15121 - Derived column list doesn't work on InlineDerivedTable #15125 - Handle SQLite's incompatible change of implementation for LOG(x) #15127 - DefaultConfiguration::toString logs wrong flags in R2DBC context #15149 - PostgresDatabase and subtypes may produce wrong table comments in presence of stored functions #15154 - Fix various Javadoc links #15168 - NullPointerException in code generator when omitting <target> directory #15182 - Add tests to prevent leaking of invisible, internal API through generated code #15183 - Compilation error in generated DAO code when visibility of a field is changed to private #15190 - DISTINCT .. LIMIT emulation renders redundant DENSE_RANK() OVER (ORDER BY ...) clauses #15195 - H2 dialect should cast binary data of unknown length as VARBINARY, not as BINARY #15202 - Add missing Experimental annotation to migrations API types #15218 - NullPointerException in AbstractMeta::lookupTable and other methods, when there is no DefaultCatalog #15238 - MetaImpl::ddl() should produce plain SQL CREATE VIEW statements if it can't parse the view contents #15250 - LoggerListener logs some batch queries twice, when using BatchMultiple #15253 - ScalaGenerator produces wrong code when generator strategy adds multiple interfaces to legacy enum type #15270 - Wrong implementation of SelectQueryImpl::wrapQueryExpressionBodyInDerivedTable in jOOQ Open Source Edition #15278 - CheckDefinition.getSource() should return CheckDefinition.getCheckClause() contents #15282 - Wrong encoding of lists in generated programmatic code generation configuration examples #15291 - Meta.ddl() export generates wrong DDL for constraints with USING INDEX clause in Oracle #15302 - Meta.ddl() generates broken DDL for smallserial columns #15318 - MetaImpl is missing view source code or unique constraints for objects in other catalogs #15319 - Error when generating code from a MariaDB database containing packages #15326 - Meta.ddl() should export tables first, then views #15331 - Batch::executeAsync throws NullPointerException when executed with R2DBC driver #15336 - Parser error when using SET new.x = y syntax in triggers #15341 - Bad syntax in Firebird when creating triggers for unquoted table names #15359 - Block::$replace doesn't replace anything #15364 - Wrong deprecation notices in PostgresDSL #15366 - Avoid generating sort specification in indexes in dialects that don't support it #15375 - Table with 255 columns generates record and POJO objects whose constructors have too many parameters #15383 - Compilation error in generated code when global object references conflict with schema names #15388 - Settings.metaIncludeSystemIndexes doesn't work for system indexes of unnamed constraints in HSQLDB #15395 - Exception when MockResult contains UDTRecord #15402 - Bad formatting of hints at the end of maven-install.sh scripts #15412 - Missing CAST in generated MERGE statement when using inline values in PostgreSQL 15's ON DUPLICATE KEY UPDATE emulation #15414 - Can't generate code using CockroachDB materialized view #15423 - Table list to ANSI JOIN transformation doesn't work if table declarations are fully qualified, but references are not #15433 - AutoConverter loses nanosecond precision when converting from Instant to LocalDateTime or OffsetDateTime #15472 - Code generation fails on BigQuery when querying INFORMATION_SCHEMA without a DefaultDataset being specified #15473 - Failure in MetaImpl.MetaSchema::source in BigQueryDatabase #15478 - AutoConverter should be lenient about TIME type fractional seconds #15482 - Can't invoke default methods on proxied types returned by DefaultRecordMapper in JDK 9 or more #15497 - Work around SQL Server's 1000 row value limitation for INSERT statements #15504 - Query::isExecutable should be checked in the R2DBC implementation, allowing no-ops for non-executable queries #15507 - Fix various UDT related issues in KotlinGenerator #15511 - Manual should stop recommending use of deprecated DefaultExecuteListener or DefaultRecordListener #15524 - Missing Stringly annotation on String... varargs parameters #15553 - AbstractTypedElementDefinition should cache resolvedType property only once per file #15555 - Datetime precision isn't maintained by code generator for domain types #15559 - KotlinGenerator - isKotlinNotNullPojoAttributes setting prevents generated DAO to set serial ID to pojo #15563 - DefaultRecordMapper should skip most mappers when an instance is provided #15564 - MutablePOJOMapper should be able to map to instance, even if there isn't a default constructor #15569 - Record.into(recordInstance) should modify argument record #15574 - DefaultOtherBinding shouldn't create string literals for inline values for numeric data types #15582 - MariaDB UPDATE .. RETURNING emulation should work on tables with unique constraints only #15584 - Install shell/batch scripts should be clearer about Java 17+ support #15595 - DefaultStringBinding should bind java.sql.Clob for CLOB types in Oracle MERGE statements #15598 - Fix DefaultRecordMapper Javadoc to reflect actual behaviour #15602 - Plain SQL Javadoc disclaimer is absent on api generator generated step methods #15610 - Bump org.eclipse.jgit:org.eclipse.jgit from 5.9.0.202009080501-r to 6.6.1.202309021850-r in /jOOQ-migrations #15614 - Wrong Support annotation on COMMENT ON COLUMN for MariaDB #15619 - On JDK 21, generated code should apply "this-escape" warning suppression #15621 - Synthetic comment flag <deprecated> should produce @Deprecated annotation in addition to Javadoc #15623 - Stop using deprecated DSL API in jOOQ-meta #15625 - QOM.Delete mutators produce a copy that always has a RETURNING clause #15629 - InlineDerivedTable can't be outer joined #15639 - RenderMapping doesn't apply to QualifiedRowid #15650 - DefaultConfiguration doesn't serialize AuditProvider or TransformProvider #15656 - InlineDerivedTable doesn't maintain contained table's meta data in some cases #15658 - Copy paste errors in likeIgnoreCase and containsIgnoreCase Javadoc #15668 - INSERT .. ON DUPLICATE KEY UPDATE emulation mustn't silently insert the last row only in Derby multi row inserts #15673 - Domains aren't generated if they don't have a CHECK constraint associated with them, in HSQLDB #15677 - Code generator doesn't generate multiple check constraints for DOMAIN types #15683 - Incorrect DEFAULT values generated for Informix #15686 - Generated DEFAULT expressions should always be syntactically valid for all data types in HANA #15687 - HANA sort indirection doesn't work with bind values #15693 - Fix a typo in a Tip #15697 - Upgrade jgit from the jOOQ-migrations prototype to 6.6.1.202309021850-r #15702 - Reactive transaction hangs when exception thrown in lambda constructing reactive flow #15714 - Possible compilation errors in generated code when column names contain double quotes #15724 - BindingSetStatementContext should reference actual ExecuteContext, if available #15735 - Ill-formed Javadoc causes JDK 21 javadoc tool to crash #15752 - JSONB inline values should be rendered using JSONB.data() not JSONB.toString() #15756 - Implicit JOIN implementation for DML is incorrect if paths navigate self joins #15760 - Compile errors of generated classes using scala 3 #15767 - MiniJAXB::marshal(XMLAppendable, OutputStream) does not flush decorating writer #15799 - LazyVal::generatesCast should return true #15803 - MetaImpl reports system indexes for Derby 10.16 #15816 - Misleading example in manual's section about the CREATE TRIGGER statement #15820 - Incorrect query generated when combining SEEK with GROUP BY #15823 - Wrong grammar for intervalLiteral in manual #15826 - Parser cannot parse undocumented reverse syntactic order of FOR UPDATE and LIMIT clauses from PostgreSQL #15828 - Support overlapping embeddables when enabling <embeddablePrimaryKeys/> #15832 - Oracle UDTs are sometimes inlined as [UDT] instead of IDENTIFIER(CONTENT) #15848 - Compilation error in KotlinGenerator generated code for tables containing a FROM column, when <interfaces> is activated #15850 - Accidental override when enabling <interfaces> for tables with columns X and IS_X in Kotlin #15873 - IllegalArgumentException when calling UpdatableRecord methods on tables with embedded domains that replace their underlying fields #15876 - Internal RecordDataType.getDataType() should be non-nullable for records consisting of all non-null fields #15883 - Compilation error in generated code when using <embeddableDomains/> and the domain is part of a composite key #15899 - Upgrade logback dependency in jOOQ-jooby-example to mitigate CVE-2023-6378 #15901 - Incorrect ExecuteListener Javadoc regarding ExecuteListener lifecycle #15917 - Swapped examples in manual section "group-by-tables" #15918 - AbstractDatabase::markUsed doesn't work in some edge cases #15927 - SnowflakeDataType is missing references to Snowflake's JDBC-internal spellings of TIMESTAMPNTZ, TIMESTAMPLTZ, TIMESTAMPTZ -- You received this message because you are subscribed to the Google Groups "jOOQ User Group" group. To unsubscribe from this group and stop receiving emails from it, send an email to [email protected]. To view this discussion on the web visit https://groups.google.com/d/msgid/jooq-user/6dd92c2d-4a7a-4b80-bb2f-7ac1e65639c8n%40googlegroups.com.
