jOOQ Changelog

What's new in jOOQ 3.19.8

May 2, 2024

Bug Fixes:
Auto wrap Field arguments to a Routine's Object typed parameter in Field<Object>
Work around lack of support for INSERT .. SELECT .. UNION [ ALL ] SELECT in SingleStore
DELETE .. ORDER BY .. LIMIT on partitioned tables without unique constraint uses non-unique ctid for self joins
Cannot configure matchers using jOOQ-codegen-gradle plugin
SAXParseException warnings when using jOOQ-codegen-gradle or any other MiniJAXB.unmarshal() usage
Time zone information lost when fetching TIMETZ[] value in PostgreSQL
Work around HSQLDB bug where wrong LocalTime value is fetched when using bind values of type LocalTime[]
Wrong cast type name when casting value to NCLOB in Firebird
Fix order of NOT NULL and DEFAULT clauses in BigQuery CREATE TABLE statements

New in jOOQ 3.19.7 (Apr 4, 2024)

New in jOOQ 3.19.6 (Mar 8, 2024)

New in jOOQ 3.19.5 (Feb 27, 2024)

New in jOOQ 3.19.4 (Feb 20, 2024)

Features and Improvements:
Add Context.scopeParts(Class<Q>): Iterable<Q> to allow for iterating over the values that are currently in scope
Bug Fixes:
jOOQ-codegen-gradle fails with UnknownDomainObjectException when java plugin isn't applied first
Generated implicit join alias collision when child table foreign keys share the same name
RenderTable.WHEN_AMBIGUOUS_COLUMNS doesn't cover all ambiguous column name cases
RenderTable.WHEN_MULTIPLE_TABLES doesn't work correctly in correlated subqueries
Maximum consumed results reached when Hikari close a SQL Server connection, leading to excessive logging
jOOQ-codegen-gradle doesn't consider basedir property for its OutputDirectory
%ROWTYPE UDT types generate invalid system columns when underlying table references object types
Settings.returnDefaultOnUpdatableRecord and Settings.returnComputedOnUpdatableRecord don't work for replacing embeddables
Overall performance improvement in AbstractNamed.hashCode() specialisations by avoiding Name::append
Remove internal AbstractContext::toggle utilities
AbstractScope::dsl, ::settings, ::dialect, and ::family should avoid unnecessary null-checks on Configuration
BatchCRUD implementation should extract bind values with SQL string in one go
Emulate LIMIT 0 where not supported
Wrong Support annotation on CREATE TRIGGER for INFORMIX
IndexOutOfBoundsException in DerbyDatabase when <includeExcludeColumns/> excludes a column from an index
Avoid allocating DataMap in short lived Scope implementations
Cache TableRecord Constructor in TableImpl for use in Tools.recordFactory()
JavaGenerator doesn't generate serialVersionUID in Path classes
Avoid allocating Collections.nCopies in ScopeStack
Avoid allocating JoinNode in scope registration of tables if unnecessary
Avoid constructing DSL.name() for constant internal names
Refactor QualifiedName to improve performance
name(null, "") should equal to name("")
Result::formatXML should omit type attribute on columns whose type is unknown
Meta::ddl generates incorrect queries for SQL Server (max) lengths
Remove unnecessary up-to-date prevention in jOOQ-codegen-gradle plugin
Wrong SQL generated for CREATE TABLE in non-default schemas for DuckDB
MULTISET equality is ORDER dependent in dialects without support for correlated derived tables
Can't parse MySQL ALTER TABLE .. DROP .., DROP .. syntax

New in jOOQ 3.19.3 (Jan 19, 2024)

New in jOOQ 3.19.2 (Jan 12, 2024)

Features and Improvements:
16023 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)
16032 SQLPerformanceWarning should log hint about gathering dictionary statistics in OracleDatabase
16045 org.jooq.tools.Convert should delegate to org.jooq.impl.Convert, instead of duplicating implementations
Breaking changes
16058 Remove mandatory dependency from compileJava to jOOQ-codegen-gradle tasks
Bug Fixes:
15976 Wrong statement generated for MySQL when leading unqualified asterisk is used with plain SQL template table
15983 Comparison predicates and quantified comparison predicates should hint array type to org.jooq.impl.Array for empty expression array casts
15985 Regression in PostgreSQL query using 'x' = ANY (ARRAY [(SELECT ARRAY ['x'])]) style quantified comparison predicate on multi dimensional arrays
15994 RenderTable.WHEN_MULTIPLE_TABLES only works with table lists, not with joins
16004 Misleading XSD warnings logged when working with MiniJAXB
16010 Code generator fails when generating triggers because TriggerExecution value is null
16014 Compilation error in KotlinGenerator generated code when GeneratorStrategy produces identifiers conflicting with property access syntax of AbstractRoutine getters
16026 Cannot project TableAsField if table contains embeddables in PostgreSQL
16030 Regression: NullPointerException in KotlinGenerator generated code when InlineDerivedTable constructor calls TableImpl.where(null)
16038 ScalaGenerator produces duplicate paths for cyclic foreign key relationships
16040 Compilation error in JavaGenerator generated code when <pojosAsJavaRecordClasses> is active and a table references a UDT
16049 DATE column in Oracle is null when fetched through multiset
16057 Cannot look up tasks.named("jooqCodegen") from gradle scripts
16060 MetaSQL lookups are done with SQLDialect.family(), not SQLDialect
16063 Regression: Table metadata calculation for Oracle does not work after 3.19.0
16066 Add Javadoc to all XJC-generated "withers" and setters of boolean types

New in jOOQ 3.19.0 (Dec 16, 2023)

Features and Improvements:
Enhance API to provide access to UDT members
Support PostgreSQL multi table TRUNCATE statement
DAO should copy the inserted identity value back to the POJO on DAO.insert(P)
Add org.jooq.Policy, to support shared-schema multi-tenancy and row level security
Support UDT object names in MatcherStrategy
Improve Javadoc on DSLContext.executeInsert(), executeUpdate(), and executeDelete() about optimistic locking not applying
Add a section to the manual showing how to bind LOBs via org.jooq.Binding
Add code generation option to generate string constants for all object names
Add JSONFormat.NullFormat to offer different NULL encoding options
Support renaming Keys and Indexes with matcher strategy
Add some gifs to the README.md on Github, also for examples
Add InsertQuery.setRecordForUpdate(Record)
Override Table.where(Condition) methods in generated tables
Add support for CREATE TYPE AS <member list>
Add org.jooq.Generated annotation with RUNTIME retention for generated code
Add support for { CREATE | ALTER | DROP } MATERIALIZED VIEW
Add DSL.noTable() for optional, dynamic joins
Offer a public Maven repository for commercial distributions
LiquibaseDatabase should create database.liquibaseSchemaName, if configured
Update manual to show also Gradle/Kotlin configuration examples
Add Trigger runtime meta model
Add emulation support for IF [ NOT ] EXISTS to MySQL for DDL on INDEX and VIEW objects
Add KeyColumnUsage.positionInUniqueConstraint to the InformationSchema for use with XMLDatabase
Support for Trino DB
Add parser support for SQL Server CREATE TYPE and DROP TYPE
Add Firebird 4.0 native support for DELETE .. ORDER BY and UPDATE .. ORDER BY
Add experimental DuckDB support
Work around missing support for REMARKS on DatabaseMetaData.getColumns()
Add Javadoc hints about Record.changed() values to InsertValuesStep[N].valuesOfRecords(...)
Add a Records::intoHierarchy Collector to turn Result into tree representations
Support INSERTING, UPDATING, DELETING in PostgreSQL via TG_OP
Add support for Informix UDTs
Create an official jooq-codegen-gradle plugin
Document the InlineDerivedTable feature
Allow for specifying both <name> and <binding> / <converter> in <forcedType>
Allow kotlin pojos to not have defaulted constructor parameters
Add support for to-many path expressions
Parser should support TIMESTAMP 'YYYY-MM-DD' and TIME 'HH:MM' literals
Simplify SQL Server's RETURNING emulation in the absence of triggers
Support CockroachDB 23 user defined functions
Add SQLDialect.ORACLE23C
Builds should log their build date with the logo
Add more startup tips to be logged with the jOOQ logo
Implicit JOIN improvements
Continue work on public query object model API
Add <E, R : Record1<E>>ResultQuery<R>.fetchValue(): E? extension method to kotlin
Add DataType.isUUID()
Add support for TRY_CAST()
Error when PostgreSQL anonymous block contains dollar quoted string token
BlobBinding and ClobBinding should fall back to byte[] and String binding if unavailable
Add more documentation after 3.18 release
Split Aliased tables section of the manual into subsections
Add a remark on the Converter Javadoc that implementations must be able to handle NULL
Apply Settings.batchSize also to other batch API
Add warnings to manual and Javadoc about ON KEY ambiguity caveats
Add Javadoc to DAO::insert and DAO::update regarding Settings.returnRecordToPojo
Add DSL.domain(Name, DataType<T>) and overloads
Add a jooq.codegen.propertyOverride system property to GenerationTool
Add the missing DSLContext.fetchValue(TableField, Condition) and other overloads
Upgrade liquibase-core to 4.21.0
Add Javadoc hints about implementation of JSONB::toString, JSONB::hashCode, and JSONB::equals
Reactive batch implementations should throw UnsupportedOperationException with a message
Upgrade Jackson to 2.15.0
Allow for specifying explicit path joins
Emulate LATERAL (TableImpl | JoinTable) where not supported
Join elimination for implicit join paths
Add a new <matchers/> subelement <foreignKeys/>
Add code generation flag <implicitJoinPathUnusedConstructors/> to offer an option to stop generating unused implicit join path constructors
Add native support for NULLS FIRST and NULLS LAST in CockroachDB 23
Add SQLDialect.COCKROACHDB_23
Support Oracle 23c's new 64k IN list limit
Add a section to the manual about SQL translation
Improve Javadoc of lookupLiteral() for generated enums
Generate annotations on generated EnumType::getLiteral method, if so configured
Add support for generic org.jooq.log.<logger>=threshold system properties
Add JooqLogger.isErrorEnabled()
Add DataType.isOther()
Upgrade maven plugins
MiniJAXB should support reading simple elements as attributes
Add error message to maven-install.sh which doesn't work with Maven 3.9.0 due to MNG-7679
maven-install and maven-deploy shell scripts should use -e flag to report more error info
Add API support for ( UNION | INTERSECT | EXCEPT ) DISTINCT
Add DSLContext.transactionCoroutine overload accepting CoroutineContext
Recognise :yugabytedb: JDBC URLs in JDBCUtils
Add SQLDialect.SQLITE_3_40
Support parsing T-SQL's named DEFAULT constraints in CREATE TABLE
Add native support for CockroachDB 23 DELETE .. USING clause
Add native support for DELETE .. LIMIT and DELETE .. ORDER BY in CockroachDB
Add runtime support for CockroachDB 23 UDTs
Add CockroachDB support for LATERAL
Add Context.inScope(QueryPart): boolean
Add parser support for Teradata specific analytic functions
Upgrade various dependencies
Remove manual section about interning
Add a section about operator precedence to the manual
SelectQueryImpl::toSQLReferenceLimitWithWindowFunctions should use QUALIFY to emulate WITH TIES where possible
Add a configuration flag to avoid generating DefaultCatalog and DefaultSchema
Support ad-hoc compilation of programmatic GeneratorStrategy objects in the code generator
Add code generation flags to avoid overrides of as() methods or rename() methods
Add <genericConverter/> and <genericBinding/> to allow for passing T and U types to custom Converter and Binding instances
Support ad-hoc compilation of programmatic Generator or Database objects in the code generator
Add support for MySQL DECIMAL/FLOAT/DOUBLE/REAL UNSIGNED types in Meta and code generation
Add Settings.parseMetaViewSource to allow for opting out of parsing view source in MetaImpl
Add documentation about the nullability of kotlin generated properties in the presence of DEFAULT or IDENTITY expressions
Add ExecuteContext.skipUpdateCounts to allow for setting the AbstractContext.skipUpdateCounts flag in an ExecuteListener
Manual section about the QUALIFY clause should reference the QUALIFY transformation section
Add Javadoc to plain SQL DSL.field() constructors recommending to use code generation or at least pass a DataType
Update jakarta.xml.bind:jakarta.xml.bind-api from 3.0.0 to 4.0.0
Add code generation support for synthetic enums
Add Replacers.transformPatterns(Configuration) public API to give access to the internal Replacer
EnumConverter should support org.jooq.EnumType as U type
Generated code should import user defined types in data type definitions
Various Meta DDL related issues
Emulate CREATE SCHEMA with CREATE USER .. NO AUTHENTICATION in Oracle 18c
Upgrade pgjdbc to 42.6.0
Add support for SQLite 3.35 RETURNING
Add native support for Db2 XML type in DDL, code generator, etc.
Support single-statement trigger bodies on RDBMS that only support SQL triggers
Add SQLDialect.H2_2_2_220
Add PostgreSQL support for CREATE TRIGGER and DROP TRIGGER
Emulate REFERENCING clause in CREATE TRIGGER in dialects that don't support it natively
Add Replacers.mappingTable(Function<? super Table<?>, ? extends Table<?>)
Add manual sections for built-in Replacers
Make EACH an optional keyword in FOR EACH ROW / FOR EACH STATEMENT in the parser
Add a jOOQ-meta-kotlin module for kotlin extensions to the jOOQ-meta module
Add extension functions for Settings, InformationSchema, MigrationsType
"Ambiguous match found" warning log should reference qualified field name, if available
Add support for CockroachDB 21 MATERIALIZED VIEWS
Upgrade dependencies
Add parser support for Redshift's DATE_PART_YEAR() function
Manual section about data type conversion should contain an example showing how to attach a converter to a DataType or Field
Add InsertSetStep.set(Collection<? extends Record>) and set(Record...)
Add matcher strategy to name path Table subclasses
Create manual subsections for matcher strategy
INSERT .. ON CONFLICT .. DO NOTHING emulation should use MERGE in Firebird 3, HANA
DefaultRecordMapper should be able to reflectively map multisets into Sets of POJOs
Upgrade jOOR dependency to 0.9.15
Add a log message whenever an exception occurs with the SQLDialect.DEFAULT
Upgrade scala.version to 2.13.11
Upgrade Liquibase to 4.23.1
Meta.ddl() exports broken DDL for materialized views
Add Database.getComments(): Map<Definition, String>
Add runtime UDT mapping
JavaWriter should have a Mode reference
Add support for ALTER TYPE IF EXISTS
Remove unnecessary line breaks in formatted DDL
Add missing Asterisk and QualifiedAsterisk.except(Collection<? extends Field<?>>) overloads
Add support for and emulate CREATE OR REPLACE MATERIALIZED VIEW and other objects
Add CockroachDB support for CREATE VIEW IF NOT EXISTS
Add support for COMMENT ON MATERIALIZED VIEW
Upgrade H2 to 2.2.224
Add a disclaimer tip to the DAO section
Upgrade third party libraries for JDK 21 build
Add parser support for functions without parameter names
Support InlineDerivedTables in DML
Add a Context::scopePart property
Add Policy::inherited to specify whether child tables should inherit a parent table's policies
Add link to explanation blog article about inline values from manual
Emulate INSERT .. DEFAULT VALUES for dialects where no DEFAULT expression exists for DML
Add support for POSITION() in Informix via INSTR
Emulate DEFAULT expression in multi row INSERT .. VALUES, where that is emulated with INSERT .. SELECT
Add documentation about some client side features not working with plain SQL templating
Remove experimental status of transform patterns and computed columns
Add a section to the manual highlighting the commercial only or experimental features
TableDefinition.getTable() should return better meta data
Add RenderImplicitJoinType.SCALAR_SUBQUERY to allow for configuring the DML implicit join path behaviour also for SELECT
Add Settings.renderImplicitJoinToManyType: RenderImplicitJoinType to govern the implicit to-many join style
Add Javadoc to the Query::bind methods indicating that they bind values in the rendered order, not the input order
Add support for JOIN algorithm hints
Support H2's USE INDEX hint
Add more emulation support for ALTER TABLE .. DROP CONSTRAINT IF EXISTS
Support parsing dynamic intervals in MySQL DATE_ADD() and DATE_SUB() expressions
Add parser support for STRING_AGG()
Support parsing a few Oracle DBMS_LOB functions
Remove workaround for ojdbc bug where JSON_ARRAY() couldn't combine bind parameter marker with FORMAT JSON
Deprecation log warning about <dateAsTimestamp/> should link to relevant manual section
Add support for MD5 in SNOWFLAKE dialect
Upgrade Jackson dependency to 2.16
Upgrade com.oracle.database.r2dbc:oracle-r2dbc to version 1.2.0
Get SNOWFLAKE dialect up to date
Remove unnecessary managed JDBC drivers from parent pom.xml
Add support for PostgreSQL DROP TRIGGER .. ON <table name>
Offer Java 8 support only in the jOOQ Enterprise Edition
Add a Don't do This: SELECT DISTINCT section to the manual
Breaking changes:
Remove pre 3.8 deprecated API and pre 3.8 documentation
Avoid second ExecuteContext for native implementations of RETURNING
Add org.jooq.Path<R>, a type to model join paths
Let SchemaImpl and TableImpl avoid traversal and replacement recursion
Experimental migrations API changes
Meta.ddl() generates broken DDL for columns of unknown types
Exception thrown inside blocking TransactionPublishable gets wrapped by DataAccessException unlike when thrown from non-blocking TransactionPublishable
Internal DefaultDataType.getDataType(SQLDialect, String) should parse precision and scale and return it
Turn off <recordsImplementingRecordN/> by default
Distinguish between Context::qualify and Context::qualifySchema
QOM.CreateTrigger and related API should work with new org.jooq.Trigger type
Deprecations:
Deprecate inconsistent DSL.jsonObject(Field...) and DSL.jsonbObject(Field...) overloads
Add Javadoc to discourage using any m(Class<T>) method if there's an m(DataType<T>) overload
UDTImpl should use Name instead of String in constructor
Bug Fixes:
Allow for using EnumType not referencing any Schema to be used in PostgreSQL
BatchCRUD does not update optimistic locking version and timestamp values in UpdatableRecord
PostgreSQL: array(<domain over UUID>) causes exception
Fix known issues of PL/SQL BOOLEAN type in SQL emulation
DDLDatabase throws parse error 'DEFAULT custom_function_name()'
Unable to rename table with qualified target table name
ORA-38104: Columns referenced in the ON Clause cannot be updated
HSQLDB MetaImpl based DataTypes are missing length of array element type
Fix known limitations of embeddable types
Fix known limitations of the QUALIFY SQL transformation
Ambiguous match found when using aliases with implicit join and joining the same table twice
Internal patchIso8601Timestamp() isn't safe for 5 digit years
Confusing (outdated) gradle examples in manual
Various runtime errors when using features in dialects that do not support them
Remove workaround for H2 process hanging when using FINAL TABLE (MERGE ...)
Syntax error when from current_timestamp when precision bind value is specified for Postgres
Avoid dialect version lookup in AbstractDatabase, if unnecessary
<clinit> race conditions in jOOQ internals
NullPointerException when using plain SQL identity and additional column in INSERT .. RETURNING
Javadoc contains warning boxes
Correctly annotate SIMILAR TO operator
Compilation error in KotlinGenerator generated code when <kotlinNotNullRecordAttributes/> and <recordsGeneratingRecordN/> are both active
SQLDialect version check throws NumberFormatException in Percona DB
JavaGenerator creates broken code for arrays when kotlinNotNullPojoAttributes is true
[#14801] Fix Java String generation for non-nullable arrays
Nullable kotlin records break columns with default values
Compilation error in generated code when table valued function returns table with client side computed columns and <recordsImplementingRecordN/> is active
Version support check shouldn't log error message for MockConnection
PL/SQL procedure returns wrong result when combining boolean and record type as input
ERROR: type "blob" does not exist when casting NULL as a domain converted as user defined type using class literal
Switch links from /doc/dev to /doc/latest for recently added diagnostics
Upgrade Spring to mitigate CVE-2023-20861
ROLLUP, CUBE should generate Keyword, not Name
Kotlin Code generator generates invalid code for embeddables in POJOs when immutable interfaces is activated
Compilation error in generated code for embeddable properties when reducing visibility to internal, and generating interfaces
Regression when using INSERT .. RETURNING pre MariaDB 10.5
Inconsistent implementation of TableImpl::equals and TableImpl::hashCode when comparing generated tables with plain SQL ones
Generate nullable annotations also on record constructor, when <pojosAsJavaRecordClasses/> is set
Regression: KotlinGenerator produces superfluous public keyword for overriding methods
QUALIFY transformation should unalias columns again
Work around Oracle 23c regression when nesting aggregate JSON functions in MULTISET
Internal API leaks into client code via generated table's join(TableLike<?>, JoinType) method
Missing parentheses when second subquery in set operation contains deep nesting
Compilation error with embedded domains and postgres types
Explicitly set locale to English in maven-javadoc-plugin
Explicitly set locale to English in maven-javadoc-plugin
jOOQ-meta should avoid redundancies between getTables0() and sources() methods to fetch view sources
Support NULL bind values of type Interval in R2DBC integration
Unstable ordering of Derby generated foreign keys
Manual section about code generation configuration contains wrong comment about LiquibaseDatabase
Wrong warning logged regarding CockroachDB version support
Upgrade spring-core dependency to mitigate CVE-2023-20863
No-arg DefaultConfiguration() constructor clones default settings twice
KotlinGenerator produces wrong code with kotlinNotNullPojoAttributes when multiple references to an embeddable have different nullability
OffsetDateTimeRange javadoc should reference tstzrange not tsrange
#14995 fix OffsetDateTimeRange javadoc
Use awaitSingle instead of awaitFirstOrNull in transactionCoroutine to correctly sequence transaction script
Change DSL.multisetAgg() overload accepting Field<?>...|Collection<? extends Field<?>> to work with SelectField<?> instead
Cannot pass Table reference to row() constructor in array or list
GROUPING() support was only added in MySQL 8
A few MySQL 5.6 related fixes
SchemaImpl and CatalogImpl $replace() and $traverse() methods shouldn't recurse into Name or Comment parts
R2DBC bind value related exceptions produce misleading error message
Support NULL bind values of type Year in R2DBC integration
The exported DDL of the table for POSTGRES_15 dialect is missing a default value
Support NULL bind values of type UUID in R2DBC integration
DDLDatabase defaultNameCase=lower doesn't work with ENUM types
JooqLogger log methods don't check if log level is enabled
Parser meta lookup fails when using qualified asterisk on a table alias
Misleading error message when ON KEY finds ambiguous keys
Generate property access syntax in KotlinGenerator generated tables
Ambiguous type name warning for non-ambiguous type name in OracleDatabase
Compilation error in Oracle generated code for package type in PL/SQL RECORD constructor
InlineDerivedTable should wrap query lazily
Upgrade sqlite dependency to 3.42.0.0 to mitigate CVE-2023-32697
Improve error message when unversioned, row based optimistic locking doesn't work with DAOs and POJOs
Derived column list doesn't work on InlineDerivedTable
Handle SQLite's incompatible change of implementation for LOG(x)
DefaultConfiguration::toString logs wrong flags in R2DBC context
PostgresDatabase and subtypes may produce wrong table comments in presence of stored functions
Fix various Javadoc links
NullPointerException in code generator when omitting <target> directory
Add tests to prevent leaking of invisible, internal API through generated code
Compilation error in generated DAO code when visibility of a field is changed to private
DISTINCT .. LIMIT emulation renders redundant DENSE_RANK() OVER (ORDER BY ...) clauses
H2 dialect should cast binary data of unknown length as VARBINARY, not as BINARY
Add missing Experimental annotation to migrations API types
NullPointerException in AbstractMeta::lookupTable and other methods, when there is no DefaultCatalog
MetaImpl::ddl() should produce plain SQL CREATE VIEW statements if it can't parse the view contents
LoggerListener logs some batch queries twice, when using BatchMultiple
ScalaGenerator produces wrong code when generator strategy adds multiple interfaces to legacy enum type
Wrong implementation of SelectQueryImpl::wrapQueryExpressionBodyInDerivedTable in jOOQ Open Source Edition
CheckDefinition.getSource() should return CheckDefinition.getCheckClause() contents
Wrong encoding of lists in generated programmatic code generation configuration examples
Meta.ddl() export generates wrong DDL for constraints with USING INDEX clause in Oracle
Meta.ddl() generates broken DDL for smallserial columns
MetaImpl is missing view source code or unique constraints for objects in other catalogs
Error when generating code from a MariaDB database containing packages
Meta.ddl() should export tables first, then views
Batch::executeAsync throws NullPointerException when executed with R2DBC driver
Parser error when using SET new.x = y syntax in triggers
Bad syntax in Firebird when creating triggers for unquoted table names
Block::$replace doesn't replace anything
Wrong deprecation notices in PostgresDSL
Avoid generating sort specification in indexes in dialects that don't support it
Table with 255 columns generates record and POJO objects whose constructors have too many parameters
Compilation error in generated code when global object references conflict with schema names
Settings.metaIncludeSystemIndexes doesn't work for system indexes of unnamed constraints in HSQLDB
Exception when MockResult contains UDTRecord
Bad formatting of hints at the end of maven-install.sh scripts
Missing CAST in generated MERGE statement when using inline values in PostgreSQL 15's ON DUPLICATE KEY UPDATE emulation
Can't generate code using CockroachDB materialized view
Table list to ANSI JOIN transformation doesn't work if table declarations are fully qualified, but references are not
AutoConverter loses nanosecond precision when converting from Instant to LocalDateTime or OffsetDateTime
Code generation fails on BigQuery when querying INFORMATION_SCHEMA without a DefaultDataset being specified
Failure in MetaImpl.MetaSchema::source in BigQueryDatabase
AutoConverter should be lenient about TIME type fractional seconds
Can't invoke default methods on proxied types returned by DefaultRecordMapper in JDK 9 or more
Work around SQL Server's 1000 row value limitation for INSERT statements
Query::isExecutable should be checked in the R2DBC implementation, allowing no-ops for non-executable queries
Fix various UDT related issues in KotlinGenerator
Manual should stop recommending use of deprecated DefaultExecuteListener or DefaultRecordListener
Missing Stringly annotation on String... varargs parameters
AbstractTypedElementDefinition should cache resolvedType property only once per file
Datetime precision isn't maintained by code generator for domain types
KotlinGenerator - isKotlinNotNullPojoAttributes setting prevents generated DAO to set serial ID to pojo
DefaultRecordMapper should skip most mappers when an instance is provided
MutablePOJOMapper should be able to map to instance, even if there isn't a default constructor
Record.into(recordInstance) should modify argument record
DefaultOtherBinding shouldn't create string literals for inline values for numeric data types
MariaDB UPDATE .. RETURNING emulation should work on tables with unique constraints only
Install shell/batch scripts should be clearer about Java 17+ support
DefaultStringBinding should bind java.sql.Clob for CLOB types in Oracle MERGE statements
Fix DefaultRecordMapper Javadoc to reflect actual behaviour
Plain SQL Javadoc disclaimer is absent on api generator generated step methods
Bump org.eclipse.jgit:org.eclipse.jgit from 5.9.0.202009080501-r to 6.6.1.202309021850-r in /jOOQ-migrations
Wrong Support annotation on COMMENT ON COLUMN for MariaDB
On JDK 21, generated code should apply "this-escape" warning suppression
Synthetic comment flag <deprecated> should produce @Deprecated annotation in addition to Javadoc
Stop using deprecated DSL API in jOOQ-meta
QOM.Delete mutators produce a copy that always has a RETURNING clause
InlineDerivedTable can't be outer joined
RenderMapping doesn't apply to QualifiedRowid
DefaultConfiguration doesn't serialize AuditProvider or TransformProvider
InlineDerivedTable doesn't maintain contained table's meta data in some cases
Copy paste errors in likeIgnoreCase and containsIgnoreCase Javadoc
INSERT .. ON DUPLICATE KEY UPDATE emulation mustn't silently insert the last row only in Derby multi row inserts
Domains aren't generated if they don't have a CHECK constraint associated with them, in HSQLDB
Code generator doesn't generate multiple check constraints for DOMAIN types
Incorrect DEFAULT values generated for Informix
Generated DEFAULT expressions should always be syntactically valid for all data types in HANA
HANA sort indirection doesn't work with bind values
Fix a typo in a Tip
Upgrade jgit from the jOOQ-migrations prototype to 6.6.1.202309021850-r
Reactive transaction hangs when exception thrown in lambda constructing reactive flow
Possible compilation errors in generated code when column names contain double quotes
BindingSetStatementContext should reference actual ExecuteContext, if available
Ill-formed Javadoc causes JDK 21 javadoc tool to crash
JSONB inline values should be rendered using JSONB.data() not JSONB.toString()
Implicit JOIN implementation for DML is incorrect if paths navigate self joins
Compile errors of generated classes using scala 3
MiniJAXB::marshal(XMLAppendable, OutputStream) does not flush decorating writer
LazyVal::generatesCast should return true
MetaImpl reports system indexes for Derby 10.16
Misleading example in manual's section about the CREATE TRIGGER statement
Incorrect query generated when combining SEEK with GROUP BY
Wrong grammar for intervalLiteral in manual
Parser cannot parse undocumented reverse syntactic order of FOR UPDATE and LIMIT clauses from PostgreSQL
Support overlapping embeddables when enabling <embeddablePrimaryKeys/>
Oracle UDTs are sometimes inlined as [UDT] instead of IDENTIFIER(CONTENT)
Compilation error in KotlinGenerator generated code for tables containing a FROM column, when <interfaces> is activated
Accidental override when enabling <interfaces> for tables with columns X and IS_X in Kotlin
IllegalArgumentException when calling UpdatableRecord methods on tables with embedded domains that replace their underlying fields
Internal RecordDataType.getDataType() should be non-nullable for records consisting of all non-null fields
Compilation error in generated code when using <embeddableDomains/> and the domain is part of a composite key
Upgrade logback dependency in jOOQ-jooby-example to mitigate CVE-2023-6378
Incorrect ExecuteListener Javadoc regarding ExecuteListener lifecycle
Swapped examples in manual section "group-by-tables"
AbstractDatabase::markUsed doesn't work in some edge cases
SnowflakeDataType is missing references to Snowflake's JDBC-internal spellings of TIMESTAMPNTZ, TIMESTAMPLTZ, TIMESTAMPTZ

New in jOOQ 3.18.7 (Oct 20, 2023)

Features and Improvements:
Add a log message whenever an exception occurs with the SQLDialect.DEFAULT
Meta.ddl() should export tables first, then views
DefaultRecordMapper should skip most mappers when an instance is provided
Domains aren't generated if they don't have a CHECK constraint associated with them, in HSQLDB
Bug Fixes:
AutoConverter should be lenient about TIME type fractional seconds
Can't invoke default methods on proxied types returned by DefaultRecordMapper in JDK 9 or more
Failure in MetaImpl.MetaSchema::source in BigQueryDatabase
Code generation fails on BigQuery when querying INFORMATION_SCHEMA without a DefaultDataset being specified
Work around SQL Server's 1000 row value limitation for INSERT statements
Missing Stringly annotation on String... varargs parameters
Datetime precision isn't maintained by code generator for domain types
Record.into(recordInstance) should modify argument record
DefaultOtherBinding shouldn't create string literals for inline values for numeric data types
MutablePOJOMapper should be able to map to instance, even if there isn't a default constructor
Install shell/batch scripts should be clearer about Java 17+ support
Fix DefaultRecordMapper Javadoc to reflect actual behaviour
Plain SQL Javadoc disclaimer is absent on api generator generated step methods
MariaDB UPDATE .. RETURNING emulation should work on tables with unique constraints only
Wrong Support annotation on COMMENT ON COLUMN for MariaDB
QOM.Delete mutators produce a copy that always has a RETURNING clause
On JDK 21, generated code should apply "this-escape" warning suppression
DefaultConfiguration doesn't serialize AuditProvider or TransformProvider
KotlinGenerator - isKotlinNotNullPojoAttributes setting prevents generated DAO to set serial ID to pojo
Copy paste errors in likeIgnoreCase and containsIgnoreCase Javadoc
Query::isExecutable should be checked in the R2DBC implementation, allowing no-ops for non-executable queries
INSERT .. ON DUPLICATE KEY UPDATE emulation mustn't silently insert the last row only in Derby multi row inserts
Code generator doesn't generate multiple check constraints for DOMAIN types
HANA sort indirection doesn't work with bind values

New in jOOQ 3.18.6 (Aug 18, 2023)

New in jOOQ 3.18.5 (Jun 23, 2023)

Features and Improvements:
maven-install and maven-deploy shell scripts should use -e flag to report more error info
Add error message to maven-install.sh which doesn't work with Maven 3.9.0 due to MNG-7679
Add a jooq.codegen.propertyOverride system property to GenerationTool
Add DSLContext.transactionCoroutine overload accepting CoroutineContext
Improve Javadoc on DSLContext.executeInsert(), executeUpdate(), and executeDelete() about optimistic locking not applying
Add support for MySQL DECIMAL/FLOAT/DOUBLE/REAL UNSIGNED types in Meta and code generation
Add Javadoc to plain SQL DSL.field() constructors recommending to use code generation or at least pass a DataType
Deprecations
Deprecate inconsistent DSL.jsonObject(Field...) and DSL.jsonbObject(Field...) overloads
Bug Fixes:
DDLDatabase defaultNameCase=lower doesn't work with ENUM types
Unable to rename table with qualified target table name
Parser meta lookup fails when using qualified asterisk on a table alias
KotlinGenerator produces wrong code with kotlinNotNullPojoAttributes when multiple references to an embeddable have different nullability - Merge [#14991
Misleading error message when ON KEY finds ambiguous keys
Inconsistent implementation of TableImpl::equals and TableImpl::hashCode when comparing generated tables with plain SQL ones
Compilation error in Oracle generated code for package type in PL/SQL RECORD constructor
Ambiguous type name warning for non-ambiguous type name in OracleDatabase
Wrong warning logged regarding CockroachDB version support
DefaultConfiguration::toString logs wrong flags in R2DBC context
Use awaitSingle instead of awaitFirstOrNull in transactionCoroutine to correctly sequence transaction script
Improve error message when unversioned, row based optimistic locking doesn't work with DAOs and POJOs
PostgresDatabase and subtypes may produce wrong table comments in presence of stored functions
NullPointerException in code generator when omitting <target> directory
Compilation error in generated DAO code when visibility of a field is changed to private
PostgreSQL: array(<domain over UUID>) causes exception
Add missing Experimental annotation to migrations API types
H2 dialect should cast binary data of unknown length as VARBINARY, not as BINARY
NullPointerException in AbstractMeta::lookupTable and other methods, when there is no DefaultCatalog
MetaImpl::ddl() should produce plain SQL CREATE VIEW statements if it can't parse the view contents
Ambiguous match found when using aliases with implicit join and joining the same table twice
ScalaGenerator produces wrong code when generator strategy adds multiple interfaces to legacy enum type
LoggerListener logs some batch queries twice, when using BatchMultiple
Wrong implementation of SelectQueryImpl::wrapQueryExpressionBodyInDerivedTable in jOOQ Open Source Edition

New in jOOQ 3.18.4 (May 11, 2023)

New in jOOQ 3.18.3 (Apr 12, 2023)

New in jOOQ 3.18.2 (Mar 29, 2023)

New in jOOQ 3.18.1 (Mar 21, 2023)

New in jOOQ 3.17.9 (Mar 8, 2023)

Features and Improvements:
Log warning when unsupported dialect version is being used
Add parser support for SQLite's WITHOUT ROWID tables
PostgreSQL interval parser handle fractional seconds with interval style iso_8601
Add support for interval types in DefaultConverterProvider
Bug Fixes:
SQL Server nullability information isn't generated correctly for domains
Work around a YugabyteDB regression querying the INFORMATION_SCHEMA.ATTRIBUTES table
Missing nullability information on nullable DOMAIN types that are made non-null by CREATE TABLE
Missing default information on DOMAIN types that get an overridden DEFAULT by CREATE TABLE
Add parser support for SQLite's STRICT tables
Single message JooqLogger doesn't work
LoggerListener::fetchEnd should check if DEBUG logging is enabled
Wrong emulation of GENERATE_SERIES with STEP parameter for Snowflake
Wrong ON KEY JOIN generated when aliased table appears twice in the JOIN tree
Wrong column resolved by JoinTable.field(Field), when JoinTable contains aliased tables and lookup uses unaliased tables
JoinTable.onKey(ForeignKey) does not work when tables are aliased
Translator duplicates comment only content when retaining comments
Wrapping SQLException must copy SQLState and other info from wrapped SQLException
SQL Server RETURNING clause emulation for fetching server side computed columns generates incorrect SQL if only computed columns are etched
INSERT statement does not apply types to bind values in VALUES clause when using valuesOfRows()
UnsupportedOperationException when selecting row with YearToSecond
Use LazyName in AbstractParam
Push down ScopeMappable marker interface from AbstractField to AbstractWindowFunction and TableFieldImpl
PostgreSQL Numeric array type with precision/scale too large in generated code
Slow TableAlias::equals implementation, when argument type is TableImpl
Speed up AbstractRow.equals() and hashCode() when comparing with other AbstractRow
Nesting MULTISET/ROW/MULTISET/ROW with ad-hoc converters and JSON emulation results in ClassCastException
VALUES() must cast NULL literals in the first row, if the type is known and the RDBMS cannot infer it

New in jOOQ 3.17.8 (Feb 9, 2023)

New in jOOQ 3.17.7 (Jan 18, 2023)

New in jOOQ 3.17.7 (Jan 17, 2023)

New in jOOQ 3.17.6 (Dec 8, 2022)

Features and Improvements:
Add support for DB2 ROWNUMBER and DENSERANK window function in parser
Bug Fixes:
ParserCLI in interactive mode should use Settings defaults for its SQL transformation flags
MANIFEST.MF contains unnecessary javax.persistence dependency
StackOverflowError in transformPatternsArithmeticExpressions when commutative operator has 2 inline arguments
DefaultDiagnosticsContext should cache resultSetFetchedRows
Bad syntax generated when using the Field.collate() clause in CREATE TABLE statements
Regression in MS Access CONCAT implementation
Plain SQL INSERT .. RETURNING doesn't work with unqualified field templates in SQL Server
Update blog links from Javadoc and comments
Outdated Javadoc on DSL.array() for how jOOQ renders H2 array constructors
ORA-00904: "v0"."GET_WKT": invalid identifier
Cannot query geometry value in a nested ROW
Cannot query geometry value in a multiset
DefaultDiagnosticsContext shouldn't call ResultSet::getMetaData on already closed ResultSet
Work around SQLite's error: HAVING clause on a non-aggregate query
ClassCastException in WithImpl::$replace
Improve generated unknown data type javadoc when forcedTypes match return type, but there are still unknown parameter types
Median emulation ignores FILTER and OVER clauses
AbstractToJacksonConverter does not work when userType is array
Kotlin Value Classes in Constructor lead to name based mapping failure
Upgrade pgjdbc to 42.4.3 to mitigate CVE-2022-41946
ScalaGenerator generated code should avoid "procedure syntax"
ForcedType enum with no matching value being converted to last enum value
ON CONFLICT DO NOTHING emulation should continue to be applied for PostgreSQL 9.3 and 9.4
In MySQL, withReturnAllOnUpdatableRecord(true) causes two SELECT statements
Informix DDL statements generate invalid SQL for timestamp columns
Informix CURRENT_TIMESTAMP emulation doesn't work as DDL DEFAULT expression
Wrong NULL behaviour of BitAndAgg, BitOrAgg, and related aggregate function emulations
Informix BOOLEAN literals 't' and 'f' need to be cast to BOOLEAN explicitly
Excess query executed against SQLite when emulating INSERT .. RETURNING
ArrayIndexOutOfBoundsException when parsing ill formed SQL ending with a comment and a semicolon
Exception in Teradata code generation: Unknown column TVName
StackOverflowError in parser with Settings.parseWithMetaLookups == IGNORE_ON_FAILURE
Error: Invalid Top N Value: N is too big for Teradata OFFSET emulation
Teradata TOP expression or DISTINCT TOP don't work
Parser meta lookups don't work correctly when using DELETE .. FROM with aliased tables
Meta::getTables should list also PARTITIONED TABLE
Parser produces wrong projection data type when parsing doubly nested derived table
Parser reports wrong Ambiguous field identifier error when derived tables share column names

New in jOOQ 3.17.5 (Nov 16, 2022)

Features and Improvements:
#13997 Improve documentation on Fields lookup methods
#14072 Add parser support for undocumented AS keyword in SQL Server procedure parameter list
Bug Fixes:
#13966 HSQLDB arrays can't be projected from nested rows
#13983 ParsingConnection doesn't correctly relay Statement::getResultSet, Statement::getUpdateCount, or Statement::getMoreResults on static Statement
#13994 Wrong value returned from NullCondition::isNullable
#14015 Slow query against SYS.ALL_INDEXES in OracleDatabase
#14018 Moderately slow query on ALL_TAB_COLS due to cartesian product in OracleTableDefinition
#14022 Moderately slow query on ALL_ARGUMENTS due to EXTENDED DATA LINK FULL in OracleTableDefinition
#14024 Postgres array of single-field UDT reads UDT's field as null instead of actual value
#14028 ClobBinding and BlobBinding shouldn't delegate sql() generation to internal DefaultStringBinding or DefaultBytesBinding
#14031 ORA-01704 when generating large CLOB inline values in Oracle
#14035 Upgrade to Scala 2.13.9 to mitigate CVE-2022-36944
#14037 KotlinGenerator produces directory names with backticks when catalog names contain special characters
#14054 Upgrade jackson-databind dependency to 2.13.4 to mitigate CVE-2022-42004
#14056 Upgrade protobuf-java to 3.16.3 to mitigate CVE-2021-22569
#14061 Work around Derby's Error [30000] [54002]: A string constant starting with '...' is too long
#14068 ClobBinding and BlobBinding shouldn't bind a null value on PreparedStatement::setClob and ::setBlob in Firebird, HSQLDB
#14087 Support parsing SELECT .. INTO <qualified table> FROM ..
#14101 Table as SelectField native support relies on actual column order, not generated order
#14109 Upgrade jackson-databind dependency to 2.13.4.2 to mitigate CVE-2022-42003
#14117 ClassCastException when nesting array(select row) projections in PostgreSQL
#14134 Code generator shouldn't generate JPA Column precision on non-decimal types
#14142 Generated text blocks for view sources should escape
#14164 Wrong transformation for transformPatternsTrivialPredicates when DISTINCT predicate operand is NULL

New in jOOQ 3.17.4 (Sep 6, 2022)

New in jOOQ 3.17.3 (Aug 16, 2022)

New in jOOQ 3.17.2 (Jul 7, 2022)

New in jOOQ 3.17.1 (Jun 27, 2022)

New in jOOQ 3.17.0 (Jun 22, 2022)

Client side computed columns:bhm
A ground breaking new core feature available in all commercial distributions is the new client side computed columns feature, building on top of jOOQ 3.16's commercial support for readonly columns and server side computed columns.
Not all RDBMS support computed columns (e.g. using the standard SQL syntax GENERATED ALWAYS AS), and if they do, they might not support them in both STORED (computed on write) and VIRTUAL (computed on read) variants. jOOQ can now emulate both features at the client side, by transforming your SQL queries:
STORED affects INSERT, UPDATE, DELETE, and MERGE
VIRTUAL affects SELECT and the RETURNING clause of DML statements. To make use of these, combine them with the new synthetic column generation feature.
Unlike their server side counterparts, these client side features can produce arbitrary expressions, including:
Implicit joins
Scalar subqueries
MULTISET subqueries
Much more
Think of this as "views" written in jOOQ, on a per-column basis. An expecially useful feature combination is to combine these computed columns with the new visibility modifier that allows for keeping computed columns (or the underlying base columns) private and thus invisible to user code.
More about this feature here:
https://www.jooq.org/doc/3.17/manual/code-generation/codegen-advanced/codegen-config-database/codegen-database-forced-types/codegen-database-forced-types-computed/
Audit columns
A special case of STORED client side computed columns are audit columns, whose most basic implementation comes in the form of:
CREATED_AT
CREATED_BY
MODIFIED_AT
MODIFIED_BY
Other approaches to auditing exist, including soft deletion, additional meta data, (bi)temporal versioning, but these columns are among the most popular approaches, making this commercial only convenience feature very useful to a lot of customers.
More about this feature here:
https://www.jooq.org/doc/3.17/manual/code-generation/codegen-advanced/codegen-config-database/codegen-database-forced-types/codegen-database-forced-types-audit/
Java 17 baseline for the jOOQ Open Source Edition
Java 17 has been the latest LTS, and it includes a lot of really cool features, including:
sealed types (essential for pattern matching)
records
instanceof pattern matching
text blocks
switch expressions
jOOQ 3.16's experimental new Query Object Model (QOM) API experiments with sealed types, which will be adopted more generally once the QOM API is finalized.
To get broader user feedback on these improvements, as well as to embrace Java's new LTS update cadence, we've decided to make Java 17 the baseline for the jOOQ 3.17 Open Source Edition, continuing our Java 8 and 11 support in the commercial jOOQ distributions.
The following older jOOQ releases will continue to receive upgrades for a while:
jOOQ 3.14: The last release with Java 8 support in the jOOQ Open Source Edition and Java 6 support in the jOOQ Enterprise Edition
jOOQ 3.15 and 3.16: The last releases with Java 11 support in the jOOQ Open Source Edition and Java 8 support in the commercial editions.
PostgreSQL data type support
The jooq-postgres-extensions module, which contained support for the HSTORE type, now has a lot more support for PostgreSQL specific data types, including array types of each of:
CIDR
CITEXT
LTREE
HSTORE
INET
RANGE (including all the specialisations for INT4, INT8, etc.)
In order to profit from these data types, just add the org.jooq:jooq-postgres-extensions module to your code generation and runtime dependencies, and the types are generated automatically.
Implicit JOIN improvements
In this release, we experimented with a few new implicit JOIN features, including support for implicit JOIN in DML statements. The current implementation produces correlated subqueries where JOIN isn't supported in DML statements.
We've also experimented with creating a "convenience syntax" for other commonly used correlated subqueries, such as EXISTS(...) subqueries or MULTISET(...) subqueries. The experiment has been very interesting. The prototype, however, was rejected. See the discussions here:
https://github.com/jOOQ/jOOQ/issues/13063
https://github.com/jOOQ/jOOQ/issues/13069
Future jOOQ versions will implement the desired convenience in the form of more implicit JOIN functionality, offering the feature also as an implicit to-many JOIN.
A leftover from the prototype is the fact that you can now more easily project expressions other than classic Field<T> in your SELECT clause, namely:
Table<R> now extends SelectField<R>
Condition now extends Field<Boolean>
Pattern matching SQL Transformations
SQL transformations have been a strategic feature set to recent jOOQ releases, offering additional compatibility between SQL dialects to commercial customers, such as, for example:
Transforming Oracle's ROWNUM into equivalent window functions or LIMIT clauses.
Turning table lists including Oracle's (+) operator into ANSI JOIN syntax.
This release ships with a new commercial only feature that directly transforms the new Query Object Model (QOM)'s expression tree prior to rendering. It does so by applying pattern matching to the expression tree. Some assorted examples include:
LTRIM(RTRIM(x)) into TRIM(x)
x != a AND x != b into x NOT IN (a, b)
x IN (a, b, c) AND x IN (b, c, d) into x IN (b, c)
NOT (NOT (x = 1)) into x = 1
NOT (x = 1) into x != 1
And much more. The primary use-cases for this functionality are:
SQL linting, e.g. as part of an ExecuteListener
SQL auto cleanup, including in a ParsingConnection
Dialect migration, when upgrading database versions, or moving between dialects
Patching specific SQL features
For more information about the feature, see:
https://www.jooq.org/doc/3.17/manual/sql-building/queryparts/sql-transformation/transform-patterns/
Note that this feature is also available for free online:
https://www.jooq.org/translate
Reactive and kotlin coroutine support:
A lot of minor improvements have been implemented. A few more significant ones include:
R2DBC 0.9.1.RELEASE is now supported
A new reactive transaction API has been added, which offers the same nested transaction semantics as the existing blocking transaction API, see also: https://blog.jooq.org/nested-transactions-in-jooq/
jOOQ's reactive streams bindings via the Publisher SPI are now bridged automatically to kotlin coroutines in the new org.jooq:jooq-kotlin-coroutines module using the usual utilites org.jetbrains.kotlinx:kotlinx-coroutines-core and org.jetbrains.kotlinx:kotlinx-coroutines-reactor
The org.jooq:jooq-kotlin extensions module now has additional extension functions for more MULTISET and other nesting related convenience.
The entire blocking execution API is now annotated with org.jetbrains.annotations.Blocking to help reactive jOOQ users avoid accidentally blocking on a query, when using IntelliJ. In addition, we now annotate experimental and internal API with the ApiStatus annotation from the same package.
For a complete list other, minor improvements, see the below change notes.
Features and Improvements:
#1592 Add formal support for "audit" fields, such as CREATED_AT, CREATED_BY, MODIFIED_AT, MODIFIED_BY
#2092 Add support for the Postgres INET data type (java.net.InetAddress)
#2333 Add DSL.noField() for "conditional" LIMIT, OFFSET, GROUP BY, ORDER BY support when creating dynamic SQL
#2968 Add support for PostgreSQL RANGE types
#3497 Add methods to Context to distinguish between derived tables and other types of subqueries
#4727 Let Table<R> extend SelectField<R>
#5214 Add support for PostgreSQL's EXCLUDED table
#5641 Support overriding code generation <target/> configuration via system properties
#5695 Allow for expressions to be put in LIMIT / OFFSET
#5934 Add support for the Postgres CITEXT type
#5970 Add Setting to auto-inline all bind variables that participate in predicates on certain fields
#6454 Support converting from java.sql.Array to Object[] types
#6489 Code generator should support SQL-generated "dynamic regular expressions"
#7284 Replace common patterns in query object model
#7508 Add support for path expressions ("implicit joins") in DML
#7803 Let ArrayRecord extend Formattable
#7912 Add InsertOnDuplicateSetStep::setAllToExcluded to auto-set all insert column list columns to their EXCLUDED value
#8653 Add support for parsing VALUES <row value special case>, ...
#8997 Remove jOOQ-spring-example and documentation
#9335 Add a jooq-kotlin-coroutines module to support transactional coroutines based on reactive streams Publishers
#9347 DataType#getCastTypeName() does not respect rendering settings
#9425 Add Meta.migrateTo(Meta):Queries to generate a migration script between two Meta versions
#9768 Support MySQL inline INDEX specifications in DDLDatabase
#9817 Add support for text blocks in generated code
#9879 Add support for VIRTUAL and STORED client side computed columns
#10120 Add some more aliasing examples to the manual
#10132 Cast NULL literal to known type in Derby
#10407 Add support for FIREBIRD 4 RETURNING * syntax
#10521 Push down derived column list aliases to derived table's SELECT clause instead of using UNION ALL emulation, if possible
#10523 Emulate UPDATE .. SET row = (SELECT ...) for dialects with no native support
#10537 Split manual section about forcedTypes into different subsections
#10677 Add <onUnused/> to code generation configuration to specify behaviour when encountering unused objects
#10756 Generate @Transactional on DAOImpl and generated DAOs query-methods
#10763 Official jOOQ-postgres-extensions bindings should register themselves as low priority bindings if found on the code generation classpath
#10832 Review our Nullable and NotNull annotation usage
#11232 Parser should parse all Names.* values at least once
#11331 Support SQLDataType.XML in DDL
#11467 LoggerListener should log batch sizes for BatchSingle and BatchMultiple
#11575 Replace internal dialect switches by Set<SQLDialect>
#11717 Known limitations of the R2DBC integration
#11731 Emulate Oracle INSERT .. SELECT.. RETURNING
#11770 UpdatableRecord::merge should use new EXCLUDED semantics to avoid repeating bind values
#11823 Investigate whether read-only converters really require the Class reference
#11969 Let Condition extend Field<Boolean>
#12481 ParsingConnection's PreparedStatement.getMetaData should be able to produce ResultSetMetaData prior to execution
#12515 Support for RowN.mapping(Function<? super Object[], ? extends U>)
#12533 Use org.jetbrains.annotations.ApiStatus
#12608 Support referencing the same embeddable type multiple times per table
#12688 Add support for H2's BIT_NAND_AGG, BIT_NOR_AGG, BIT_XNOR_AGG aggregate functions
#12721 Add more startup tips to be logged with the jOOQ logo
#12734 Address known limitations of MULTISET support
#12779 Add support for MySQL COMMENT syntax in DDLDatabase's CREATE TABLE statements
#12782 Add DiagnosticsContext.message(): String to give access to a text message
#12785 Add DiagnosticsListener::exception to handle exceptions encountered while running diagnostics
#12807 Parse and ignore Teradata's COMPRESS DDL clauses
#12829 Support parsing H2's undocumented DROP TABLE .. CASCADE CONSTRAINTS syntax
#12830 Support DROP TABLE .. CASCADE in Oracle
#12832 Improve parser error message when encountering unterminated quoted identifier
#12834 Support parsing empty column lists in INSERT statements
#12836 Parser should support VALUES constructor in FROM clause without parentheses
#12838 Support parsing DATABASE() as synonym for CURRENT_CATALOG() or CURRENT_DATABASE()
#12840 Parser improvements thanks to the sqlancer team related test cases
#12843 Support parsing LOG(n) without explicit base, based on input dialect
#12846 Support parsing alternative H2 and HSQLDB DROP CONSTRAINT c IF EXISTS clause
#12848 Support parsing HSQLDB's inline FOREIGN KEY syntax
#12862 Upgrade all relevant R2DBC dependencies to 0.9.0.RELEASE
#12874 Upgrade org.jetbrains:annotations dependency to 23.0.0
#12875 Annotate all blocking execution methods with org.jetbrains.annotations.Blocking
#12877 Improve blocking call error message when trying to run Query.execute(), etc. with R2DBC
#12883 Add DSL.nullCondition(), a condition that correctly represents the NULL / UNKNOWN predicate value
#12893 Add an Replacers.listening(Replacer, BiConsumer<QueryPart, QueryPart>) to allow for listening to QueryPart.$replace() events
#12894 Add accessors for Select::$limit, ::$limitPercent, $limitWithTies, ::$offset
#12896 Add Settings.renderOptionalAssociativityParentheses
#12905 Emulate expressions in LIMIT .. OFFSET where not natively supported
#12906 Add a QOM.UCommutativeOperator utility with methods like $swap()
#12911 QOM type accessors should accept Collection when they return UnmodifiableList
#12912 Add missing Select.$groupBy(), $orderBy(), setter accessors
#12914 Document QOM API outside of the QOM type, and annotate it as @Experimental
#12920 Add Traversers.recursing()
#12921 Replace internal org.jooq.impl.Finder utility by Traverser API usage
#12945 Add Field<Result<Record[N]>>.mapping(Function[N]<T[N], E>): Field<List<E>> kotlin extension functions
#12959 Gradle examples should list the usual commercial groupIds
#12973 Add Traversers.containing(Predicate<? super QueryPart>)
#12989 Update R2DBC dependency to 0.9.1.RELEASE
#13000 Add Replacers.decomposing(): Replacer to decompose a compound statement into equivalent individual statements
#13001 Refine Replacer Javadoc
#13004 Add a TableElement type, a super type of Field<?> | Constraint | Index
#13014 Add support for providing a --schema to the ParserCLI
#13031 Add a rootPath property to the LiquibaseDatabase configuration for the FileSystemResourceAccessor
#13037 Add documentation for the new FormattingProvider
#13070 Change Function[N] to be non-experimental
#13072 Remove experimental status on Row[N].mapping(Function[N])
#13077 Bump postgresql from 42.3.2 to 42.3.3
#13078 Add internal Tools.CONFIG as a convenience for Tools.CTX.configuration()
#13093 Remove a few redundant null checks in jOOQ's internals
#13097 Add Converters.forArrayComponents(Converter<T[], U[]>): Converter<T, U>
#13104 Reimplement SQL Server RETURNING emulation using QueryPart.$replace instead of SchemaMapping
#13109 Add Settings.parseIgnoreCommercialOnlyFeatures
#13118 Pull up Field::convert, ::convertFrom, ::convertTo methods to SelectField
#13129 Add Context::predicandSubquery
#13131 Add sections to the manual about using Table references as GroupField, SelectField
#13132 DSLContext.fetchValue(SelectField<T>) should work with Table<R>
#13135 Generate mapping() deconstruction convenience methods on generated Tables if <recordsImplementingRecordN/> is set
#13137 Change default for <pojosEqualsAndHashCode/> code generation option to true
#13142 Add JSONFormat.mutable(), XMLFormat.mutable()
#13143 Add code generation flags to turn off the recognition of jOOQ-specific types
#13157 Remove Oracle work around for JSON_ARRAYAGG causing ORA-40590: invalid format in Oracle 21c
#13161 Add support for array bindings for the PostgreSQL HSTORE, INET, and CIDR types
#13162 SchemaVersionProvider etc should be looked up using context classloader, too
#13183 Add Javadoc warnings to UpdatableRecord::fetchChildren, and TableRecord::fetchParent about the N+1 problem
#13188 Add support for the LTREE data type in the jooq-postgres-extensions module
#13192 Add SQLDialect.MARIADB_10_7
#13194 Various third party dependency updates
#13195 Add a SQLDialect.SQLITE_3_38 dialect
#13201 Add SQL Server JSON_ARRAY support via JSON_MODIFY
#13223 Emulate inline indexes in CockroachDB
#13224 Document declaration vs reference rendering mode of Field, Table, WindowDefinition, Parameter, CommonTableExpression
#13244 Upgrade kotlin dependency to 1.6
#13246 Add more examples to manual section "codegen-database-version-providers"
#13248 Amend manual sections about data types (XML, Spatial, JSON)
#13255 Support casting VARCHAR to XML / XMLTYPE in Oracle
#13260 Add DAO.deleteById(T) overload
#13264 Manual anchors should be generated from text, not from XSL generated ID
#13267 Make QOM::unmodifiable public, internal
#13271 Add support for SQLite 3.33 UPDATE .. FROM
#13272 Add support for SQLite 3.35 ALTER TABLE DROP COLUMN
#13275 Add SQLite 3.35 support for CTE MATERIALIZED hint
#13277 Add support for SQLite 3.35's built-in math functions
#13278 Add support for inverse hyperbolic functions ASINH, ACOSH, ATANH, ACOTH
#13281 Add more explicit links to Record::from and RecordUnmapper wherever this applies
#13284 Add support for T-SQL FOR XML EXPLICIT clause
#13286 Emulate SQL/XML XMLELEMENT and XMLATTRIBUTES in SQL Server using FOR XML EXPLICIT
#13287 Emulate SQL/XML XMLCOMMENT in T-SQL
#13288 Emluate SQL/XML XMLCONCAT in T-SQL
#13289 Support XMLQUERY() and XMLEXISTS() also in SQL Server
#13306 Separate QOM.Ln (natural logarithm) from QOM.Log (logarithm with base)
#13324 Code generation output shouldn't print table mapping output, if it's the same as the input
#13325 Refactor internal FieldMapForUpdate to support the row assignments, too
#13326 Emulate UPDATE .. FROM with MERGE, where available
#13329 Add a FieldOrRowOrSelect nominal union type
#13334 Add native support for MySQL's derived column lists starting from SQLDialect.MYSQL8_0_19
#13335 Add Table::as and TableLike::asTable overloads accepting Collection<? extends X> for derived column lists
#13336 Generate covariant overrides for Table.rename(Table) and Table.as(Table) methods
#13342 Refactor Multiset::jsonxArrayaggEmulation
#13391 Add support for the FOR XML BINARY BASE64 clause
#13393 Replace internal usage of DatatypeConverter::parseBase64Binary by java.util.Base64
#13399 jOOQ-checker should system property defaults that apply to the entire checked code
#13400 Add native Informix MULTISET and nested ROW support
#13410 Add a "Don't Do This" page to the manual
#13417 Add native EXASOL ROWNUM support
#13432 Add <visibilityModifier/> code generation option to <forcedType/>
#13434 Add <columns/> to <syntheticObjects/> to generate synthetic columns
#13437 Add Definition.isSynthetic() to indicate that a jOOQ-meta object has been created synthetically
#13446 Add H2_2_0_202 support for UPDATE .. RETURNING and DELETE .. RETURNING
#13457 New configuration to generate implicit join definitions ALWAYS from foreign key name
#13458 PI() emulation should be ACOS(-1) rather than ASIN(1) * 2
#13461 ResultQueryTrait::getFields should accept Supplier<ResultSetMetaData> instead of ResultSetMetaData
#13467 KotlinGenerator should generate open properties in generated records
#13471 Add Scope.creationTime() and make it available through GeneratorContext.renderTime()
#13482 Upgrade H2 dependency to 2.1.212
#13485 Add a QOM.UOpaque marker interface for non-traversable QueryPart types
#13486 Replace internal ConstantSortField by noField()
#13496 Specify the various Scope subtype's lifecycle in their Javadoc
#13497 Add BindingScope, a common super type of the various BindingXYZContext types
#13502 Add a reactive transaction API
#13508 Add MySQL support for INSERT .. ON DUPLICATE KEY UPDATE .. WHERE
#13516 KotlinGenerator should generate implicit joins path accessors as properties
#13523 Add support for parsing ! (bang) as equivalent to . (dot) in MS Access identifiers
#13525 Improve Documentation for DSLContext.fetchStream() and related methods
#13528 Document <implicitJoinPathsToOne/> flag
#13534 Avoid rendering PostgreSQL native cast operator :: which cannot be used in Hibernate native queries
#13538 Add a <T, E> Field<Result<R>>.collecting(Collector<R, ?, E>) kotlin extension function, and similar
#13540 Remove "inline" and "reified" keywords from jOOQ-kotlin extensions where unnecessary
#13544 Remove EXPERIMENTAL remark from ad-hoc converter and MULTISET construction API
#13546 Stop aligning generated POJO members and constructor arguments in columns
#13552 Change DSL.multiset(Select<R>) into DSL.multiset(TableLike<R>)
#13553 Add TableLike<R>.asMultiset(): Field<Result<R>>
#13556 Consistently use org.jooq Maven groupId across the manual
#13558 Add a PrefixSuffixGeneratorStrategy to jOOQ-codegen
#13571 Emulate the PostgreSQL ON CONFLICT .. EXCLUDED pseudo table in MERGE emulation
#13572 Add SQLDialect.MYSQL_8_0_20
#13573 Add parser support for the PostgreSQL EXCLUDED pseudo table and MySQL VALUES() syntax
#13578 Add native support for BITXNOR in H2
#13579 Add documentation to the manual for bitwise aggregate functions
#13582 DefaultRecordMapper should check whether user is attempting to map into an inner class
#13591 Add a new ColumnElement type
#13594 Change the Java 17 distribution to --release 17
#13599 Let Context extends ExecuteScope
#13605 Add JSONtoJacksonConverter, JSONBtoJacksonConverter, XMLtoJAXBConverter implementations
#13607 Add JSONtoJacksonConverter, JSONBtoJacksonConverter, XMLtoJAXBConverter forcedType configuration convenience
#13616 Scala extensions should have some multiset convenience
#13618 Document EnumType::lookupLiteral's nullable result
#13631 Add Context.topLevel() and Context.topLevelForLanguageContext() to give access to the top level QueryPart type that is being rendered
#13632 DDLDatabase should have a sql property, as an alternative to scripts
#13634 Add Field<Record[N]>.mapping(Function[N]<T[N], E>): Field<E> kotlin extension functions, and the Scala equivalent
#13642 Add a section about security to the manual's reference section
#13650 Settings.emulateMultiset should have NestedCollectionEmulation.JSON as default in PostgreSQL
#13657 Ability to download OSS edition snapshot
#13666 Support Oracle JSON data type in DDL
#13670 Add support for Oracle SYS.XMLTYPE in plain SQL templates
#13679 Upgrade HSQLDB to 2.6.1
#13693 JPA code examples should produce a jakarta.persistence.* import
Breaking changes:
#12430 Make Java 17 the baseline for the jOOQ Open Source Edition
#12772 Continue work on public query object model API
#12781 Remove pre 3.7 deprecated API and pre 3.7 documentation
#12895 Rename QOM.UOperator[N]::constructor to ::$constructor
#12904 Remove redundant limit(int) and offset(int) overloads
#12910 Add DSL.emptyGroupingSet(): GroupField for explicit empty grouping sets
#13028 Generated DAOs should use an embeddable's referencingName, not name for the fetchByXYZ() and fetchRangeOfXYZ() methods
#13053 java.lang.NoClassDefFoundError: org/postgresql/util/PGInterval when rendering SQL without the pgjdbc dependency
#13068 Change selectFrom(Table<R>) methods to selectFrom(TableLike<R>)
#13080 Standard SQL MULTISET emulation using XML produces a null Result
#13082 SQL Server MULTISET as JSON emulation of empty subquery produces NULL instead of empty Result
#13094 Throw an exception when calling ConvertedDataType.getArrayDataType() when the type has a custom Binding
#13114 SelectField.as() should return SelectField<T>, not Field<T>
#13115 Change Table::getType to Table::getTableType
#13116 Rename QOM.RowField to QOM.RowAsField
#13149 Let Query.keepStatement() return CloseableQuery and ResultQuery.keepStatement() return CloseableResultQuery
#13181 MULTISET emulation using SQL/XML doesn't correctly distinguish between NULL and ''
#13208 SQL Server JSON_OBJECT should implement NULL ON NULL semantics by default
#13307 Change $number() arguments in experimental QOM function types to $value()
#13426 DSLContext::fetchFromJSON and ::fetchFromXML wrongly assume dialect specific data types in header
Deprecations:
#13005 Deprecate FieldOrConstraint
#13071 Deprecate the org.jooq.Internal annotation
#13542 Replace SPI default implementation class (e.g. DefaultExecuteListener) by default methods in interface
Bug Fixes:
#1049 Better GREATEST() and LEAST() emulations for SQL Server using MAX() or MIN() with VALUES() correlated derived table
#5612 Inline enum values should be cast to their enum type just like inline bind variables
#6133 Cannot combine CREATE TEMPORARY TABLE .. AS .. with ON COMMIT ..
#7362 Excess parentheses generated in NOT operator
#7783 Nested row value expressions produce String column types when concrete type information should be available
#8614 Passing arrays of generated tableRecords to a stored procedure generates SQL that won't parse due to cast ::any[]
#8681 Wrong SQL generated for connectByRoot(minus(one()))
#9981 Some BooleanDataKey values should be reset when entering a new scope
#10277 CAST to PostgreSQL enum type lacks type qualification
#10304 Unnecessary parentheses generated in ConditionAsField
#11114 CAST should generate qualified type when casting to Table::getDataType or UDT::getDataType
#11424 Improve the alignment of GenerationTool INFO log
#11441 Inlining PostgreSQL CHAR(len)[] types produces VARCHAR[] instead
#11509 batchStore(), batchInsert(), etc. with StatementType.STATIC_STATEMENT throws java.sql.BatchUpdateException
#11552 UpdatableRecord::merge doesn't work in the presence of a unique constraint and in the absence of a primary key value
#11637 FilePattern cannot load classpath resource from within jar file
#11722 Code generator cannot handle tables from other schemas than PUBLIC referencing H2 enum domain types
#12036 Timestamp Arithmetic fails with ConvertedDataType
#12134 Support deserialising binary data in MULTISET emulations
#12269 Records detached when converting nested multiset
#12287 Replace calls to System.currentTimeMillis() by Clock usage
#12428 DDL export no longer exports INDEX WHERE clause
#12525 Nesting of converters causes unexpected Exception
#12783 Feature Comparison on website is different from docs
#12788 Support SQLite columns having no data type declaration
#12794 Parser and code generator does not recognise H2 2.0's BINARY VARYING and other standard SQL data type synonyms
#12795 Upgrade H2 dependency to 2.0.206
#12801 GroupConcat renders string_agg separator argument within wrong parentheses
#12804 Add parser support for Teradata's { UPDATE | DELETE } .. ALL syntax
#12811 DAOImpl.findOptionalById shouldn't be final
#12818 GROUP_CONCAT doesn't work as window function
#12820 Parser doesn't support Derby's FOR BIT DATA data type modifier
#12824 Parser cannot handle 1. decimal syntax in SELECT
#12825 Parser shouldn't parse Teradata cast syntax based on Settings.parseAppendMissingTableReferences, but only based on the parseDialect()
#12852 Parser can't handle TRIM (FROM <value>) syntax
#12854 jOOQ Open Source Edition code generation doesn't work PostgreSQL 11 or less because of ERROR: column pg_attribute.attgenerated does not exist
#12855 Bump spring-core from 5.3.13 to 5.3.14
#12858 Computed column related support annotations claim SQLDialect.POSTGRES instead of SQLDialect.POSTGRES_12
#12864 OSS Edition H2 INSERT .. RETURNING no longer works if columns are qualified with a schema
#12868 The DATA_RENDERING_DATA_CHANGE_DELTA_TABLE qualification omission doesn't work correctly in the presence of scalar subqueries
#12884 Upgrade jOOQ-checker's error_prone_core's transitive protobuf dependency to mitigate CVE-2021-22569
#12888 Parser should treat AS optional in CREATE TABLE AS SELECT
#12890 Parser fails to parse SET SCHEMA 'string-literal'
#12908 Select::$replace loses GROUP BY clause
#12916 Select.$where(), $having, $qualify(), $connectBy(), $connectByStartWith() don't actually return null in the absence of a predicate
#12917 Wrong SQL generated when InlineDerivedTable is transformed using $replace()
#12922 Bump h2 from 2.0.206 to 2.1.210
#12923 Upgrade H2 to 2.1.210
#12925 Work around H2 issue 3398 which hangs the process when using FINAL TABLE (MERGE ...)
#12929 NullPointerException when mapping NULL nested ROW from scalar subquery
#12930 Nested ROW projection emulation doesn't work in scalar subqueries
#12931 DAOImpl#deleteById(Collection<T>) ignores Converter
#12938 Outdated implementation examples in manual's MULTISET section
#12939 maven-deploy.sh should have same description in --repository flag as maven-deploy.bat
#12944 Consider improving invalid JDBC URL error messages in class generation
#12951 GenerationTool should handle JDBC driver returning null Connection on Driver::connect
#12954 Typo in manual section "codegen-ddl"
#12955 Wrong code generated for identity columns in H2 1.4
#12956 Can no longer store/retrieve blob data exceeding 1M in H2 2.0
#12966 NullPointerException in MetaDataFieldProvider when reading plain SQL column without a name in MySQL
#12970 jOOQ Open Source Edition does not generate routine with long name
#12976 Bump postgresql from 42.3.0 to 42.3.2
#12977 Jooq holds onto connections when using r2dbc
#12979 Upgrade the pgjdbc dependency to 42.3.2 due to CVE-2022-21724
#12982 Bump postgresql from 42.2.8 to 42.2.25 in /jOOQ-examples/jOOQ-spark-chart-example
#12983 Outdated JAXB dependency in manual tutorial
#12991 Typo in manual section "codegen-tables"
#12992 Code generation <indexes/> flag should turn on <tables/> as a dependency
#12993 [jOOQ/jOOQ#12992] Automatically enable table generation if indexes are enabled
#12994 Typo in manual section "fetching"
#13008 Compilation error in KotlinGenerator output when implicit join path cache conflicts with keyword
#13010 [#13008] Unquote keyword when mapping one to many relation
#13013 Interpreter does not correctly interpret CREATE INDEX .. WHERE
#13023 Record.formatJSON(Writer) and Record.formatXML(Writer) should flush the writer
#13029 SQLDataType.XYZ.getArrayDataType().getTypeName() and getCastTypeName() should produce standard SQL XYZ ARRAY type
#13033 DSL.function not replacing schema for function call in generated SQL
#13034 SchemaMapping should apply Settings.defaultCatalog even if Settings.defaultSchema doesn't apply
#13035 SchemaMapping should cache result of Settings.defaultCatalog or Settings.defaultSchema application
#13040 AbstractRecord.from(String[], TableField[]) no longer works as expected
#13043 Avoid generating H2 NUMBER type alias for NUMERIC types
#13048 Settings.parseRetainCommentsBetweenQueries doesn't work for the last comment
#13054 java.lang.IllegalArgumentException: Cannot create a VALUES() constructor with an empty set of rows when using JSON_ARRAY(ABSENT ON NULL) in PostgreSQL
#13058 NullPointerException when using CAST(x AS user-defined-type) with SQLDialect.JAVA
#13060 Typo in Records.intoArray(Class) Javadoc
#13073 Order of calling DataType.asConvertedDataType(Converter) and DataType.getArrayDataType() should not matter
#13076 Bump postgresql from 42.2.25 to 42.3.3 in /jOOQ-examples/jOOQ-spark-chart-example
#13081 Cannot use H2 enum values in JSON documents
#13085 Field.sortAsc() should not hard wire NULLS FIRST behaviour
#13089 MySQL's BIT(1) type doesn't map correctly in MULTISET subqueries
#13107 Register array types of built-in types in internal static type registry
#13113 Manual dialects translations for nested records emulations is wrong
#13117 Bad deserialisation of UDT TIMESTAMP value in the presence of a Converter in PostgreSQL
#13119 Nested record projection should generate ROW constructor keyword for rows of degree 1 in PostgreSQL's RETURNING clauses
#13120 Cannot use RETURNING with 2-level nested ROW expressions in SQL Server
#13124 Sequence.nextvals() doesn't work with DSLContext.selectFrom()
#13138 Bad JSONFormat rendering of nested records
#13144 ClobBinding shouldn't call Clob.length() in Firebird
#13147 Context::scopeMapping should return @NotNull QueryPart
#13148 Prevent Context::scopeMapping to apply when wrapperFor(X) is equal to X
#13156 Work around Oracle / ojdbc bug where JSON_ARRAY() can't combine bind parameter marker with FORMAT JSON
#13163 Compilation error when PostgreSQL stored function has an ANY[] data type reference
#13169 Incorrect parsing of (NULL) row literal in PostgreSQL for nested records, UDTs, etc.
#13170 NPE in INSERT .. ON DUPLICATE KEY emulation when defaulted PRIMARY KEY value isn't supplied in Oracle
#13174 ERROR: could not determine data type of parameter when projecting PostgreSQL UDT bind value
#13184 UNNEST table expression does not maintain derived column list
#13189 Feedback about manual section "codegen-ddl"
#13196 Db2 RowAsField emulation using JSON_OBJECT is lacking RETURNING BLOB when using the JSONB emulation
#13200 MULTISET nested record as JSON_OBJECT() emulation (Db2, SQL Server) doesn't work for records with more than 10 fields
#13202 SQL Server CREATE TABLE statement should generate VARBINARY(MAX) for BLOB
#13204 Boolean values aren't serialised correctly in SQL Server JSON documents
#13211 KotlinGenerator cannot read existing catalog/schema version
#13212 [#13211] Use square brackets for KotlinGenerator
#13216 Change Sakila database such that all ID types are INTEGER
#13217 Work around xerial SQLite driver's Clob behaviour when data is null
#13220 SQLite's JSON operators don't retain boolean three-valued logic
#13226 Wrong escaping of string literals in doubly nested EXECUTE IMMEDIATE blocks for DDL emulations
#13230 UNNEST with array argument doesn't work in Oracle when used with derived column list
#13237 ORA-03001: unimplemented feature when nested row emulation produces double quotes in Oracle identifiers
#13240 Code generation fails with H2 2.1.210 when using MySQL execution mode
#13245 Bump liquibase-core from 4.4.3 to 4.8.0
#13251 Error when nesting ROW() expressions with values instead of with fields, with degree > 22
#13252 Cannot insert data into PostgreSQL XML column due to missing cast
#13273 INSERT .. ON DUPLICATE KEY { IGNORE | UPDATE } emulation should consider all UNIQUE keys on SQLite
#13276 Wrong code generated for SQLite table with unnamed primary key and unique constraints
#13290 NullPointerException in Result.formatJSON(), formatXML(), formatCSV(), formatHTML() when a Record is null
#13302 H2TableDefinition with H2 2.0+ produces wrong code generation output when the run mode is Oracle
#13311 QOM API mutators on Select type don't copy OFFSET .. LIMIT and a few other clauses
#13315 Compilation error in generated UDTRecord's POJO constructor if the UDT contains arrays of table records
#13319 Generated records shouldn't have a @ConstructorProperties annotation on their POJO constructor
#13340 Wrong precision documented in forceIntegerTypesOnZeroScaleDecimals manual section
#13341 jOOQ internals shouldn't create unnamed derived tables
#13348 Internal deprecation note on FieldsTrait::field leaks into generated code
#13349 Select.asTable() should delay slow call to Tools::autoAlias
#13355 Invalid code generated when pojosEqualsAndHashCode option is enabled and column name is 'other'
#13364 Result::formatXML does not escape type names
#13379 Generated SQL Server code uses `sp_executeSQL`, which fails for binary (case sensitive) collations
#13383 Invalid SQL generated in Oracle 11g when query has LIMIT clause and scalar subqueries without explicit aliases
#13392 Generated column name for binary bind values shouldn't use Java's byte[].toString()
#13395 Bump spring-core from 5.3.16 to 5.3.18
#13396 Update spring-core dependency to 5.3.18 to mitigate CVE-2022-22965
#13403 MULTISET and ROW generated nested records should not have their changed flags set to true
#13415 GroupConcat renders string_agg separator argument within wrong parentheses in EXASOL
#13422 Dead links in manual for nested class Javadocs
#13424 Duplicate headers in manual where there exist redirects
#13429 DSL.noCondition() isn't applied correctly to aggregate FILTER WHERE clause
#13439 No warning is logged when readonly columns or rowids are not used
#13447 Upgrade to org.postgresql:postgresql:42.3.3 to mitigate CVE-2022-26520
#13454 ARRAY_AGG cannot aggregate array columns in H2
#13465 Expressions based on computed columns must not retain computation reference
#13468 Work around SQLite INSERT .. SELECT .. ON CONFLICT bug
#13473 SQLException when calling oracle.jdbc.driver.ArrayDataResultSet.getMetaData()
#13479 Bump spring-core from 5.3.18 to 5.3.19
#13488 org.jooq.SQL and manual should document plain SQL templating's capability of recognising :named parameters
#13489 ArrayIndexOutOfBoundsException when rendering PostgreSQL plain SQL template containing ?@
#13499 Improve implementation of QualifiedName.hashCode()
#13503 Parser meta lookups don't work for INSERT .. SELECT .. RETURNING
#13509 MariaDB, MySQL, Oracle, SQL Server may ignore MULTISET subquery ORDER BY clause
#13513 LoaderLoadStep.execute() shouldn't have @CheckReturnValue annotation
#13536 Wrong documentation for <printMarginForBlockComment/>
#13543 NullPointerException when rendering CTE without a top level context
#13545 DSL.quotedName(String[]) should produce QualifiedName only if argument array length != 1
#13555 Field::likeIgnoreCase should cast lhs operand just like Field::like and Field::similarTo
#13557 MySQL / MariaDB generated columns with enum type are not generated as readonly
#13560 Invalid SQL generated for Oracle when selecting multiple unaliased rows
#13563 INSERT .. RETURNING emulations shouldn't acquire multiple connections from ConnectionProvider when using ThreadLocalTransactionProvider
#13574 UpdatableRecord::merge might produce wrong update count if generated keys can't be fetched
#13581 Excess parentheses generated in unary ~ (QOM.BitNot) or - (QOM.Neg) operators
#13600 Bump spring-core from 5.3.19 to 5.3.20
#13601 Derby boolean expressions have to be wrapped in parentheses when passed to COALESCE
#13608 Distribute jOOQ-postgres-extensions also with the commercial distributions
#13611 UnsupportedOperationException when selecting single nested row with JSON column
#13624 Manual documents wrong artifactId for
#13625 Wrong code generated for Oracle package procedure SYS.DBMS_STATS.GATHER_DATABASE_STATS
#13635 Test container does not close in example
#13636 Close testcontainer in example
#13643 Wrong result column type for requested conversion when reading JSONB_ARRAY and JSONB_OBJECT nested in ROW in DB2
#13647 DefaultRecordUnmapper should cache AbstractRow and record type
#13660 PostgreSQL ON CONFLICT .. WHERE .. DO NOTHING generates not valid SQL
#13663 Remove the "modern IDEs" section from the manual
#13664 Avoid ambiguous reference when using Table<R> as SelectField<R> for table conflicting with column
#13667 Link.$schema() is Nullable
#13671 Oracle doesn't support ORDER BY in UPDATE .. SET correlated subquery
#13673 Settings.returnAllOnUpdatableRecord doesn't work for UPDATE queries in HSQLDB
#13676 Improve <inputCatalog/> warning message in code generator
#13681 Cannot use scalar subquery originating from MULTISET in JSON_OBJECT() VALUE clause in Db2
#13691 Manual should link JDBC types to Javadoc

New in jOOQ 3.16.7 (Jun 16, 2022)

Features and Improvements:
#13526 Improve Documentation for DSLContext.fetchStream() and related methods
#13529 Replace internal usage of DatatypeConverter::parseBase64Binary by java.util.Base64
#13531 Support converting from java.sql.Array to Object[] types
#13583 DefaultRecordMapper should check whether user is attempting to map into an inner class
Bug Fixes:
#13466 Expressions based on computed columns must not retain computation reference
#13469 Work around SQLite INSERT .. SELECT .. ON CONFLICT bug
#13474 SQLException when calling oracle.jdbc.driver.ArrayDataResultSet.getMetaData()
#13490 ArrayIndexOutOfBoundsException when rendering PostgreSQL plain SQL template containing ?@
#13492 org.jooq.SQL and manual should document plain SQL templating's capability of recognising :named parameters
#13500 Improve implementation of QualifiedName.hashCode()
#13504 Parser meta lookups don't work for INSERT .. SELECT .. RETURNING
#13511 MySQL, MariaDB, SQL Server may ignore MULTISET subquery ORDER BY clause
#13514 LoaderLoadStep.execute() shouldn't have @CheckReturnValue annotation
#13532 ARRAY_AGG cannot aggregate array columns in H2
#13561 Invalid SQL generated for Oracle when selecting multiple unaliased rows
#13566 MySQL / MariaDB generated columns with enum type are not generated as readonly
#13567 INSERT .. RETURNING emulations shouldn't acquire multiple connections from ConnectionProvider when using ThreadLocalTransactionProvider
#13569 Field::likeIgnoreCase should cast lhs operand just like Field::like and Field::similarTo
#13622 UnsupportedOperationException when selecting single nested row with JSON column
#13626 Wrong code generated for Oracle package procedure SYS.DBMS_STATS.GATHER_DATABASE_STATS
#13644 Wrong result column type for requested conversion when reading JSONB_ARRAY nested in ROW in DB2
#13648 DefaultRecordUnmapper should cache AbstractRow and record type
#13661 PostgreSQL ON CONFLICT .. WHERE .. DO NOTHING generates not valid SQL
#13674 Settings.returnAllOnUpdatableRecord doesn't work for UPDATE queries in HSQLDB
#13677 Improve <inputCatalog/> warning message in code generator
#13682 Cannot use scalar subquery originating from MULTISET in JSON_OBJECT() VALUE clause in Db2

New in jOOQ 3.16.6 (Apr 19, 2022)

Features and Improvements:
#13268 Make QOM::unmodifiable public, internal
#13282 Add more explicit links to Record::from and RecordUnmapper wherever this applies
#13346 Refactor Multiset::jsonxArrayaggEmulation
Bug Fixes:
#13253 Cannot insert data into PostgreSQL XML column due to missing cast
#13256 UpdatableRecord::merge doesn't work in the presence of a unique constraint and in the absence of a primary key value
#13258 batchStore(), batchInsert(), etc. with StatementType.STATIC_STATEMENT throws java.sql.BatchUpdateException
#13279 AbstractRecord.from(String[], TableField[]) no longer works as expected
#13291 NullPointerException in Result.formatJSON(), formatXML(), formatCSV(), formatHTML() when a Record is null
#13305 H2TableDefinition with H2 2.0+ produces wrong code generation output when the run mode is Oracle
#13313 Inlining PostgreSQL CHAR(len)[] types produces VARCHAR[] instead
#13316 Compilation error in generated UDTRecord's POJO constructor if the UDT contains arrays of table records
#13320 Generated records shouldn't have a @ConstructorProperties annotation on their POJO constructor
#13344 jOOQ internals shouldn't create unnamed derived tables
#13351 Internal deprecation note on FieldsTrait::field leaks into generated code
#13353 Inline enum values should be cast to their enum type just like inline bind variables
#13356 Invalid code generated when pojosEqualsAndHashCode option is enabled and column name is 'other'
#13360 CAST to PostgreSQL enum type lacks type qualification
#13362 DataType#getCastTypeName() does not respect rendering settings
#13365 CAST should generate qualified type when casting to Table::getDataType
#13367 Result::formatXML does not escape type names
#13369 NullPointerException when using CAST(x AS user-defined-type) with SQLDialect.JAVA
#13372 Error when nesting ROW() expressions with values instead of with fields, with degree > 22
#13376 Select.asTable() should delay slow call to Tools::autoAlias
#13381 Generated SQL Server code uses sp_executeSQL, which fails for binary (case sensitive) collations
#13387 Invalid SQL generated in Oracle 11g when query has LIMIT clause and scalar subqueries without explicit aliases
#13397 Update spring-core dependency to 5.3.18 to mitigate CVE-2022-22965
#13404 MULTISET and ROW generated nested records should not have their changed flags set to true
#13406 Records detached when converting nested multiset
#13413 Generated column name for binary bind values shouldn't use Java's byte[].toString()
#13416 GroupConcat renders string_agg separator argument within wrong parentheses in EXASOL
#13430 DSL.noCondition() isn't applied correctly to aggregate FILTER WHERE clause
#13440 No warning is logged when readonly columns or rowids are not used
#13448 Upgrade to org.postgresql:postgresql:42.3.3 to mitigate CVE-2022-26520

New in jOOQ 3.16.5 (Mar 9, 2022)

Features and Improvements:
#13032 Add a rootPath property to the LiquibaseDatabase configuration for the FileSystemResourceAccessor
#13098 Add Converters.forArrayComponents(Converter<T[], U[]>): Converter<T, U>
#13185 Add Javadoc warnings to UpdatableRecord::fetchChildren, and TableRecord::fetchParent about the N+1 problem
#13247 Add code generation flags to turn off the recognition of jOOQ-specific types
Bug Fixes:
#13025 Record.formatJSON(Writer) and Record.formatXML(Writer) should flush the writer
#13030 SQLDataType.XYZ.getArrayDataType().getTypeName() and getCastTypeName() should produce standard SQL XYZ ARRAY type
#13042 Code generator cannot handle tables from other schemas than PUBLIC referencing H2 enum domain types
#13044 Avoid generating H2 NUMBER type alias for NUMERIC types
#13050 Settings.parseRetainCommentsBetweenQueries doesn't work for the last comment
#13055 java.lang.IllegalArgumentException: Cannot create a VALUES() constructor with an empty set of rows when using JSON_ARRAY(ABSENT ON NULL) in PostgreSQL
#13061 Typo in Records.intoArray(Class) Javadoc
#13083 Cannot use H2 enum values in JSON documents
#13086 Field.sortAsc() should not hard wire NULLS FIRST behaviour
#13090 MySQL's BIT(1) type doesn't map correctly in MULTISET subqueries
#13102 Order of calling DataType.asConvertedDataType(Converter) and DataType.getArrayDataType() should not matter
#13110 Register array types of built-in types in internal static type registry
#13111 jOOQ Open Source Edition shouldn't fail when parsing geometry type in DDL
#13121 Cannot use RETURNING with 2-level nested ROW expressions in SQL Server
#13140 Bad JSONFormat rendering of nested records
#13145 ClobBinding shouldn't call Clob.length() in Firebird
#13158 Work around Oracle / ojdbc bug where JSON_ARRAY() can't combine bind parameter marker with FORMAT JSON
#13164 Compilation error when PostgreSQL stored function has an ANY[] data type reference
#13177 Incorrect parsing of (NULL) row literal in PostgreSQL for nested records, UDTs, etc.
#13179 ERROR: could not determine data type of parameter when projecting PostgreSQL UDT bind value
#13197 Db2 RowAsField emulation using JSON_OBJECT is lacking RETURNING BLOB when using the JSONB emulation
#13206 Boolean values aren't serialised correctly in SQL Server JSON documents
#13209 Cast NULL literal to known type in Derby
#13213 KotlinGenerator cannot read existing catalog/schema version
#13218 Work around xerial SQLite driver's Clob behaviour when data is null
#13221 SQLite's JSON operators don't retain boolean three-valued logic
#13228 Wrong escaping of string literals in doubly nested EXECUTE IMMEDIATE blocks for DDL emulations
#13231 UNNEST with array argument doesn't work in Oracle when used with derived column list
#13234 UNNEST table expression does not maintain derived column list
#13238 ORA-03001: unimplemented feature when nested row emulation produces double quotes in Oracle identifiers
#13241 Code generation fails with H2 2.1.210 when using MySQL execution mode
#13242 NPE in INSERT .. ON DUPLICATE KEY emulation when defaulted PRIMARY KEY value isn't supplied in Oracle

New in jOOQ 3.16.4 (Feb 8, 2022)

New in jOOQ 3.16.3 (Jan 25, 2022)

New in jOOQ 3.16.2 (Jan 14, 2022)

New in jOOQ 3.16.1 (Jan 7, 2022)

New in jOOQ 3.16.0 (Jan 5, 2022)

Features and Improvements:
Add support for spatial extensions
Reduce log level of most DefaultRelations messages from INFO to DEBUG
Add support for additional Firebird 3.0 features
Add support for the standard SQL <data change delta table>
Add support for computed columns
Integration test jOOQ also on the module path
Review manual for places to explain that in jOOQ, views = tables
Add code generation option to generate a synthetic, readonly ROWID column
Add support for PostgreSQL 11 procedures
Support FILTER for GROUP_CONCAT
Add support for MariaDB 10.3 PERCENTILE_DISC, PERCENTILE_CONT, MEDIAN functions
Create a SQL dialect version support manual page
Remove deprecated reference to org.sonatype.oss:oss-parent
Add SQLDialect.H2_2_0_202
Add support for readonly columns
Add a new DSL.systemName type
Remove Alias.SUPPORT_DERIVED_COLUMN_NAMES_SPECIAL3 on SQLDialect.H2_2_0_202
Add support for the Oracle 21c WINDOW clause
merge() should support fetching generated keys, where possible
Modularise jOOQ-meta, jOOQ-codegen and others
Make org.jooq.impl.CombinedCondition a binary expression
Enum literals should be defined by generator strategies
Add documentation for formatChart()
Add SQLDialect.ORACLE21C
Add DSLContext.fetchMap(ResultQuery<? extends Record2<K, V>>) and fetchGroups(ResultQuery<? extends Record2<K, V>>)
Support parsing the JDBC escape syntax { call ... }
Add JSON support for SQLite via the JSON1 extension
Add ParseListener.parseStart() and parseEnd() events
Add support for GROUP BY DISTINCT
Let Table<?> extend GroupField
Add more startup tips to be logged with the jOOQ logo
Emulate DML in WITH using data change delta tables
Address known limitations of MULTISET support
Add support for MariaDB 10.6
Support nesting ROW in MULTISET
Spring Boot example should use `@SpringBootApplication(exclude = { R2dbcAutoConfiguration.class })`
Document lack of correlated MULTISET support in Db2, H2, MariaDB, MySQL 5.7
Split MCVE template into 3 modules for Java, Scala, and Kotlin
Add a cache for Tools.fieldName() and fieldNameString()
Add support for TO_CHAR in Db2
Remove "These are currently generated" from single page manual and PDF manual
Upgrade R2DBC dependency to 0.9.0.RELEASE
Improve formatting of XMLELEMENT()
Add an R2DBC example project to our examples
Avoid reflection with ParserImpl.IGNORE
Add support for enums in PostgreSQL R2DBC
Avoid maven per-execution configuration in manual, if unnecessary
Add missing DSL.dateSub() overloads
Support parsing Oracle 21c's JSON construction convenience syntax
Let RowIdImpl implement toString(), equals(), hashCode()
Add Configuration::formattingProvider to offer various formatting related SPIs
Add missing @NotNull annotations to TXTFormat, CSVFormat, JSONFormat, XMLFormat, ChartFormat
Add support for SQLDialect.POSTGRES_14
Add DMLQuery<R> as a common super type for Insert<R>, Update<R>, Delete<R>, Merge<R>
Add parser support for DML in CTEs
Add another jOOQ testcontainers example that includes using Flyway
Add ParseContext.characters() to access and replace the SQL char[]
Upgrade ojdbc dependency to 21.3.0.0 and require its module name com.oracle.database.jdbc
Parser should accept 1 and 0 as boolean literals in MySQL
CLI programs should set java.util.loggin.SimpleFormatter.format if not already set
Add a SQLDialect.YUGABYTEDB dialect
Make the OSGi imports for jackson and gson modules optional
Add native support for BIT_AND_AGG() and BIT_OR_AGG() in PostgreSQL
Offer alternative EnumConverter constructor accepting Function<U, T> as a Converter::to implementation
Add public query object model API draft
Extract bitwise operations into their own classes
Extract arithmetic operations into their own classes
Extract CompareCondition and CombinedCondition into their own classes
Generate some Javadoc on implicit join path navigation methods
Add better Javadoc documentation about what Class<T> literals can be passed to DSL.val(Object, Class), etc.
Change source, target, and release level to 17 for Java 17 distribution
Manual should point to JDK 17 Javadoc
Log warning in code generator when wrong runtime version is used
Offer more Settings flag in ParserCLI and TranslationService
SQLDialect.supportedBy() and supportedUntil() should specify that they're inclusive in their Javadoc
Improve some internal Nullable / NotNull annotation usage
DefaultConverterProvider should be able to convert from JSON(B) to the usual JSON types and back
Add new Functions.nullOnAllNull(FunctionN) and nullOnAnyNull(FunctionN)
Add ExecuteScope, a Scope that knows about an ExecuteContext
Add nullability annotations to BindingXYZContext types
Let Function1 <: Function and Function2 <: BiFunction
Add Settings.parseRetainCommentsBetweenQueries
Better seek clause examples
JDBCUtils::safeClose methods should debug log stack traces
Add ExecuteContext::resultLevel and ::recordLevel to indicate the Result and Record nesting level
ControlFlowSignal should use Throwable(String, Throwable, boolean, boolean) super constructor
Add DAO.findOptionalById()
Use INFO level instead of WARNING level for routines with more than 254 parameters
JPADatabase should log a WARNING message if it cannot find any entities on the classpath
Produce compilation error if code generator version doesn't match runtime version
Add SQLDialect.FIREBIRD_4_0
Document that the asterisk may lead to column order mismatches
Manual examples shouldn't re-create Gson or ObjectMapper instances all the time
The JavaGenerator.printDeprecationIfUnknownType should hint at a UDT being in a different schema
Upgrade Spring Boot example to Spring Boot 2.6
Add HANA support for ON DUPLICATE KEY UPDATE et al
Add H2 support for ON CONFLICT ON CONSTRAINT
Add EnumType.<E extends EnumType>lookupLiteral(Class<E>, String) and generate E.lookupLiteral(String) methods
Support distinguishing between STORED and VIRTUAL computed columns
Add Source.of(InputStream, int) and Source.of(Reader, int) to create length limited sources
Add JooqLogger.getLogger(Class<?>, int) to create a logger whose number of messages are limited to some number
Support parsing single element IN predicate without parentheses
Development version of the manual should include a disclaimer in the header
Split manual section about CREATE TABLE into multiple subsections
Manual section "daos" should link to "codegen-daos"
Add support for Informix stored procedures
Add DataType.isSpatial()
Bump log4j-core from 2.16.0 to 2.17.0
Additional SQL statements after JDBC connection
Mention fetchSingle() in the manual section about fetching
Breaking changes:
Migrate Java EE dependencies to Jakarta EE
Add support for H2's data change delta tables
Remove pre 3.6 deprecated API and pre 3.6 documentation
R2DBC execution should wrap R2dbcException in DataAccessException
Unnecessary generic type parameter in localDateAdd and other date time arithmetic functions
Remove DB2DataType.ROWID
Move XSDs from jOOQ and jOOQ-meta to subpackages to avoid split xsd packages
Experiment with sealed classes
Deprecations:
Deprecate Internal.fieldsRow(TableField)
Deprecate PostgresDSL.oid() and replace its usage by actual OID columns
Deprecate IGNITE dialect again
Bug Fixes:
INSERT .. RETURNING does not return any value in H2, when no AUTO_INCREMENT column is involved
Avoid generating new SQL statements for every bind variable length in Firebird 3
Usage of jOOQ API inside of ConnectionProvider.acquire() causes issues with Oracle cross-schema OBJECT type bindingsUse JDK 9 Matcher.replaceAll(Function) instead of Matcher.replaceAll(String) where possible
Support parsing ALTER TABLE ... ADD ... AUTO_INCREMENT
Wrong SQL generated in DB2's NTH_VALUE() IGNORE NULLS window function
Parser missing type information for Enum fields
Codegeneration fails with case sensitive data types in postgres 9.0 or less
Bad translation of identity to CockroachDB
Generator produces an invalid enum with an underscore "_" as the name
Avoid streaming SQL Server FOR JSON or FOR XML in chunked results
Improve JSON_VALUE formatting
Upgrade Liquibase dependency of jooq-meta-extensions-liquibase to 4.x
Parser can't parse functions receiving operator based string expressions
Parsed DATE_ADD and DATE_SUB don't translate correctly when lacking column meta data
R2DBC nested subscription loops forever when nesting or sequencing INSERT .. RETURNING run on r2dbc-pool
Operator called default onErrorDropped: PostgresConnectionClosedException when chaining queries
ORA-06550 when calling a PL/SQL procedure with a %ROWTYPE parameter that has DATE fields when dateAsTimestamp=true and javaTimeTypes=true
Regression in SQLite code generation for unnamed composite pkeys on JDK 9+ with the jOOQ Open Source Edition
Regression in ResultQuery.fetchMap(Field, Field) with null values
Wrong Support annotation: HSQLDB doesn't support MULTISET or MULTISET_AGG
Wrong deserialisation of temporal data types in MULTISET XML emulation
DefaultConverterProvider should be able to convert both ISO timestamp formats to Timestamp and LocalDateTime
MULTISET emulation doesn't correctly deserialise single column record containing only a NULL value in SQL Server
IndexOutOfBoundsException when deserialising MULTISET as XML emulation with NULLs
MULTISET as JSON emulation using JSON_ARRAY must use NULL ON NULL clause
Data conversion error converting "TIMESTAMP to JSON" in H2
Regression when binding JSONB value containing a JSONB string in PostgreSQL
Setter return type must be Unit & '@set:' annotations could be applied only to mutable properties
DSL.using(String, String, String) based R2DBC Connection does not use provided username and password
[jOOQ/jOOQ#12149] Use username and password properties for r2dbc connection
Nested multiset record mapping fails at the 3rd level of nesting
MULTISET/JSON emulation can't read TIME type in Db2
Error when embedding a timestamp in Db2 XMLELEMENT
Deeply nested MULTISET produce quoted JSON in MariaDB
Unnecessary finalizer registration in DefaultConnectionProvider
SQL Server doesn't correctly serialize TIME bind values in FOR XML and FOR JSON usage
An R2dbcException wrapping DataAccessException should properly produce sqlState() and other properties
The XML MULTISET_AGG emulation doesn't work with unnamed bind values in Db2
Db2 cannot handle scalar subqueries in JSON_OBJECT in the presence of a MULTISET ad-hoc converter
INSERT .. RETURNING doesn't work in H2 when a composite key does not have the identity as its first column
MySQL DELETE .. USING with JOIN produces duplicate table declarations in USING clause
The DataKey.DATA_PREPEND_SQL and DATA_APPEND_SQL feature must work on Query only, not other QueryParts
SelectOnStep::onKey returns wrong type, preventing combinations of join predicates
Error when embedding a timestamp in Db2 XMLATTRIBUTES
Deeply nested MULTISET mappings with ad-hoc conversion doesn't work when using reflection
Aliasing implicit join paths produces invalid queries
Remove references to javax.annotation.Generated from jooq-codegen Javadoc
DefaultConverterProvider truncates timestamps to milliseconds precision when converting from Timestamp to LocalDateTime
Embeddables cannot be placed in MULTISET
NullPointerException in MetaImpl.MetaTable.getReferences() when there are catalog conflicts in SQL Server
Inconsistent formatting of table list when using generated or non-generated aliased tables
Replace remaining reflective call to OracleConnection.createARRAY from DefaultBinding
Long lists are no longer wrapped when rendering formatted SQL
NullPointerException when reading empty results for MULTISET_AGG / JSON emulation
Delay initialisation of Jackson, Gson, JAXB classes in Convert
Custom data type binding example in manual works only on JDBC, not R2DBC
jOOQ 3.15.0 XSD is not published?
Wrong method name used in manual section schema-diff
Empty subsection in manual section codegen-config-generator
IllegalArgumentException: Minimum abbreviation width is 4 when TXTFormat::minColWidth is less than 4
java.lang.NoClassDefFoundError: javax/xml/bind/annotation/XmlSchema when running examples from manual tutorial
In manual section jooq-in-7-steps-step3, fix multi line shell syntax
Reference to database and/or server name in 'master.sys.schemas' is not supported in this version of SQL Server.
Wrong table list to ANSI join transformation when tables are qualified and aliased
Wrong result for Table or Field.getQualifiedName() on aliased table(Name) or field(Name)
MockDataProvider cannot handle MULTISET fields
Wrong procedure declaration generated in MySQL when using IN parameters with VARCHAR(length) types
ParseListener example doesn't compile, should use onParseCondition(), not onParseField()
Wrong (+) to LEFT JOIN transformation in join tree A⟕B, A⟕C, A⋈D
ImmutablePOJOMapper cannot map more than one nested POJO on the same level
Empty select() should not project asterisk if unknown table is used with leftSemiJoin() or leftAntiJoin()
Result.formatChart() produces bad default formatting for Display.HUNDRED_PERCENT_STACKED
IndexOutOfBoundsException when calling Result.formatChart() on an empty result
Improve <dialects/> to display correct number of dialects for operators
Inline floating point formatting shouldn't depend on default Locale
Wrong SQL example in manual section multiset-value-constructor
Nested Block generates top-level anonymous block behaviour when top level Statement is not a Block
Spelling mistake in manual section "jooq-with-flyway"
ClassCastException when using returning() with R2DBC
NullPointerException in OracleDatabase.getArrays0()
Wrong type documented in INSERT .. RETURNING section of the manual
DSLContext.explain(Query) doesn't work with bind values in Oracle
Positional window functions without ORDER BY should generate ORDER BY 1 in Oracle
FOR JSON emulation must use RETURNING CLOB in Oracle
DataTypeException in multiset with a mapped nested row
BIT_AND_AGG(), BIT_OR_AGG() emulations shouldn't use bind values
CVE-2021-26291 via maven-core-3.6.3 dependency
Avoid generating overloaded table valued functions with compilation errors, until they are supported
Fix generating multi-key DAOs with Java records
Compilation errors in generated code when using <daos/> with <pojosAsJavaRecordClasses/>
Unnecessary cast in Db2 when comparing value with concatenation
KotlinGenerator setter return type must be Unit also for records
H2 enum values which contain brackets are not generated as Java literals
MockFileDatabase example doesn't compile
InlineDerivedTable shouldn't inline when used in outer joins
DSL.arrayGet() does not generate required parentheses
api-diff generates wrong nested class Javadoc links
Clarify whether .offset(..) starts from 0 or 1
Ignored COMMENT ON CONSTRAINT syntax should support qualified object identifiers
Meta does not produce correct DataType::nullable information when data type isn't supported
Wrong documentation in section "codegen-database-regex-flags"
Unable to fetch Instant field within a multiset
NPE in Query.equals() when Query isn't attached
Cannot map JSON(B) in MULTISET when mapping with Jackson from DefaultConverterProvider
Field with Converter<String, Boolean> inside multiset causes JSON parsing error on Oracle
Parser should support PERCENTILE_CONT / PERCENTILE_DISC with expressions as percentiles
DefaultExecuteContext.LOCAL_SCOPE is reset to null when nesting lazy executions
ParserCLI interactive mode ignores setting booleans to false
ParserCLI interactive mode can't handle leading /* comment block
Field<Instant>.div(int) regression for Instant fields that have a converter
Lenient support for H2's time zone format when using the Instant type
Wrong JSON_MERGE_PRESERVE function generated when embedding JSON in MULTISET in MariaDB and MySQL
Add support for unwrapping Optional types in DefaultConverterProvider
ROWNUM transformation doesn't work when projecting an expression containing ROWNUM
Exception in LoggerListener when projecting top level row(...).mapping()
Connection leak when ExecuteListener::fetchEnd throws an exception
CockroachDB IDENTITY column recognition is broken
ParamType.INLINED produces wrong behaviour for Settings.cacheParsingConnection
Incorrect MERGE statement syntax generated in FIREBIRD when aliasing USING derived table
Parser cannot parse INSERT .. SELECT without column list
SQLDataType.null generated when using XMLDatabase with lower case array type
Generated column in table valued function of type TIMESTAMP without precision is generated using precision zero
OracleDatabase::sequences produces query that doesn't work on older ojdbc driver versions
typo in jOOQ-academy setup script
OracleDatabase doesn't produce correct CYCLE sequence flag information in code generation
Parser should support PostgreSQL date part syntaxes with explicit type casts
Parser parses and ignores NOT keyword after column expression
Fix Firebird Support annotations on INSERT .. ON DUPLICATE KEY UPDATE as well as UpdatableRecord.merge
Wrong SQL generated for PostgreSQL functions returning single UDT OUT parameters
Restore streaming bind value method behaviour on ParsingStatement
Blob.length() and Clob.length() calls shouldn't be silently downcast to int
HanaTableDefinition reports all computed columns as identities
MariaDBDatabase no longer generates check constraints
Potential resource leak in SettingsTools static initialiser
Regression in code generation catalog mapping
Mapped JSON in multiset causes multiple ad-hoc conversions
Single element IN predicate without parentheses uses wrong operator precedence
DefaultRecordUnmapper.IterableUnmapper uses name based field access instead of index based ones, leading to ambiguities
Cannot nest MULTISET in top level ROW in PostgreSQL
Parser mis-interprets KEY columns as MySQL KEY (INDEX) specification if unquoted and of type VARCHAR(n)
Debug log output causes exceptions when data type converter is re-applied incompatibly
Some manual "previous" and "next" links use wrong URL
DB2Database should order routine overloads by signature, not specificname
Update log4j to 2.15.0 because of CVE-2021-44228
Loader.onDuplicateKeyIgnore doesn't work on tables that don't have a PRIMARY KEY
ListAgg not working with filter clause.
Bump h2 from 1.4.199 to 2.0.202 in /jOOQ-examples/jOOQ-javafx-example
DDLDatabase defaultNameCase property shouldn't affect built in functions in view definitions
SQLDialect.JAVA produces wrong output for quotedName()
DSL.unquotedName() has wrong Javadoc
Compilation errors in generated code when enabling <pojosAsJavaRecordClasses> and <embeddables>
Support generating the PostGIS GEOMETRY type as SQLDataType.GEOMETRY

New in jOOQ 3.15.5 (Dec 2, 2021)

New in jOOQ 3.15.4 (Oct 27, 2021)

New in jOOQ 3.15.3 (Sep 17, 2021)

New in jOOQ 3.15.2 (Aug 25, 2021)

Features and Improvements:
Improve formatting of XMLELEMENT()
Add more startup tips to be logged with the jOOQ logo
Avoid reflection with ParserImpl.IGNORE
Let RowIdImpl implement toString(), equals(), hashCode()
Add parser support for DML in CTEs
Bug Fixes:
The DataKey.DATA_PREPEND_SQL and DATA_APPEND_SQL feature must work on Query only, not other QueryParts
Error when embedding a timestamp in Db2 XMLATTRIBUTES
MySQL DELETE .. USING with JOIN produces duplicate table declarations in USING clause
Remove references to javax.annotation.Generated from jooq-codegen Javadoc
DefaultConverterProvider truncates timestamps to milliseconds precision when converting from Timestamp to LocalDateTime
Avoid streaming SQL Server FOR JSON or FOR XML in chunked results
Embeddables cannot be placed in MULTISET
NullPointerException in MetaImpl.MetaTable.getReferences() when there are catalog conflicts in SQL Server
Inconsistent formatting of table list when using generated or non-generated aliased tables
Replace remaining reflective call to OracleConnection.createARRAY from DefaultBinding
Long lists are no longer wrapped when rendering formatted SQL
NullPointerException when reading empty results for MULTISET_AGG / JSON emulation
Delay initialisation of Jackson, Gson, JAXB classes in Convert
IllegalArgumentException: Minimum abbreviation width is 4 when TXTFormat::minColWidth is less than 4
Reference to database and/or server name in 'master.sys.schemas' is not supported in this version of SQL Server.
Wrong table list to ANSI join transformation when tables are qualified and aliased
Wrong result for Table.getQualifiedName() on aliased table(Name)
Parsed DATE_ADD and DATE_SUB don't translate correctly when lacking column meta data
Parser can't parse functions receiving operator based string expressions
Wrong procedure declaration generated in MySQL when using IN parameters with VARCHAR(length) types
Wrong (+) to LEFT JOIN transformation in join tree A⟕B, A⟕C, A⋈D
Empty select() should not project asterisk if unknown table is used with leftSemiJoin() or leftAntiJoin()
IndexOutOfBoundsException when calling Result.formatChart() on an empty result
Inline floating point formatting shouldn't depend on default Locale

New in jOOQ 3.15.1 (Jul 14, 2021)

Features and Improvements:
Spring Boot example should use `@SpringBootApplication(exclude = { R2dbcAutoConfiguration.class })`
Wrong Support annotation: HSQLDB doesn't support MULTISET or MULTISET_AGG
Document lack of correlated MULTISET support in Db2, H2, MariaDB, MySQL 5.7
Breaking changes:
R2DBC execution should wrap R2dbcException in DataAccessException
Bug Fixes:
R2DBC nested subscription loops forever when nesting or sequencing INSERT .. RETURNING run on r2dbc-pool
Support nesting ROW in MULTISET
Regression in ResultQuery.fetchMap(Field, Field) with null values
Wrong deserialisation of temporal data types in MULTISET XML emulation
DefaultConverterProvider should be able to convert both ISO timestamp formats to Timestamp and LocalDateTime
MULTISET emulation doesn't correctly deserialise single column record containing only a NULL value in SQL Server
IndexOutOfBoundsException when deserialising MULTISET as XML emulation with NULLs
MULTISET as JSON emulation using JSON_ARRAY must use NULL ON NULL clause
Data conversion error converting "TIMESTAMP to JSON" in H2
Regression when binding JSONB value containing a JSONB string in PostgreSQL
Regression in SQLite code generation for unnamed composite pkeys on JDK 9+ with the jOOQ Open Source Edition
DSL.using(String, String, String) based R2DBC Connection does not use provided username and password
Setter return type must be Unit & '@set:' annotations could be applied only to mutable properties
Nested multiset record mapping fails at the 3rd level of nesting
MULTISET/JSON emulation can't read TIME type in Db2
Error when embedding a timestamp in Db2 XMLELEMENT and other XML functions
Add support for TO_CHAR in Db2
ORA-06550 when calling a PL/SQL procedure with a %ROWTYPE parameter that has DATE fields when dateAsTimestamp=true and javaTimeTypes=true
Deeply nested MULTISET produce quoted JSON in MariaDB
Unnecessary finalizer registration in DefaultConnectionProvider
SQL Server doesn't correctly serialize TIME bind values in FOR XML and FOR JSON usage
An R2dbcException wrapping DataAccessException should properly produce sqlState() and other properties
The XML MULTISET_AGG emulation doesn't work with unnamed bind values in Db2
Db2 cannot handle scalar subqueries in JSON_OBJECT in the presence of a MULTISET ad-hoc converter

New in jOOQ 3.14.12 (Jul 2, 2021)

New in jOOQ 3.14.11 (May 24, 2021)

New in jOOQ 3.14.10 (May 20, 2021)

New in jOOQ 3.14.9 (Apr 20, 2021)

Features and Improvements:
#11775 Add a Settings.forceIntegerTypesOnZeroScaleDecimals
Bug Fixes:
#11561 java.lang.ClassCastException: class org.jooq.impl.ResultImpl cannot be cast to class java.sql.ResultSet when mocking Oracle SYS_REFCURSOR procedure
#11568 JDBCDatabase doesn't yet distinguish between TableType.TABLE and VIEW and others
#11577 DefaultMetaTableDefinition doesn't consider DataType.identity() flag
#11592 Misleading Javadoc about Settings.isInsertUnchangedRecords
#11597 ArrayTable doesn't pass derived column list to ArrayTableEmulation
#11600 Avoid auxiliary derived table in SQLite GENERATE_SERIES emulation
#11610 fetchParent() doesn't work properly with foreign key referencing just a part from a composed primary key
#11615 Fix @Support on ALTER TABLE .. RENAME INDEX
#11617 Missing DB2 and Derby @Support on DROP SCHEMA .. RESTRICT
#11622 Parser wrongly recognises VERSIONS table alias as keyword
#11635 XMLFormat.quoteNested() is not being considered in Result.intoXML()
#11636 intoXML() throws NPE exception
#11664 Wrong order of WINDOW / QUALIFY clauses
#11668 Oracle MetaTable fields do not have identity information
#11676 PostgresDatabase doesn't produce CHAR type length for CHAR(n)[] array types
#11702 Infinity values not correctly escaped with PostgreSQL
#11710 Oracle typed REF CURSOR produce wrong code
#11726 Sequence.nextvals() does not yet work in SQL Server
#11728 Wrong precision for H2 timestamp when using domains
#11735 Column "INFORMATION_SCHEMA.COLUMNS.INTERVAL_TYPE" not found in H2 1.4.197
#11742 Blocking subscriber.onComplete called after subscriber.onError
#11750 TO_CHAR(x) without format is not natively supported in PostgreSQL
#11764 Regression when using plain SQL H2 array types
#11765 Passing an empty array or collection to returningResult() does not match the behaviour of returning()
#11773 PostgreSQL ON CONFLICT .. WHERE <index_predicate> generates not valid SQL
#11776 Oracle UPDATE .. RETURNING emulation doesn't work for boolean data type rewrites

New in jOOQ 3.14.8 (Feb 26, 2021)

New in jOOQ 3.14.7 (Feb 2, 2021)

New in jOOQ 3.14.6 (Jan 27, 2021)

New in jOOQ 3.14.5 (Jan 22, 2021)

Features and Improvements:
Add Name.qualifierQualified() to check if a Name's qualifier (if any) is qualified as well
Add Javadoc to Map producing API (fetchMap(), fetchGroups()) about map iteration order guarantees
Clarify unused logger warning message about what is obsolete
Breaking changes:
KotlinGenerator generates Record[N]<T1, T2, ..., TN> for PK types in DAOs, instead of Record[N]<T1?, T2?, ..., TN?>
Bug Fixes:
Compilation errors for <implicitJoinPathsToOne/> when referenced table is called RECORD_TYPE
Avoid synthetic ORDER BY clause in window functions of remaining dialects if not strictly necessary
StackOverflowError generating code from Postgresql XML schema with ARRAY columns
Add support for parsing INSERT .. WITH .. SELECT
Support parsing table aliases in DELETE statements
Code generator does not produce indexes for quoted identifiers in PostgreSQL
KotlinGenerator should generate kotlin.Deprecated annotation instead of java.lang.Deprecated
Improve performance of Record.into(Table) and related calls
Override CatalogImpl.equals()
Wrong SQL generated when DomainDataType is loaded before base SQLDataType for SQLDialect.DEFAULT
Misleading error message when something goes wrong in the code generator
NullPointerException when custom JavaGenerator subclasses don't call JavaWriter.printPackageSpecification()
NullPointerException when GenerationTool is not properly initialised
Cache implicit join path references
Nested records produced by DefaultRecordMapper do not pass through RecordListener lifecycle
Avoid calling AbstractQueryPart::equals
ParseWithMetaLookups looks up columns in Meta that cannot possibly appear in query
ParseWithMetaLookups propagates wrong type from derived table
ParseWithMetaLookups produces wrong projection on self join
ParserWithMetaLookups reports ambiguous column in correlated subquery, when there is none
DataType.convert(Object...) and convert(Collection<?>) don't work for converted data types
Omitting parts of the foreign key in onKey(TableField…) doesn't produce the expected result
Compilation errors in generated DAOs when embeddables use <replacesFields/>
Compilation errors in generated embeddable pojos if the embeddable is located in a "synthetic" schema
MetaTable::getReferences and MetaUniqueKey::getReferences do not take into account inverseSchemaCatalog
ArrayStoreException when calling ResultQuery<Record[N]>.fetchArray()
Multithread deadlock: org.jooq.impl.AbstractField references subclass org.jooq.impl.Val in static initializer
JDBCUtils.dialect() should recognise MariaDB versioned SQLDialect
DROP TEMPORARY TABLE doesn't generate TEMPORARY keyword in MariaDB
Settings.isMapConstructorParameterNamesInKotlin doesn't work for kotlin inline classes
Parser throws IllegalArgumentException instead of ParserException when date_trunc() is parsed with invalid DatePart
Parser fails when union subquery contains correlated subquery #11235
Generated order of check constraints does not respect Database::getOrderProvider
SelectQuery.setForUpdate and similar methods do not clear flag when value is false
NullPointerException when calling MetaImpl.snapshot() on a PostgreSQL schema with function based indexes
Meta.getTables() does not include PostgreSQL foreign data wrapper tables
Interpreter cannot find unique key if foreign key references columns in different order
NullPointerException in MetaImpl.snapshot() when foreign key column order doesn't match unique key column order
The default SQL generated for DATEADD() is an empty string
Wrong support annotation for FIREBIRD ALTER TABLE .. RENAME

New in jOOQ 3.14.4 (Nov 26, 2020)

Features and Improvements:
Add additional JSONFormat options to optimise formatting of JSON in the presence of SQL/JSON result set content
Add JavaGenerator.printDaoConstructorAnnotations() to allow for custom annotations in generated DAO constructors
Throw more explicit DataTypeException when Convert fails to convert between JSON/JSONB/XML and a user-defined type
Bug Fixes:
Compilation error in ScalaGenerator generated code when table has column "CLASS"
Deadlock on lazy initialisation of Tables in Scala
KotlinGenerator does not annotate properties with <jpaAnnotations/>
java.lang.ClassCastException: class java.lang.Class cannot be cast to class java.lang.reflect.ParameterizedType when custom data type extends List
jOOQ trial version 3.14.3 uses org.jooq.trial-java-8 groupId in pom.xml files but installs things as org.jooq.trial
KotlinGenerator produces compilation error in generated interfaces when <jpaAnnotations/> is set
Wrong code generated by KotlinGenerator for <validationAnnotations/>
PostgreSQL supports XMLTABLE only after version 10
KotlinGenerator produces compilation errors in UDT Records when <recordsImplementingRecordN/> is true
Ignore <records>false</records> for UDTRecords
Converter using primitive types fails when used in UDT array in PostgreSQL
Wrong SQL generated for IIF() emulation in MySQL
Code generator warning message should refer to deprecated <customType/> only if customType configuration is present
Compilation error in KotlinGenerator generated code, when OTHER data type columns have a default value
Address known issues of Settings.transformTableListsToAnsiJoin
Missing data type display in ParserCLI help listing
Add missing documentation about throwing of DataDefinitionException in relevant API
Unqualified field lookup in ON DUPLICATE KEY UPDATE clause doesn't work
JPAConverter may cause DataTypeException if it does not detect the proper <T, U> types using reflection
Parser should support plural form of DatePart where applicable
Parser should ignore TRUNC() call when parsing TRUNC(CURRENT_DATE) or TRUNC(SYSDATE)
Ambiguous field identifier when parsing unions with unqualified columns and parseWithMetaLookups
Unknown field identifier when parsing ORDER BY clauses referencing field aliases with parseWithMetaLookups
Parser cannot parse set operations combining SELECT * with SELECT <column list>
Support ARRAY_AGG in H2
jOOQ-checker does not work with error prone 2.4.0
XMLDatabase does not produce parameters for overloaded routines
Wrong SQL generated for INSERT .. SELECT .. ON DUPLICATE KEY IGNORE emulation using NOT EXISTS
<includeSystemCheckConstraints/> fails with missing FROM-clause entry for table "alias_18649163" on PostgreSQL
Wrong Oracle style to ANSI JOIN transformation result, depending on predicate order
Parser cannot look up column from tables by same name from different schemas
Compilation error in KotlinGenerator generated code when enum literals conflict with modifier keywords
Wrong SQL generated when outer and correlated subquery share implicit join path
Subquery IS [ NOT ] NULL predicate should avoid RVE emulation for degree = 1
Kotlin POJO generator produces wrong equals/hashCode for binary types
KotlinGenerator should generate equals(other: Any?), not equals(obj: Any?) on pojos
Wrong variable binding for boolean values in Oracle and Db2 JSON_OBJECT(), JSON_ARRAY() and others
The NAME keyword in XMLELEMENT(NAME <name>) should be optional for the parser
Avoid synthetic ORDER BY clause in window functions if not strictly necessary

New in jOOQ 3.14.3 (Nov 10, 2020)

New in jOOQ 3.14.2 (Nov 9, 2020)

New in jOOQ 3.14.1 (Oct 28, 2020)

New in jOOQ 3.14.0 (Oct 20, 2020)

Features and Improvements:
#229 Enhance API to provide access to ARRAY elements
#681 Add support for type DOMAINs
#1571 Add support for REGEXP_REPLACE()
#1962 Improve formatting of SQL rendered by window functions
#2230 Add support for INTERVAL data types in code generator
#2530 Add support for "fetch groups" or "embedded record types", where a group of fields is defined as a reusable RowN type across various tables
#2961 Add UpdatableRecord.merge()
#3419 Add support for intercepting PreparedStatements, collecting individual bind value sets into larger batch sets
#3505 Emulate quantified comparison predicates for row value expressions, if not natively supported
#3564 Emulate PostgreSQL's DISTINCT ON clause
#3713 Add <pojosAsScalaCaseClasses/> to the code generator to generate case classes
#3774 Move Configuration thread safety content to new section
#3896 Add Configuration.converterProvider() to allow for implementing default converters between <T> and types
#4528 Add manual section about DSLContext.connection()
#4941 Add LoaderListenerStep.onRowStart() for preprocessing input data
#5216 Add UpdatableRecord<R>.children(ForeignKey<O, R>): Table<O>
#5218 Add support for FOR SHARE OF in Postgres dialect
#6124 Add code generator option to generate an embeddable record per primary / unique key
#6183 Add GeneratorStrategy.getGlobalReferencesFile(Class.class) and getGlobalReferencesJavaClassName(Class.class) etc. to allow for overriding the files that contain global references
#6187 Add Schema.getTable(Name), getSequence(Name), getUDT(Name), getDomain(Name)
#6188 Add Catalog.getSchema(Name)
#6248 Implement KotlinGenerator
#6256 Add Kotlin infix and extension functions to a new jOOQ-kotlin extensions module
#6345 Generate Kotlin data classes
#6456 Generate comments also on POJOs
#6501 Can we profit from Kotlin's named and defaulted parameters for procedure calls, record constructors etc?
#6598 Support mapping into nested immutable POJOs
#6736 Add support for PostgreSQL ON CONFLICT .. WHERE <index_predicate>
#7067 Specify jOOQ's lack of Serializable backwards compatibility in the manual
#7155 Add support for synthetic foreign keys
#7168 Maven, Gradle, programmatic configuration code should be toggled using tabs
#7253 Add support for Loader.batchAll() with onDuplicateKeyIgnore()
#7262 Improve formatting of dual emulations
#7291 Add support for multiple MERGE .. WHEN MATCHED AND { condition }
#7312 Add Setting to transform table lists to ansi join
#7507 Implicit Joins should produce inner joins when possible
#7553 Add more and better DDL examples to the manual
#7681 Add programmatic and Gradle examples on how to configure generator strategies in the manual
#7711 Support recent features for Sybase ASE
#7860 Add support for synthetic unique keys
#7997 Emulate DISTINCT predicate using DECODE in Db2, H2, Oracle
#8054 Support `NO WAIT` with FOR SHARE on MySQL/Postgres
#8254 Publish an API version diff in the manual
#8353 Fix known limitations of embeddable types
#8381 Pull up OracleDSL.toChar() to DSL
#8384 Emulate support for INSERT INTO t [ AS alias ]
#8450 Improve procedural language abstraction API
#8492 DSL.row(Collection<?>) should also accept Select in argument collection
#8519 Add native support for H2 JOIN .. USING syntax
#8548 Add support for SQLite window function extensions from version 3.28
#8553 Add support for foreign keys referencing unique key columns in different order than in the unique key definition
#8575 Implement native support for H2 RATIO_TO_REPORT()
#8592 Emulate PERCENT_RANK and CUME_DIST where not natively supported
#8719 Use native support for H2 <rve> IS [ NOT ] NULL predicate
#8732 Add native support for H2's new UNIQUE predicate
#8805 Support OVERLAY() function
#8841 Redshift: Support ILIKE
#8844 Emulate FOR UPDATE SKIP LOCKED using READPAST table hint
#8949 Add CharsetProvider SPI
#8950 Add support for standard JSON functions - continued
#9017 Add Settings.transformRownum
#9044 Add support for parsing single parameter numeric TRUNC() function
#9054 Manual headers should offer a link to the "latest" version
#9061 Improve Settings.parseWithMetaLookups
#9131 Support parsing MySQL BIT(1) value literals
#9212 Add support for MariaDB INSERT and DELETE RETURNING
#9351 Let DataType extend QueryPart
#9404 AbstractKey and subtypes should accept Name instead of string in constructors
#9492 Deprecate static data type registry lookups for user defined data types
#9496 Improve formatting of CREATE TABLE and derived column lists
#9639 Apply Database::getOrderProvider to Keys.java content as well
#9744 Add <locale/> to code generator <target/> specification
#9764 Rework formatting of SQL
#9775 Various parser bugs / missing features
#9798 Make the names in org.jooq.impl.Names unquoted
#9825 Document new jOOQ-refaster module
#9833 Add missing @Support annotation to DSLContext#fetch*() methods
#9839 Remove manual version 3.2, unsupport 3.7
#9841 Update documentation to refer to org.jooq.trial-java-8 Maven groupId
#9851 Rewrite ResultQuery Javadoc
#9861 Add covariant overrides Record[N].with(Field, T) for fluent setting of values on a Record
#9866 Liquibase imports should use ClassLoaderResourceAccessor
#9868 SQL Server: Support STRING_AGG() function
#9872 LiquibaseDatabase should use configured changeLogParameters.contexts when updating
#9874 [#9872] LiquibaseDatabase should use provided contexts on update
#9881 DB2: Support ALTER TABLE ... DROP PRIMARY KEY
#9882 Deprecate SQLDialect#supports(Collection<SQLDialect>) method
#9885 Add support for DSL.execute() in Oracle
#9888 Support parsing some PostgreSQL specific matching operators
#9889 Add support for native ILIKE in H2
#9891 Change Pro annotation retention to class
#9894 DB2: New aggregate functions in version 11
#9898 Implement native support for LIKE ANY et al in PostgreSQL
#9899 Programmatic code generator configuration documentation should fully qualify org.jooq.meta.jaxb.Configuration
#9900 Add TransactionalRunnable.of(TransactionalRunnable...) to compose nested transactions
#9902 Add Settings to apply native JSR 310 data type binding
#9911 Deprecate Comparator.supportsQuantifier() and supportsSubselect()
#9921 Offer additional settings as dropdowns in /translate
#9923 Add support for FOR XML and FOR JSON
#9924 Emulate SQL Server FOR XML (single table) in other dialects
#9925 Add support for standard XML functions
#9926 Emulate SQL Server FOR JSON (single table) in other dialects
#9927 Add support for JSON_ARRAYAGG
#9928 Add support for JSON_OBJECT <JSON constructor null clause>
#9930 Add internal DefaultAggregateFunction and DefaultWindowFunction
#9932 Add DSL.jsonEntry(String, Field) and jsonObject(String, Field)
#9936 Add support for JSON_OBJECTAGG
#9938 Emulate SQL Server FOR JSON PATH and FOR XML PATH with dot / slash notation in other dialects
#9939 Emulate SQL Server FOR JSON AUTO nested collections from to-many joins
#9950 Improve support for EXECUTE for use in procedural blocks
#9952 Implement procedural language support for Firebird
#9958 Add DataType.precisionDefined(), scaleDefined(), lengthDefined()
#9959 Code generator should produce TIMESTAMP(precision) calls instead of TIMESTAMP.precision(precision)
#9967 Add support for HSQLDB temporal tables
#9971 Support parsing BETWEEN ASYMMETRIC where the SQL standard supports it
#9973 Remove internal AbstractFunction
#9976 Deprecate also CUBRIDDSL
#9977 Add more thread safety documentation around DSLContext and Configuration
#9979 Add DSL.val(), value(), and inline() overloads for JSON, JSONB, and XML types
#9985 Refactor some rendering logic to make better reuse of QueryPartList
#9986 Add an internal QueryPartListView class
#9990 Add some convenience API to SQLDialect, delegating to JDBCUtils
#9991 Offer an org.jooq.impl.AbstractBinding base implementation for the common case
#9994 Add missing with(Collection<? extends CommonTableExpression<?>>) overloads
#9995 Add SQLDialect.POSTGRES_12
#10000 Add DSL.tau() to support τ, which is a better π
#10008 Add a configuration flag to DDLDatabase to specify whether queries should be logged
#10010 Rename Loader { CSV | JSON | Rows } Step.fieldsFromSource() to fieldsCorresponding()
#10013 Add <constructorPropertiesAnnotation/> to generate @ConstructorProperties on pojos and records
#10015 Replace internal usages of QueryPartList by QueryPartListView
#10016 Improve H2's derived column list support
#10023 Add Table.with(SQL) to allow for plain SQL templating in T-SQL style table hints
#10024 Upgrade dependencies
#10025 Move Keywords.F_XYZ to Names.N_XYZ and make them unquotedName
#10032 Add a /doc/dev URL mapping to the manual
#10038 Add SQLDialect.ORACLE20C
#10040 Add support for Oracle 20c EXCEPT ALL and INTERSECT ALL
#10041 Add support for Oracle 20c window function GROUPS and EXCLUDE clauses
#10042 Add RecordListener.mergeStart() and RecordListener.mergeEnd() lifecycle events
#10043 Add Support annotations to TableRecord.insert(), UpdatableRecord.store(), DAO.update(), etc.
#10045 Deprecate the H2 style MERGE statement
#10046 Add DSLContext.batchMerge()
#10049 Add DAO.merge()
#10050 Add support for optimistic locking with UpdatableRecord.merge()
#10052 Add support for standard SQL MERGE .. WHEN MATCHED [ AND .. ] THEN DELETE
#10053 Improve tutorial "jOOQ as a SQL builder" explaining the resulting bind parameter markers
#10060 Emulate JSON_ARRAYAGG() in older MariaDB versions
#10061 Add native support for DISTINCT predicate in Db2
#10064 trueCondition(), noCondition() and falseCondition() should generate TRUE and FALSE, where BOOLEAN types are supported
#10068 Add native support for the DB2 11.1 OVERLAPS predicate
#10070 jOOQ should allow empty JOIN .. USING clauses
#10071 DefaultRecordMapper should apply ConverterProvider for Record1.into(...) calls
#10072 Out of the box support mapping between XML/JSON and POJOs using JAXB or Jackson/Gson
#10074 Provide default implementation of AbstractTable.as(Name)
#10075 Support unqualified column lookups in parser
#10078 Create manual subsections for each function
#10079 Create subsections in the manual for aggregate function features
#10082 Add JSON.json(), JSONB.jsonb(), XML.xml() methods
#10085 Add DataType.isJSON() and isXML()
#10089 Emulate JSON_OBJECTAGG where unavailable
#10090 Add a <generatedAnnotationDate/> flag to allow for turning off generating @Generated.date()
#10094 Emulate FOR XML AUTO with joins in other dialects
#10097 Add support for DB2 CREATE INDEX .. EXCLUDE NULL KEYS clause
#10099 Emulate XMLTABLE in SQL Server with NODES() and VALUE()
#10100 Emulate JSON_TABLE in SQL Server with OPENJSON
#10104 Add synthetic FOR JSONB syntax that produces JSONB instead of JSON
#10105 Support parsing ALTER { SEQUENCE | TABLE | TYPE | VIEW } .. OWNER TO ..
#10111 FOR JSON WITHOUT_ARRAY_WRAPPER emulation should use REGEXP_REPLACE, not SUBSTRING
#10112 Add QueryPartInternal.rendersContent(Context<?>)
#10127 Generate dialect specific rendering information in manual
#10128 Add support for Postgres 12 materialized CTEs
#10131 Emulate NVL2 using IIF in SQL Server
#10133 Add Javadoc and manual documentation for WIDTH_BUCKET
#10137 RPAD() and LPAD() should no longer need to cast
#10152 Add support for SAP HANA's BOOLEAN data type
#10153 Get HANA dialect support up to date
#10156 Deprecate createView(X, Function), Table.as(X, Function), and DSLContext.with(X, Function)
#10160 Add support for MySQL's IF() function
#10162 Add parser support for named NOT NULL constraints in DDL
#10164 Support parsing statement batches without delimiter
#10165 Add support for MySQL's INSERT() function via OVERLAY()
#10171 Parse a few known syntaxes and throw an exception about them not being supported
#10178 Add Field.is[Not]DistinctFrom(Select) and RowN.is[Not]DistinctFrom(Select)
#10179 Boolean field emulation should be NOT NULL aware
#10180 Add native support for DECODE where it is supported
#10184 Add missing TableLike.asTable(Name) and asTable(Table) overloads
#10188 Add Tools.visitSubquery(Context<?>, Select)
#10193 Support precision on LOCALTIME and LOCALDATETIME data types
#10196 GeneratorWriter should auto-indent generated code
#10204 Add a way to filter out objects from org.jooq.Meta instances
#10210 Add support for CREATE, ALTER, and DROP DATABASE statements
#10215 Stop emulating GROUP BY () in PostgreSQL 9.5+
#10216 Add code generation support for HANA ARRAY type parameters
#10220 Support parsing CHECK constraints without parentheses
#10230 Let DataType extend Named
#10235 jOOQ-kotlin-example should use new KotlinGenerator
#10246 Add missing <includeXYZ/> flag documentation to manual
#10250 Add Db2 11.1 support for more EXTRACT DateParts
#10258 Improve PostgreSQL dateAdd() implementation
#10264 Support s in the code generation config's indentation configuration
#10278 Add Named.getCommentPart()
#10280 Add Meta.snapshot() to create an in-memory copy of a Meta implementation
#10284 Add UDT.getPackage() in the OSS edition API
#10288 Add <pojosAsKotlinDataClasses/> to the code generator to generate data classes
#10291 Add support for CITEXT and VARCHAR_IGNORECASE types in parser
#10292 Add org.jooq.Qualified
#10294 Remove unnecessary covariant overrides from RenderContext and BindContext
#10299 Improve ParserImpl code reuse for single arg functions
#10300 Add DataType.getArrayComponentType() and getArrayComponentDataType()
#10309 Add code generation support for arrays of domain types
#10317 Deprecate Context.formatIndentLockStart() and formatIndentLockEnd()
#10321 Add support for JSON / JSONB types in H2
#10322 Add parser support for JSON, JSONB, and XML types
#10353 Add a new internal InlineDerivedTable implementation
#10354 Retrofit Table.where() implementation to use new InlineDerivedTable
#10360 Support parsing NOT DEFERRABLE INITIALLY IMMEDIATE on foreign key constraints
#10361 Add JSONFormat.quoteNested() and XMLFormat.quoteNested() flags
#10362 Refactor DefaultBinding to reference DataType<T>, not Class<T>
#10368 Add DataType.isNString()
#10372 Refactor internal org.jooq.impl.Cast.Native for better reuse
#10377 Inline internal AbstractContext.visit0() to reduce stack trace size
#10382 Add support for CockroachDB 20.1 features
#10383 Add support for CockroachDB WITH RECURSIVE
#10384 Add support for CockroachDB TEMPORARY tables
#10388 Add parser support for Oracle's INTERVAL YEAR TO MONTH and INTERVAL DAY TO SECOND types
#10389 Support INFORMATION_SCHEMA.COLUMNS.INTERVAL_TYPE in H2
#10391 Implement TableOptions equals() and hashCode()
#10397 Default implementation of AbstractTable.getIdentity() should check Table.fields() for any Field with DataType.identity()
#10400 Use DataType.identity() information in the absence of Table.getIdentity() in INSERT .. RETURNING emulation
#10402 Add when(Field<Boolean>) overloads to CASE expression API
#10404 Add SQLDialect.ASE_12_5, ASE_15_5, ASE_15_7, ASE_16_0 dialects
#10406 Get ASE dialect support up to date
#10420 Add Context.methodIf(Arg, boolean) for an "internal if" implementation
#10422 Let User and Role extend Named to give access to quoted / unquoted and qualified / unqualified names
#10428 Improve manual section "importing"
#10429 Make LoaderRowListener a FunctionalInterface
#10432 Add Settings.cachePreparedStatementsInLoader to keeping open PreparedStatements in Loader API
#10438 Support lazy DataType lookups in DSL.val() and DSL.inline()
#10447 Refactor some internal duplicate logic
#10451 Use H2, HSQLDB native interval arithmetic instead of DATEADD emulation
#10453 Support parsing additional standard interval literals
#10456 Add static YearToMonth and DayToSecond.<intervalType>(String) constructor methods
#10460 Use MERGE to emulate INSERT .. ON DUPLICATE KEY IGNORE in H2
#10472 Add LazySchema and LazyCatalog to allow for lazy referencing a schema or catalog in generated code
#10478 Add Matchers for catalogs
#10481 Add <replacesFields/> to embeddable configuration
#10483 Add Database.getUniqueKeys(), getForeignKeys() to look up constraints without a specific schema
#10489 Add parser support for qualified data types in DDL and casts
#10491 Add conditional-expressions subsection about Field<Boolean>
#10493 Add TemplatingException for errors that occur with plain SQL templating
#10495 Add a "show imports" button to all manual code sections
#10497 Add parser support for the PostgreSQL CREATE INDEX .. ON .. USING syntax
#10499 Support overlapping embeddables
#10511 Add <embeddableDomains/> to allow for wrapping all DOMAIN types in embeddables
#10518 /learn should clearly distinguish between unreleased and released versions in the docs
#10524 Add DataType.isEmbeddable()
#10532 Add new <lambdaConverter/> configuration in <forcedType/> to further simplify programmatic converters
#10535 Generated code should import org.jooq.impl.SQLDataType if possible
#10540 Implement new internal syntax to create derived column lists only if necessary
#10542 Add Comparator.inverse()
#10543 Manual should discourage using jOOQ without the code generator
#10550 Remove the Derby SelectQueryImpl.UNION_PARENTHESIS_IN_DERIVED_TABLES emulation
#10554 Avoid workaround for too large initialisers when unnecessary
#10568 ParserCLI should offer configuration of RenderQuotedNames
#10569 ParserCLI should display individual flags when not providing a new value in interactive mode
#10575 Add some empty protected methods to generate custom class footers in reference classes
#10578 Add PackageDefinition.getUDTs()
#10583 Loader API should pad input rows if more target fields are provided than source fields
#10588 Add new <syntheticObjects/> configuration, and deprecate / replace existing functionality
#10592 Add DDLExportConfiguration.includeConstraintsOnViews to prevent Meta::ddl from exporting synthetic constraints on views
#10600 Gradle example in the manual should not use MarkupBuilder to avoid issues with name
#10613 Add Key.nullable() to indicate that a key is (partially) nullable
#10616 Add Settings.implicitJoinType to govern whether an INNER or LEFT JOIN is generated
#10625 Static import all SQLDataType types in the manual
#10631 Display context sensitive imports in manual
#10632 Log all column and parameter types in DEBUG level in JavaGenerator
#10633 Add DataTypeDefinition.getMatchNames()
#10636 Link to SEEK clause from OFFSET clause in the manual
#10638 Add parser support for arbitrary CONNECT BY .. START WITH .. GROUP BY .. HAVING ordering
#10640 Remove unneeded private DSL constructors
#10641 Support and emulate Oracle's TO_CHAR() function
#10646 Document that import-on-demand cannot be used with org.jooq.Record
#10648 Log info when code generation run doesn't produce any difference
#10651 Manual section about like should document example of concatenating "%" to a bind value
#10653 Make the JavaGenerator::INITIALISER_SIZE configurable through <maxMembersPerInitialiser/>
#10654 Make the generation of the serialVersionUID configurable
#10658 Add Sequence.nextvals(int):Select<Record1<T>> and DSLContext.nextvals(Sequence<T>, int):List<T> to fetch a number of sequence values in one go
#10659 Add Informix emulation for GENERATE_SERIES
#10660 Add WITH RECURSIVE emulations for GENERATE_SERIES, where available
#10665 Change org.jooq.impl.Expression implementation to be binary only
#10682 Add Collection overload for CatalogMetaProvider, SchemaMetaProvider, TableMetaProvider constructors
#10688 Add Converter.forArrays() to turn a Converter<T, U> into a Converter<T[], U[]>
#10689 Deprecate zero-args and one-arg Converters.of() methods
#10692 Address known issues of BatchedConnection
#10693 Add Settings.batchSize to transparently specify a maximum batch size for BatchedConnection
#10694 Add DataType.asConvertedDataType(Class, Function<-T, +U>, Function<-U, +T>)
#10705 MockResultSet::toString should visually display current row
#10707 Add Routine.getInValue(Parameter) to allow for retrieving IN parameter values
#10711 Emulate using WITH in UNION subqueries by wrapping the subquery in a derived table in dialects where this isn't supported
#10713 Upgrade SQLite JDBC dependency from 3.30 to 3.32
#10728 Add DSL.jsonEntry(Field) and DSL.jsonObject(Field...) overloads that derive key value(s) from field name(s)
#10731 Bump junit from 4.13 to 4.13.1 in /jOOQ-examples/jOOQ-spark-example
#10732 Bump junit from 4.13 to 4.13.1 in /jOOQ-examples/jOOQ-academy
#10733 Bump junit from 4.13 to 4.13.1 in /jOOQ-examples/jOOQ-javafx-example
#10735 Bump junit from 4.13 to 4.13.1
#10750 Deprecate some internal field(String) and field(Name) implementations
#10753 Add support for ALTER TABLE .. SET NOT NULL in Oracle
Breaking changes
#3285 Add support for HSQLDB table-valued functions
#4695 Create separate Row[N] and Record[N] implementations for each N
#4703 The underscore "_" is a reserved token in Java 9. The jOOQ code generator should avoid generating it
#6612 Modularise jOOQ
#7328 Replace cursor-based FOR UPDATE emulation in SQL Server by table hints
#7342 Field.as(Field) and Table.as(Table) should inherit alias-defining Named's quoted flag
#8576 Regenerate jOOQ-meta code with <instanceFields>true</instanceFields>
#8829 Loader should decode binary data as base64, not with new String(byte[])
#8945 Add org.jooq.XML
#9754 Unstable routine name suffix generation with overloaded names
#9840 Remove DSL.groupingId() from jOOQ Open Source Edition, as no OSS dialect supports it
#9933 Optimistic locking does not work when recordTimestamp column has precision less than TIMESTAMP(3)
#10081 Make accidentally public classes package private again
#10129 SQLite's SIGN() emulation does not produce the correct value on NULL
#10146 Let SQLDataType.TIMESTAMP map to DATETIME2 instead of DATETIME in SQL Server
#10187 Remove CONNECT BY support from OSS Edition
#10276 DSLContext.ddl() should not produce foreign keys that point outside of the argument schema
#10283 Stop generating singleton Identity declarations and move logic into TableImpl
#10331 Split jOOQ-meta-extensions into jOOQ-meta-extensions-hibernate and jOOQ-meta-extensions-liquibase
#10338 XMLGenerator should produce 1-based <ordinal_position/> in <key_column_usage/>
#10343 Make JSON::data, JSONB::data, and XML::data NotNull
#10355 Change JavaGenerator.printClassAnnotations() to (JavaWriter, Definition, Mode)
#10418 GrantOnStep.on(String) and RevokeOnStep.on(String) should wrap String argument in Name
#10435 DSLContext.connection() and similar methods should not wrap RuntimeException in DataAccessException
#10512 Add a CloseableDSLContext and stop subtyping AutoCloseable from DSLContext directly
#10534 <enumConverter/> and <lambdaConverter/> don't work in ScalaGenerator and KotlinGenerator
#10566 Wrong DDL generated in Oracle when translating integer types
#10576 Compilation error when 2 Oracle packages both contain the same record type name
#10686 ConnectionRunnable and ConnectionCallable should accept throwing Throwable
Bug Fixes:
#3379 Table-valued function aliasing is confusing as the order of .call() and .as() is relevant
#3479 Awkward formatting of "short" functions
#4691 Add an unused forced type hint about Pattern.COMMENTS being turned on to help debug regexes with whitespace
#5200 Loader API onDuplicateKeyIgnore() doesn't work when primary key is an identity
#5422 ScalaGenerator should follow Scala Style Guide in generated code
#5488 Excess newline in formatted SELECT without FROM clause
#6004 DSL.values(Row[N]...) and DSL.table(Record) should emulate simpler SQL
#6186 Log warning if standalone <outputSchema/> element is not paired with <inputSchema/>
#6266 JoinTable.join(...).onKey() does not work
#6278 Wrong DDL generated when using SQLDataType.TINYINT on SQL Server
#6356 H2 row expression IN predicate with subquery doesn't work when subquery columns are aliased
#6385 Derby emulation of all(T...) is incorrect
#6793 Avoid allocating (and iterating) the MutablePOJOMapper's nestedFields HashMap
#6819 PostgreSQL UDT not working when used as stored procedure return type
#6935 insert queries having auto-generated ids are not executed
#7070 Add code generation support for PostgreSQL types referencing domains
#7334 DataAccessException.sqlStateClass() always returns OTHER for SQLite
#7411 `returning` statement does not work in MySQL even with primary key and auto increment
#7489 Datetime arithmetic generates bind values when input uses inline values
#7626 join(...).onKey(TableField) doesn't work with aliased tables
#7667 Generated SQL is missing aliasing for Stored Procedure
#7673 Cannot call SQL Server stored procedure on HSQLDB
#7679 Cannot use Meta.getSchema() for DROP SCHEMA statement
#7682 KeepNamesGeneratorStrategy doesn't work with ScalaGenerator
#7867 DSLContext.fetchCount(Select) should rename the select statement's column names to prevent ambiguities
#7917 Use H2 1.4.198 domain qualification for enums stored as domains
#8029 Cast expressions on TIMESTAMP data types should use explicit precision
#8045 EnumConverter doesn't work when fromType is Kotlin Int
#8089 Compilation error in generated Scala code for single letter schema names
#8139 scala.UninitializedFieldError in runtime using generated data objects
#8220 Row[N] predicates should wrap T argument values in Tools.field() to allow for raw type scalar subqueries
#8278 Code generation for SQLite doesn't pick up view column types correctly
#8589 Unstable code generation in PostgreSQL regexp_split_to_table function
#8869 jOOQ-scala modules no longer compile under JDK 13
#8965 Wrong DDL generated when using precision on TIMESTAMPTZ type
#9103 Remove EPUB manual from website
#9164 Consistently show SQL code to the left and Java code to the right in manual
#9188 Cannot use DayToSecond intervals in Oracle, for intervals bigger than 99 days
#9246 ALTER TABLE .. ADD UNIQUE INDEX syntax cannot be parsed
#9337 DDLDatabase does not support JSON or JSONB columns
#9396 Too many tables produced from DSLContext.meta(Tables).getSchemas()
#9540 SQL Server NVARCHAR literal is not rendered correctly
#9554 not(unique(c)) / notUnique(c) and not(exists(c)) / notExists(c) should generate the same SQL
#9590 JDBC DatabaseMetaData backed Meta implementation should read DECIMAL_DIGITS for timestamp precision, not COLUMN_SIZE
#9647 Dead links to javax.validation
#9832 jOOQ Open Source Edition code generation fails on MySQL 5.7 and MariaDB 10.3
#9834 jOOQ-meta Database implementations should dynamically detect server version and use appropriate dialect version
#9835 NPE when using AbstractDatabase instance without explicit configuredCustomTypes
#9842 Update error messages to refer to org.jooq.trial-java-8 Maven groupId
#9849 Compilation error in generated code for check constraints containing bad escape sequences
#9856 Parser cannot handle double quotes in string literals
#9865 Fix a few REDSHIFT support annotations and DDL statements
#9870 OracleDatabase produces wrong query when tableValuedFunctions is active
#9873 LiquibaseDatabase should use actual changeLog database table names
#9875 [#9873] LiquibaseDatabase should use actual changeLog table names
#9896 DB2: Wrong rendering of DSL#stddevSamp() and DSL#varSamp()
#9897 CockroachDB does not yet implement STDDEV_SAMP() and VAR_SAMP()
#9903 Changing getJavaClassName() for Mode.ENUM in DefaultGeneratorStrategy generates invalid code
#9907 NullPointerException in ByteArrayClassLoader, when it is asked to load an external class
#9914 PostgreSQL UNION requires parentheses if subquery has WITH clause
#9916 NullPointerException in XMLDatabase when new <enforced> element is missing
#9922 INSERT .. RETURNING with aliased target table generates wrong SQL in Oracle
#9934 Fix Sakila install scripts for Oracle Database
#9935 Oracle Database 11g: Column SEARCH_CONDITION_VC does not exist in table SYS.ALL_CONSTRAINTS
#9940 AS keyword is mandatory when aliasing DML target tables in SQLite
#9946 INSERT .. RETURNING emulation produces wrong follow up SELECT query when target table is aliased
#9954 Incorrect SQL generated in DB2's INSERT INTO t .. RETURNING t.* emulation
#9961 Wrong SQL generated when using implicit joins in union subquery
#9968 Error when reading or writing timestamps of year 10000+ in HSQLDB
#9975 Fix generated imports in RowN types
#9980 Wrong Javadoc link in DSL.value() methods
#9992 Firebird batch statements can produce java.sql.DataTruncation
#9996 INSERT ... RETURNING documentation in chapter 4.3.4.6 is lacking further explanation about returningResult
#9998 DSL.and(noCondition()) and DSL.or(noCondition()) generates a "1 = 1" or "1 = 0" predicate
#9999 Work around CockroachDB's wrong implementation of <row> IS NULL predicate
#10007 "constant string too long" in generated code when view source code exceeds 64KB
#10029 Manual documentation about RenderQuotedNames is not up to date
#10033 Stop casting bind values in INSERT .. VALUES()
#10034 Stop casting bind values in UPDATE .. SET
#10056 Again ORA-38104 on newer versions of Oracle
#10066 The FOR LOOP is supported only by MariaDB 10.3
#10093 Sqlserver datetime2 precision not respected in batch insert
#10098 Support parsing SQL Server multi-column ADD syntax
#10121 Compiler regression on CI
#10130 Remove reference to ADBA from docs
#10134 Bad formatting of nullif()
#10135 Improve SPACE(n) emulation where possible
#10136 DSL.repeat().getName() is "rpad"
#10139 Unknown columns in code generator queries for Firebird 2.5
#10143 java.nio.file.InvalidPathException: Illegal char <*> when using FilePattern on module path
#10144 Runtime compilation error when compiling enum types on module path
#10145 NoClassDefFoundError when trying to load JAXB from a modularised jOOQ
#10158 The default ParseNameCase for MariaDB should be AS_IS
#10169 Improve parser error message for 2 expected tokens
#10172 Wrong Javadoc: There are also DSLContext.fetchSingle() methods that return null
#10183 Bad record type returned for selectFrom(T) when T contains LEFT SEMI JOIN or LEFT ANTI JOIN
#10189 Bad formatting when selecting NULL
#10191 Fix several ScalaGenerator issues
#10192 Optimistic locking does not work when recordTimestamp column has precision less than LOCALDATETIME(3)
#10194 DefaultRecordMapper incorrectly maps immutable Kotlin classes with defaulted properties
#10195 GenerationTool should execute SHUTDOWN on HSQLDB connections
#10197 Implicit join constructor shouldn't be generated on table valued functions
#10203 Bad Javadoc generated for Tables.java in the default schema
#10205 NullPointerException when calling Meta.apply() on an H2 database with views
#10207 DataDefinitionException: Table can only have one identity when using Meta.apply() on PostgreSQL
#10211 Syntax errors in manual's SQL snippets
#10223 AUTO_INCREMENT columns fail to parse if they are preceded by a column with DEFAULT
#10226 DSLContext.fetchValue(field(name("t", "i"))) should select "i" from "t"
#10227 Global UDT, Index, Identity, references are generated as static, not static final
#10248 Wrong emulation of EXTRACT() with DECADE, CENTURY, MILLENIUM date parts
#10252 Add empty comment after stmt in trigger in Db2 Sakila scripts
#10254 Derby date time arithmetic uses unsupported sql_tsi_milli_second
#10256 HSQLDB cannot handle negative DAY intervals when using expression syntax
#10262 Newline configuration doesn't work
#10267 ImmutablePOJOMapperWithParameterNames throws InaccessibleObjectException on module path
#10268 Unrelated Liquibase error when using jooq-meta-extensions with Spring Boot
#10269 Settings.renderQuotedNames does not work with Routine
#10271 Cannot create or drop catalog-qualified schema in SQL Server
#10272 NPE in Interpreter when foreign key references table from other schema that does not exist
#10279 Missing implementations in DetachedMeta
#10281 AbstractKey.equals doesn't work for MetaPrimaryKey
#10282 Creating a Record, setting no fields explicitly, doing .insert(), PK is not set into Record object
#10289 Tutorial documentation - Incorrectly suggests installing XAMPP to get MySQL
#10295 Configuration.transactionProvider() is null after deserialisation
#10296 Reflect branch renaming from master to main in CONTRIBUTING.md
#10301 Columns are aliased by default to their own name, when using SQL Server parse dialect
#10305 Excluded schema is still included in code generation of foreign keys in PostgreSQL
#10311 Javadoc of SQLDataType.INTERVAL is incorrect
#10312 Converted datatype not using type from dialect after calling nullable
#10313 SQLDialect.supportedBy() sets should be used with contains(dialect()), not contains(family())
#10315 Bad formatting of single WHEN simple CASE expression
#10318 Long source code workaround allocates substrings twice
#10326 Derby binary literals don't work with BLOB types
#10334 MySQLRoutineDefinition uses HSQLDB's INFORMATION_SCHEMA.PARAMETERS table, not MySQL's
#10335 NullPointerException when Database.setOnError(null) is called
#10336 jooq-meta.xsd shouldn't require table_type
#10339 orderProvider is not applied to AbstractDatabase.getSchemata0()
#10345 NON_BIND_VARIABLE_SUFFIXES should only be used in PostgreSQL dialect
#10350 Document Kotlin meta data usage by the DefaultRecordMapper in Javadoc
#10364 Mistake in the "FOR clause" documentation
#10365 DSL.currentTimestamp() should generate GETDATE() instead of CURRENT_BIGDATETIME() in Sybase ASE 12.5
#10370 General exception error has occurred in the optimizer in Informix code generation, when generating only one schema and <includeSystemIndexes/> is turned on
#10373 Db2 and Derby CHAR casts erroneously casts to VARCHAR
#10374 YearToSecond interval not correctly supported in Oracle
#10381 CockroachDB FOR UPDATE must now specify unqualified names
#10387 XMLGenerator should quote source code from views, check constraints, and default expressions in generated output
#10390 <sources/> and <sourcesOnViews/> are not implemented in XMLGenerator
#10394 <comments/> and related flags implemented incorrectly in JavaGenerator
#10398 <syntheticIdentities/> doesn't set DataType.identity(true) in generated code
#10399 DataType.defaultValue() and DataType.identity() shouldn't be mutually exclusive
#10408 Error in Sybase ASE INSERT .. DEFAULT VALUES emulation when used with identity column
#10410 Excess derived table generated when putting unions in derived tables in Sybase ASE
#10413 maven-deploy.sh and maven-install.sh should use #!/bin/bash
#10415 Wrong Support annotations on INTERSECT and EXCEPT for MySQL
#10417 Sybase ASE cannot cast from numbers to TEXT directly
#10421 Sybase ASE TEXT columns get generated as LONGVARCHAR rather than CLOB
#10425 ImmutablePOJOMapperWithParameterNames no longer injects default values for unmapped primitive arguments
#10426 Use standard SQL for identity columns in H2 DDL
#10442 Wrong Javadoc on Settings.renderKeywordStyle
#10444 PostgreSQL code generation is incorrect when two tables share check constraint name
#10445 Manual redirects don't produce anchors in manual-single-page
#10448 Firebird arithmetic exception, numeric overflow, or string truncation; numeric value is out of range, when using Field.add(DayToSecond) with large millisecond numbers
#10459 Empty GROUP BY emulation stops working in HSQLDB 2.5.1
#10461 INSERT .. ON DUPLICATE KEY IGNORE emulation using MERGE should support multi value inserts
#10463 Configuration log level is ignored by GenerationTool for first log statements
#10466 Code generator fails with ArrayIndexOutOfBoundsException for Index..Include statements
#10467 PostgresUtils.toPGArray does not handle escaped quotes
#10474 Manual refers to wrong <nonnnullannotation/> code generation configuration element
#10479 Manual section about custom code section doesn't document the possibility of overriding catalog related methods
#10480 Avoid generating empty header comments in Keys.java
#10494 Avoid querying ALL_JSON_COLUMNS on Oracle 12.1.0.1.0
#10498 Compilation error in generated code when there is a table called OVERRIDE
#10508 DSLContext.meta(Table) may contain sequences
#10538 Improve emulation of (a, b) >= (x, y)
#10548 Unnecessary stack elements when SelectQueryImpl doesn't have both semi join and where clause predicates
#10558 Mention mapping into Record types in DefaultRecordMapper Javadoc
#10561 Various compilation errors when schema, table, key names conflict
#10565 Known issues with new FOR XML, FOR JSON features
#10567 Translator doesn't correctly quote identifiers in FOR XML and FOR JSON emulations
#10579 JavaWriter::beforeClose shouldn't search for package using a regex
#10586 Some missing nullable annotations in generated code
#10587 NullPointerException when misconfiguring code generator, lacking a <database/>
#10594 Meta::ddl does not correctly export view contents from generated code
#10595 Error when fully qualifying a view with catalog name in CREATE/DROP VIEW in SQL Server
#10602 Missing NOT NULL constraint in generated DDL for some dialects
#10603 Ambiguous match found when using complex implicit join graphs
#10605 offset(0) is ignored
#10608 Apply URL rewrite in /latest and /dev manuals also to internal links
#10614 Avoid ClassCastException when comparing two column values without natural order in Record::compareTo
#10624 Failing constraint exclusion with partitioned tables in Postgres 12.4 - 10.2
#10628 BackslashEscaping.DEFAULT should implement ON behaviour in Redshift, not OFF
#10635 AbstractQueryPart::equals might not work when one QueryPart has a different Configuration than the other
#10644 Add Settings.transformUnneededArithmeticExpressions to optimise arithmetic prior to SQL generation
#10655 Support empty INSERT .. VALUES() clause via DEFAULT VALUES
#10663 Improve formatting of CONNECT BY emulation of GENERATE_SERIES
#10664 DataType.getArrayDataType() should wrap custom Converter<T, U> implementations into Converter<T[], U[]> automatically
#10669 Parser should parse DATE - DATE to dateDiff() and TIMESTAMP - TIMESTAMP to timestampDiff()
#10670 Error when parsing Oracle (+) operator with ParseUnknownFunctions.IGNORE
#10674 jOOQ Translator - Maria DB Version are missing
#10675 Parser doesn't recognise Oracle ( + ) operator, if it contains whitespace
#10678 Unsafe re-use of object in Expression math causes incorrect SQL generation
#10679 Parser incorrectly parses IN predicate of degree > 1 with extra parentheses around SELECT subquery
#10680 Translator should ignore unknown functions
#10704 ClassCastException when using MockDataProvider with Oracle ArrayRecord types
#10718 Error when mocking Oracle routines that have VARRAY or TABLE parameters
#10720 MockConnection must not produce first ResultSet when calling stored procedures with OUT parameters
#10736 NullPointerExceptions when calling DSLContext.informationSchema() with DSL.schema(Name) and similar meta data
#10738 NullPointerException in Meta.migrateTo() when using DatabaseMetaData backed Meta containing views
#10741 NullPointerException in SQLite Meta.migrateTo() when using DatabaseMetaData backed Meta containing FK referencing wrong identifier case
#10743 Fix emulations of nested FOR JSON and FOR XML queries
#10751 Code generator can't handle SQL Server database names with dash

New in jOOQ 3.13.5 (Oct 2, 2020)

New in jOOQ 3.13.4 (Jul 29, 2020)

New in jOOQ 3.13.3 (Jul 17, 2020)

Features and Improvements:
Support parsing CHECK constraints without parentheses
Support s in the code generation config's indentation configuration
Implement TableOptions equals() and hashCode()
Bug Fixes:
Wrong Javadoc: There are also DSLContext.fetchSingle() methods that return null
Bad record type returned for selectFrom(T) when T contains LEFT SEMI JOIN or LEFT ANTI JOIN
NullPointerException when calling Meta.apply() on an H2 database with views
DataDefinitionException: Table can only have one identity when using Meta.apply() on PostgreSQL
AUTO_INCREMENT columns fail to parse if they are preceded by a column with DEFAULT
Derby date time arithmetic uses unsupported sql_tsi_milli_second
HSQLDB cannot handle negative DAY intervals when using expression syntax
EnumConverter doesn't work when fromType is Kotlin Int
Settings.renderQuotedNames does not work with Routine
NPE in Interpreter when foreign key references table from other schema that does not exist
Columns are aliased by default to their own name, when using SQL Server parse dialect
Javadoc of SQLDataType.INTERVAL is incorrect
CreateSequenceFlagsStep javadoc maxvalue refers to minvalue
Long source code workaround allocates substrings twice
ALTER TABLE .. ADD UNIQUE INDEX syntax cannot be parsed
Join(...).onKey(TableField) doesn't work with aliased tables
Unknown columns in code generator queries for Firebird 2.5
Jooq-meta.xsd shouldn't require table_type
ImmutablePOJOMapperWithParameterNames throws InaccessibleObjectException on module path
JoinTable.join(...).onKey() does not work
NON_BIND_VARIABLE_SUFFIXES should only be used in PostgreSQL dialect
Document Kotlin meta data usage by the DefaultRecordMapper in Javadoc
Excluded schema is still included in code generation of foreign keys in PostgreSQL
Loader API onDuplicateKeyIgnore() doesn't work when primary key is an identity
General exception error has occurred in the optimizer in Informix code generation, when generating only one schema and <includeSystemIndexes/> is turned on
XMLGenerator should quote source code from views, check constraints, and default expressions in generated output
<sources/> and <sourcesOnViews/> are not implemented in XMLGenerator
Maven-deploy.sh and maven-install.sh should use #!/bin/bash

New in jOOQ 3.13.2 (May 5, 2020)

New in jOOQ 3.13.1 (Feb 21, 2020)

New in jOOQ 3.13.0 (Feb 12, 2020)

Starting with this release, we will further embrace our support for parsing, translating, executing, and now also interpreting DDL statements. The driving force is better code generation support, but in the future, also better integration with database change management systems like Flyway or Liquibase.
We've added support for a very promising new dialect: CockroachDB:
We're starting to support one of SQL:2011's most interesting features: temporal tables for system and application time versioning, and we've generally improved the way we build and distribute jOOQ to our paying customers.
SQL Dialects:
We've worked together with a team of great engineers at CockroachDB to speed up our newly added, formal CockroachDB support in the jOOQ Professional and Enterprise Editions. While many users have successfully used the POSTGRES dialect with CockroachDB for simple integrations, this new dialect is now fully integration tested and supported for future jOOQ and CockroachDB versions. The integration fixed a variety of issues and minor differences that we have encountered in the code generator and the runtime library.
We've added support for a variety of features now available in Firebird 3.0+, MariaDB 10.3+, MySQL 8+, and PostgreSQL 10+.
DDL interpretation:
Our biggest investment has been made in the area of DDL interpretation. Since jOOQ 3.9, we can parse more and more SQL syntax. A logical next step is to allow for interpreting parsed (or ordinary, DSL constructed) DDL statements in order to maintain an incremental, in-memory meta model of a database. This has a variety of benefits, which we will take advantage of in this release and in the future.
The main out of the box benefits in this version include:
Being able to create a diff between two versions of a schema, programmatically through Meta.migrateTo(Meta), on the command line through DiffCLI (https://www.jooq.org/doc/latest/manual/sql-building/schema-diff-cli), or online, through our website: https://www.jooq.org/diff.
Such a diff or the meta model itself can be used for ad-hoc introspections, or formally, for automated migrations by tools built on top of jOOQ. Future versions will offer such migrations out of the box.
Unfortunately, we have not yet replaced our H2 backed DDLDatabase by our new DDL interpretation capabilities. This is a high priority for jOOQ 3.14, though
In the context of these investments, we have improved a variety of infrastructure that were needed for these features and that users can benefit as well. These improvements include:
A new LiquibaseDatabase, which uses Liquibase behind the scenes to simulate a schema migration in memory (similar to the DDLDatabase for Flyway), to reverse engineer that for the code generator. If you're using Liquibase, chances are that you no longer need to connect to an actual database to use jOOQ's code generator. More info here: https://blog.jooq.org/2019/10/16/how-to-simulate-a-liquibase-migration-using-h2/
We now support the inclusion of SQL text in generated code and other parts of the runtime meta model, including for CHECK constraints and views
A lot of improvements to the JDBC DatabaseMetaData backed org.jooq.Meta API have been implemented.
A lot of additional DDL statement and syntax support has been added throughout the API, parser, and other tooling.
The runtime meta model has been enhanced with new information, such as sequence flags, check constraints, table type information, and more.
Temporal table support:
Perhaps the SQL:2011 standard's most exciting "new" feature are temporal tables, an enhancement on top of Oracle's historic flashback query feature, and much more.
In many systems, single, or bi temporal versioning of data is essential. The two dimensions of versioning that are now supported in jOOQ are:
System versioning, useful for backups and auditing, where every mutating operation results in a backup copy of the data in a managed backup table.
Application versioning, useful for data that has a timely limited validity, such as a price for a product, which could have a temporary discount.
jOOQ 3.13 supports org.jooq.Period and related API in Select, Update, and Delete to manipulate and query temporal tables in dialects that ship with native support for these features. To different degrees, these dialects include:
DB2
MariaDB
Oracle
SQL Server
Emulations of incompletely supported syntax in the above dialects, as well as in all other dialects will be added in future jOOQ versions, making temporal validity a problem of the past.
Build improvements
We've invested a lot of time in improving our build automation using newer Jenkins features that allow us to publish builds more frequently, especially snapshot builds of upcoming minor releases for early adopters, as well as patch releases for customers needing urgent fixes:
These new releases also include trial versions for Java 6, 8, 11, without the need to register for extended trials.
In addition to the above, we've improved and continue to improve our documentation of features per edition, in the future.
Procedural API improvement:
In jOOQ 3.12, we've introduced support for procedural languages, which we are improving in every new release. jOOQ 3.13 adds support for additional procedural statements, including:
EXECUTE for dynamic SQL execution embedded in procedural blocks
RETURN to return from functions
Plain SQL statement support
In the future, we're planning to support also the generation of functions, procedures, and triggers through standard jOOQ API.
This is a commercially licensed only feature.
jOOQ-Refaster:
Some of our users have had a lot of success using our checker-framework or ErrorProne integrations, which allow for some static API usage analysis in client code (e.g. plain SQL / SQLi risk, dialect compatiblity, etc.)
Starting from jOOQ 3.13, we're also adding support for ErrorProne's sub project "refaster", which allows for automatically rewriting bad API usage to something better, such as for example:
Migrate deprecated API usage like field.trim(), to its replacement trim(field)
Migrate inefficient SQL usage like ctx.fetchCount(select) != 0 to ctx.fetchExists(select)
More details here: https://www.jooq.org/doc/3.13/manual/tools/refaster/
Features and Improvements:
#2286 Add LiquibaseDatabase to support interpreting the liquibase XML format in the code generator
#2370 Add org.jooq.TableOptions to describe the various storage and other options of a table in the meta model
#3521 Implement JDBCDatabase.loadForeignKeys()
#3676 Treat identical UNION [ ALL ] and INTERSECT set operations as associative avoiding unnecessary parentheses
#4245 Add support for PostgreSQL's DELETE .. USING syntax
#4454 Implement Table.getIdentity() for tables obtained via org.jooq.Meta
#4793 Add support for Catalog in runtime schema mapping
#5181 Add additional runtime meta information for indexes
#5317 Add support for ALTER TABLE .. ADD [ COLUMN ] .. [ { PRIMARY KEY | UNIQUE } ] [ REFERENCES | CHECK .. ]
#6314 Add Meta.getIndexes()
#6412 DSLContext.ddl() should distinguish between table types (table, temporary table, view, etc.)
#6659 Add support for PostgreSQL 10 IDENTITY columns
#7004 Add support for MariaDB sequences
#7006 Add support for MariaDB 10.3 Features
#7241 Add support for ALTER TABLE .. ADD .. [ FIRST | BEFORE | AFTER ]
#7293 Generate OFFSET .. FETCH for Firebird 3.0
#7421 Stop rendering "FROM dual" in MySQL 8+ and MariaDB 10.4+
#7511 Add support [ NOT ] ENFORCED in constraints
#7629 Add support for exporting CHECK constraints through DSLContext.ddl()
#7639 Add code generation support for CHECK constraints
#7752 Add support for Sequence flags in meta model
#7775 Add support for ALTER TYPE to modify enum types in PostgreSQL
#8104 Add support for ALTER DATABASE with DDLDatabase
#8105 Interpreter should have an option to disable foreign key checks
#8194 Add a Configuration.systemConnectionProvider() SPI
#8201 Add support for EXECUTE for use in procedural blocks
#8252 Add build integration test verifying if all pro API is annotated with the org.jooq.Pro annotation
#8323 Publish existing jOOQ-xtend project as a Maven module
#8345 Add an org.jooq.Typed<T> marker interface
#8507 Add a parent pom.xml for all examples
#8524 Add support for CREATE TEMPORARY TABLE IF NOT EXISTS
#8528 Add org.jooq.Meta implementation that is based on DDL interpretation
#8541 Use MySQL's native derived column lists support
#8545 Add support for CockroachDB
#8621 Add support for exception syntax in MockFileDatabase
#8642 Separate section for jOOQ's SQL extensions
#8755 Make Loader(CSV|JSON|Rows)Step.fields() calls optional
#8787 Support DSL#alterIndexIfExists() for SQL Server
#8800 Add Settings.transformAnsiJoinToTableLists to support pre-ANSI join syntax
#8807 Add setting to specify whether INNER and OUTER keywords should be generated in joins
#8870 Support Scala 2.13
#8901 Cannot use INSERT .. RETURNING in Oracle to fetch back a UDT
#8923 Consider using jaxb2-annotate-plugin in XJC compiler
#8953 Use Internal API for generated code of Queues and Sequences
#8995 Add Javadoc to XJC generated with-methods
#9019 Render DROP TEMPORARY TABLE in MySQL
#9043 Add org.jooq.Source API
#9053 Offer a SNAPSHOT repository
#9086 Add tags to the manual documenting what editions support a given feature
#9096 Document the procedural language API
#9101 Improve method Javadoc of JAXB generated classes
#9109 Emulate multi column COUNT (DISTINCT col1, col2) in H2 using row value expressions
#9127 Update jOOQ-mcve dependency versions
#9130 Support MySQL FOREIGN KEY [ index_name ] syntax
#9132 Support parsing MySQL's USING [ BTREE | HASH ] index type syntax everywhere where it is supported
#9138 Parser errors from DDLDatabase should hint at jOOQ's parser ignore comment syntax
#9141 DDLDatabase should output query results to log output
#9155 Various third party dependency updates
#9161 Add support for parsing MySQL FULLTEXT KEY inline declaration in CREATE TABLE
#9166 Deprecate loading settings from /jooq-settings.xml or from -Dorg.jooq.settings
#9168 Add a DSL.execute(Query) convenience method
#9171 Add Javadoc to DSL::execute
#9183 Add support for DISTINCT ON in H2
#9186 Correct various @Support annotations for MariaDB
#9192 Add DSL.statement(String), a plain SQL procedural Statement API
#9194 Add support for RETURN in the procedural API
#9200 Avoid unnecessary warning when there are multiple nextval default values (not caused by serial types) in PostgreSQL
#9209 Add support for exceptions in MockResult
#9213 Introduce versioned MARIADB dialects
#9217 Support parsing MySQL's USING HASH index_type in CREATE INDEX
#9221 Postgres supports DateParts MILLISECOND and MICROSECOND
#9222 Align @Support annotation of DatePart enum constants with DSL methods
#9233 Use new Source API throughout the jOOQ API
#9238 Add a new Settings.parseNameCase
#9240 Constraint with empty name rendered as CONSTRAINT ""
#9244 Add support for DROP TEMPORARY TABLE IF EXISTS
#9252 H2: Omit OFFSET clause if offset is 0
#9255 Upgrade Maven version to 3.6.2 in Travis
#9263 Better support for fields with boolean converter
#9265 Add JSON.data() and JSONB.data()
#9272 Slightly improved code generation pattern
#9273 Update Gradle example to use newer version of H2
#9276 Java generator always uses LF line terminator for import statements
#9285 Add a link from the dialect family to the latest dialect version in each SQLDialect
#9289 Add Javadoc to Configuration.dsl() explaining that it is just convenience
#9294 Add support for MariaDB FOR UPDATE .. [ WAIT n | NOWAIT ]
#9295 Use Settings.getQueryTimeout() consistently
#9305 Support parsing Vertica's TEMP table syntax
#9307 Add Mock.of(SQLException)
#9312 Add SQLDialect.supportedBy(SQLDialect...) to produce a set of supported dialects from an input
#9313 Add SQLDialect.predecessors() to produce a set of all preceding versions of a given dialect
#9316 Also support STRAIGHT_JOIN for MariaDB and MemSQL
#9317 Synchronize @Support annotations on JoinType and Table methods
#9318 H2: Support WITH clause for MERGE statement
#9320 Add a new DataDefinitionException to be thrown by DDLInterpreter
#9325 Add Name.empty() to check if a name consists only of the empty string ""
#9327 Add DDLFlag.SEQUENCE to allow for exporting CREATE SEQUENCE statements from DSLContext.ddl()
#9329 Add reactive streams in published ZIP file as a dependency, for convenience
#9344 Fix Support annotations for CREATE SEQUENCE flags
#9352 Only render CREATE SEQUENCE ... NO CYCLE clause where supported
#9353 Support parsing ALTER TABLE .. ALTER .. SET DEFAULT
#9354 Add support for ALTER TABLE .. ALTER .. DROP DEFAULT
#9358 Add support for parsing the H2 SCHEMA() function
#9359 Refactor common meta extensions code to new InterpretingDatabase
#9361 Upgrade H2 dependency to 1.4.200
#9362 Add Settings.interpreterDialect
#9364 Add DDLFlag.INDEX to allow for exporting CREATE INDEX statements
#9371 H2: DSL#currentTime() should render as CURRENT_TIME
#9372 Improve SEMI / ANTI JOIN documentation
#9374 Support various H2 ALTER .. IF EXISTS statements
#9375 Add code generation and runtime flags to include/exclude automatic indexes on PK/UK/FK
#9380 Add support for ALTER TABLE .. DROP CONSTRAINT .. [ CASCADE | RESTRICT ]
#9382 Add support for Oracle's ALTER TABLE .. DROP UNIQUE (<columns>) syntax
#9384 DataType.getDataType(Configuration) turns this on dialect specific data types
#9394 Move DSLContext.ddl() API to Meta
#9395 Let Meta extend Scope
#9399 Move DSLContext.informationSchema() to Meta
#9403 Deprecate CUBRID dialect
#9407 Deprecate remaining Field.xyz() convenience API
#9410 Various Firebird DDL improvements
#9413 Add support for RDB$DESCRIPTION in Firebird code generation
#9421 Add Firebird code generation support for indexes
#9426 DSLContext.meta(Source...) should be able to read InformationSchema from sources
#9427 Let Name extend Comparable
#9428 Meta.toString() should call Meta.ddl()
#9429 Add DSLContext.meta(Query...) as a shortcut for meta(Source...)
#9431 Add a /diff tool to the website
#9432 Add Queries.concat(Queries)
#9433 Implement Meta.equals() and hashCode() based on Meta.ddl()
#9434 Add DDLExportConfiguration.respectOrder flags
#9435 Let Key extend Named
#9436 Add Meta.apply(Queries)
#9437 Add support for ALTER SEQUENCE [ sequence flags ]
#9438 ALTER SEQUENCE .. RESTART emulation should use Sequence.startWith() flag, if available
#9441 Add DSLContext.meta(String...) for convenience
#9442 Add code generation support for sequence flags
#9445 Various Sybase ASE DDL improvements
#9460 Support additional Settings.interpreterDialects and add an InterpreterConnectionProvider SPI
#9476 Add parser support for MySQL [ INNER ] JOIN without ON clause
#9478 Support parsing ALTER TABLE .. ALTER COLUMN .. SET NULL syntax
#9482 Add new internal org.jooq.impl.Names class for commonly used DSL.name() references
#9490 Create an FAQ on the website, and link to it from the issue template
#9491 Add 301 redirects for non-modular Javadoc
#9502 Add Settings.renderOptionalAsKeywordForTableAliases and ...ForFieldAliases
#9504 Add DDLExportConfiguration.createViewIfNotExists and DDLExportConfiguration.createOrReplaceView
#9505 Add org.jooq.Version to describe a database version
#9508 Add Settings.interpreterDelayForeignKeyDeclarations
#9511 Avoid quoted identifiers in jOOQ-meta queries
#9514 LiquibaseDatabase should allow for passing parameters to the Liquibase
#9520 Log info message when a forcedType never matches
#9533 Add support for DROP INDEX .. [ CASCADE | RESTRICT ]
#9534 Add support ALTER TABLE .. DROP UNIQUE <name>
#9536 Add DataType.isInteger()
#9558 Clarify in Javadoc of selectFrom() and related methods that all Table.fields() will be fetched, not DSL.asterisk()
#9562 Add Table.getChecks() to return a list of check constraints
#9565 Add CheckConstraint XSD type to jooq-meta.xsd
#9570 Generate single ADD or DROP ALTER TABLE statements when a list of length 1 is passed
#9578 Upgrade Hibernate dependency to 5.4.9.Final
#9580 Add DDLExportConfiguration.defaultSequenceFlags
#9584 Add Source.readString()
#9588 Use H2's native BITNOT()
#9589 Use H2's native LSHIFT() and RSHIFT()
#9591 Let DefaultRecordContext and DefaultExecuteContext extend AbstractScope
#9595 Regenerate HSQLDB information schema against 2.5.0
#9600 Add code generation flag <includeSystemCheckConstraints/>
#9603 Add sequence flag support on jooq-meta.xsd
#9604 Implement a default OrderProvider in the code generator
#9610 Add code generation support for Derby indexes
#9611 Add code generation support for Informix indexes
#9612 Document JSON and JSONB NULL semantics
#9613 Update Configuration Javadoc
#9614 Clarify that SQL Data Warehouse = Azure Synapse Analytics
#9616 Support parsing ALTER TABLE .. ADD, .. ADD
#9624 Add a DiffCLI command line tool
#9629 Add new <sequenceFlags/> flag to allow for turning off sequence flag generation
#9630 Add more ErrorProne and Refaster checks / refactorings
#9633 Add a new Settings.interpreterNameLookupCaseSensitivity
#9636 Add Settings.locale() as a default for renderLocale() and other locales
#9646 Document <generatedAnnotation/>
#9651 Support parsing // as a single line comment token
#9657 Publish 3.12 snapshots on website
#9660 Update dependency to Derby 10.15
#9661 Support parsing MySQL's unnamed constraint syntax
#9667 Ignore changes to sun-jaxb.episode files
#9668 Offer Java 11 and 6 trial downloads from website
#9669 Move xjb files out of artifacts
#9670 Make slf4j-api version backwards compatible to OSGi consumers
#9672 Add new ConstraintDefinition type
#9675 Postgres: Support MD5() function
#9677 Add Settings.interpreterSearchPath
#9681 Synchronize @Support annotations on MergeUsingStep#columns() methods
#9682 Add SQLDialect.SQLITE_3_30
#9692 Add InsertQuery.setSelect(Collection, Select) overload
#9696 Add a new <generateGlobalIndexReferences/> flag
#9698 How to alter a table to add a column of Enum/Set type in MySQL.
#9700 Sakila/PostgreSQL: Don't fail if language plpgsql already exists
#9703 Document the requirement of matching versions between code generator and runtime library
#9719 Support MySQL ISNULL() function in the parser
#9727 Add configuration/basedir to resolve relative paths in code generator
#9733 Add <nonnullAnnotationType/> and <nullableAnnotationType/>
#9734 Add <nonnullAnnotation/> and <nullableAnnotation/>
#9741 Add org.jooq.Period for temporal validity
#9747 JSON and JSONB should implement Serializable
#9762 Add support for DB2 SET SCHEMA command
#9772 Add SQLDialect.MYSQL_8_0_19
#9776 Add support for MySQL 8.0.19 VALUES clause
#9777 Add SQLDialect.supportedUntil()
#9778 Support NULLS [ FIRST | LAST ] in SQLite 3.30
#9779 Add native support for aggregate and window function FILTER clause in SQLite 3.30
#9780 Add Settings.parseSetCommands
#9781 Add DSLContext.set(Name, Param<?>) for arbitrary set commands
#9790 Add internal functional interfaces F0, F1, F2
#9796 Generated annotation should produce HTTPS link to jOOQ website
#9799 Make TableOptions available through code generation
#9800 Make TableOptions available through org.jooq.Meta
#9801 Make TableOptions available through InformationSchema
#9805 Generate view source code with generated views
#9806 Add Batch.executeAsync() methods
#9807 Apply Configuration.onError flag also to SQL errors from AbstractDatabase
#9808 Add JooqLogger.log(Level) overloads
#9811 Document that CustomRecord subclasses need a no-arg constructor
#9816 Add Definition.getSource()
#9819 Add support for INFORMATION_SCHEMA.VIEWS in jooq-meta.xsd
#9822 Firebird support for ALTER TABLE ... ALTER ... [ DROP | SET ] NOT NULL
#9827 Remove SQL 2 jOOQ section from the manual
Breaking changes
#4934 Delay query execution until a Stream terminal op is called
#5714 Change <javaTimeTypes/> default value to "true"
#9031 Remove unnecessary AlterSequenceRestartStep
#9235 Remove checked exceptions from LoaderSourceStep methods
#9237 Remove checked exceptions from MockFileDatabaseConfiguration::source methods
#9241 Change <varargSetters/> to default to false
#9283 DefaultBinding should return null on null JSON values, instead of JSON[B].valueOf(null)
#9365 Support H2's standard LOG() function
#9470 FilePatter.Loader should accept Source, instead of InputStream
#9479 Remove internal, deprecated DefaultConfiguration constructors
#9596 Regenerate MySQL information schema against 8.0.18
#9601 Add code generation flag <includeSystemIndexes/>
#9725 Move org.jooq.meta.tools.FilePattern API to core library
#9732 Change default value of <generatedAnnotation/> to "false"
#9737 Wrong generics on DSLContext.selectFrom(Name) and similar methods
#9758 Generated constraint names should not be table prefixed in meta data in DB2 and PostgreSQL
Bug Fixes
#2967 Impossible to inline "decimals" parameter of ROUND() function
#4856 UNION generates bad SQL for MySQL, when UNION subqueries contain duplicate column names from JOIN operations
#6497 Add LocalDateAsLocalDateTimeBinding to make <javaTimeTypes/> and <dateAsTimestamp/> work together
#7377 When using org.jooq.Meta, UniqueKey.getReferences throws NPE in Firebird
#7962 ORA-04043 on INSERT when using qualified, quoted table name and fetching generated keys
#8335 DDLDatabase loads too many files when using relative path
#8508 Fix Javadoc warnings
#8555 Parser cannot handle enum literals that are invalid java identifiers
#8580 LikeEscapeStep#escape() also supported by Teradata
#8677 Log warning when file based databases have invalid <jdbc/> configurations
#8721 Enum type with '-' character does not compile
#8824 DDLDatabase can not handle multiple constraints with the same name
#8966 Invalid SQL rendered for recursive query
#8967 Generator outputs duplicate method (not compilable)
#8968 An exception in ExecuteListener#start is not routed to ExecuteListener#exception
#8991 DSL.field(Name) fields should support schema mapping
#9099 Cannot build Javadoc in jOOQ-checker under Java 11
#9100 Fix Javadoc links starting from jOOQ 3.12, which is built with JDK 11
#9104 JooQ 3.12.0 codegen fails with an incorrect query where 3.11 worked correctly (PostgreSQL)
#9110 Wrong SQL generated by DSL.countDistinct() without arguments
#9111 Allow parsing of COUNT(DISTINCT <row-value-expression>)
#9121 Generator does not report file in which invalid SQL was found
#9122 java 8+ distribution of 3.12.0 broken
#9133 404s on /latest Javadoc
#9134 Wrong rendering of [ FROM { FIRST | LAST } ] clause for NTH_VALUE()
#9140 Translation of USE command should result in SET SCHEMA command in dialects that do not support catalogs
#9144 ParserCLI "-f" flag does not work as shortcut for "--from-dialect"
#9145 Manual page about ParserCLI misses reactive-streams in classpath
#9146 ParserCLI --from-dialect is not case insensitive
#9147 ParserCLI -h parameter throws a RuntimeException
#9150 Compilation error in generated code when Oracle OBJECT type contains index_of(varchar2) member procedure
#9157 Prevent "Illegal reflective access operation" warning in jOOQ Open Source Edition
#9158 Review and fix a few formatting issues in the manual
#9165 Quantified LIKE predicate (LIKE ANY) is not documented correctly
#9177 H2: SelectLimitPercentStep#percent() not working properly
#9187 Bad parenthesis in UNION under HSQLDB
#9193 Consecutive RenderContext.formatSeparator() calls ignored when formatIndentStart() is called in between
#9196 Only first value added to date time appears in rendered SQL
#9201 Negative intervals not rendered properly for PostgreSQL
#9205 Fix DefaultYearToMonthBinding and DefaultYearToSecondBinding for Aurora Postgres
#9214 SQLDialect.MEMSQL lacks Pro annotation
#9219 Regression in Extract(QUARTER) on Postgres in 3.12.1
#9223 MySQL: Support date parts MICROSECOND and WEEK
#9224 Regression for "= ANY(?::int[])" no longer produces array bind variable
#9225 Postgres: FILTER clause no longer rendered
#9231 Wrong Javadoc on org.jooq.Source
#9242 AbstractKey#equals() assumes name is unique
#9248 Regression: DSLContext#nextval() broken for H2
#9250 LEFT [ ANTI | SEMI ] JOIN ... USING not implemented
#9251 H2's WITH TIES support broken in OSS edition
#9266 Consistently document all commercial SQLDialects
#9274 AttributeConverterExtractor should receive custom Hibernate configuration properties
#9277 Improve error message when AttributeConverters cannot be loaded due to NoClassDefFoundError
#9291 Sequences are generated as tables in MariaDB
#9296 withRenderSchema(false) does render schema in order by clause
#9311 Incomplete @Support annotations on UpdateQuery.addValues(Row[N], Select)
#9315 Remove unnecessary generic type variable on CreateSchemaImpl
#9324 Name.append(Name) should not produce a QualifiedName when one of the parts is empty
#9331 Postgres 12 exception in code generation output: "column c.consrc does not exist"
#9338 Parse ignore comments not parsed correctly if stop comment is last token of file, prior to a newline
#9343 Wrong SQL generation for PostgreSQL function calls having arguments with custom data types.
#9355 LoggingConnection does not log static statements
#9368 Outdated comment in manual about H2 supporting window functions
#9386 RenderMapping is not applied to DSL.schema(Name)
#9389 CREATE INDEX commands created from DSLContext.ddl() based on Meta contain illegal WHERE clause
#9411 Firebird generated code contains "DEFAULT" keyword in default expressions
#9414 Unable to create index with qualified index name on Oracle dialect
#9415 Emulate RETURNING * in Firebird
#9418 Regression in Firebird's SUBSTRING() implementation
#9420 Incorrect emulation of unnamed indexes
#9424 Add line breaks to a few parser grammar diagrams
#9443 Regression in Sybase ASE source code generation: Cannot generate tables
#9457 UDT.getQualifiedName() doesn't return schema qualification for generated tables
#9461 Missing @PlainSQL annotation on some DSLContext#batch() methods
#9462 Missing @Support annotations on BatchBindStep methods
#9463 Add missing @Support annotations to methods of LoaderSourceStep
#9468 SQLDialect.ASE cannot be used with a MockConnection
#9471 JDBCDatabase does not order objects alphabetically
#9473 Creating tables using DSLContext.ddl() converts VARBINARY columns to TEXT in MySQL
#9480 CREATE SEQUENCE implementation should reuse Sequence.getDataType() in various flags
#9493 JoinStep#crossApply() throws IllegalArgumentException
#9497 NullPointerException when calling methods on DAO that is not attached to a Configuration
#9498 DDLDatabase: Flyway's repatable migrations are executed to early
#9513 Oracle: PIVOT ... FOR always rendered as quoted
#9516 Cannot use MERGE .. DELETE WHERE without UPDATE WHERE
#9528 Some ConstraintForeignKeyReferencesStep.references() methods are missing Support annotations
#9531 Open Source version references dual license
#9545 Parser cannot parse views with WITH
#9547 Query ALL_MVIEWS instead of ALL_MVIEW_COMMENTS in Oracle
#9551 Bad code generated when using SQL Server user defined types
#9567 Cosmetic exceptions caused by JPADatabase when using attribute converters
#9571 Multi column ALTER TABLE .. ADD statement shouldn't qualify column names
#9582 Generator's <globalObjectReferences/> does not prevent the generation of Indexes.java
#9597 DefaultRelations#getCheckConstraints() returns all checks on first call
#9598 Static class initialisation deadlock race between DefaultDSLContext.java:388 and DefaultDSLContext.java:505
#9620 No DiagnosticsListener.missingWasNullCall() when nullability is unknown
#9621 NullPointerException in DefaultRecordMapperProvider when setting a new instance to a Configuration
#9648 ArrayIndexOutOfBoundsException if query has a single or double quote char in vendor specific comment
#9653 Meta.ddl() loses Schema and Constraint Name.quoted() information
#9658 Parser settings repeat available flag documentation
#9659 Missing documentation for Settings.inListPadBase
#9664 Parser should reject duplicate identities
#9671 Fixes #9670 to make jooq OSGi backwards compatible for slf4j and also…
#9674 Bad SQL generated from implicit join from within subqueries
#9685 Generate.globalTableReferences should not impact what is returned by Schema#getTables()
#9690 All links in FAQ are broken
#9697 Full identifier qualification in generated code when <globalObjectReferences> is turned off
#9708 Mapping schema with RegEx generates invalid output name after upgrade to 3.12
#9718 Wrong type returned by LoaderCSVStep#fields(LoaderFieldMapper)
#9726 FilePattern matches too many files when wildcards are being used
#9751 MySQL 5.7: Invalid SQL for set operations in subqueries
#9756 Regression in IGNORE NULLS clause for DB2
#9782 Add missing @Support annotation to PivotForStep#for_(Field)
#9791 Meta.getTables() returns the same table for each catalog in SQL Server
#9792 Meta doesn't produce correct data type in SQL Server for identity columns
#9793 BLOB SUBTYPE not supported in dialect FIREBIRD when using plain SQL
#9797 XMLDatabase cannot read INT type
#9823 WITH TIES emulation not used for FIREBIRD dialect
#9824 Informix check constraint and view generated SQL code is not trimmed

New in jOOQ 3.12.3 (Oct 31, 2019)

New in jOOQ 3.12.2 (Oct 22, 2019)

Features and Improvements:
Parser errors from DDLDatabase should hint at jOOQ's parser ignore comment syntax
Add Javadoc to DSL::execute
Add support for parsing MySQL FULLTEXT KEY inline declaration in CREATE TABLE
Render DROP TEMPORARY TABLE in MySQL
Add JSON.data() and JSONB.data()
Add a link from the dialect family to the latest dialect version in each SQLDialect
Add Javadoc to Configuration.dsl() explaining that it is just convenience
Support parsing Vertica's TEMP table syntax
Improve SEMI / ANTI JOIN documentation
Java generator always uses LF line terminator for import statements
Breaking changes:
DefaultBinding should return null on null JSON values, instead of JSON[B].valueOf(null)
Bug Fixes:
Wrong rendering of [ FROM { FIRST | LAST } ] clause for NTH_VALUE()
404s on /latest Javadoc
Translation of USE command should result in SET SCHEMA command in dialects that do not support catalogs
ParserCLI --from-dialect is not case insensitive
ParserCLI -h parameter throws a RuntimeException
Compilation error in generated code when Oracle OBJECT type contains index_of(varchar2) member procedure
ParserCLI "-f" flag does not work as shortcut for "--from-dialect"
H2: SelectLimitPercentStep#percent() not working properly
Only first value added to date time appears in rendered SQL
Negative intervals not rendered properly for PostgreSQL
SQLDialect.MEMSQL lacks Pro annotation
Regression in Extract(QUARTER) on Postgres in 3.12.1
Postgres: FILTER clause no longer rendered
Regression for "= ANY(?::int[])" no longer produces array bind variable
Wrong Javadoc on org.jooq.Source
Regression: DSLContext#nextval() broken for H2
H2's WITH TIES support broken in OSS edition
LEFT [ ANTI | SEMI ] JOIN ... USING not implemented
AttributeConverterExtractor should receive custom Hibernate configuration properties
Improve error message when AttributeConverters cannot be loaded due to NoClassDefFoundError
Consistently document all commercial SQLDialects
Parser cannot handle enum literals that are invalid java identifiers
Sequences are generated as tables in MariaDB
DSL.field(Name) fields should support schema mapping
Postgres 12 exception in code generation output: "column c.consrc does not exist"
Parse ignore comments not parsed correctly if stop comment is last token of file, prior to a newline
Wrong SQL generation for PostgreSQL function calls having arguments with custom data types.
Fix Support annotations for CREATE SEQUENCE flags
LoggingConnection does not log static statements
DataType.getDataType(Configuration) turns this on dialect specific data types
RenderMapping is not applied to DSL.schema(Name)
CREATE INDEX commands created from DSLContext.ddl() based on Meta contain illegal WHERE clause
Java 8 distribution references JAXB 2.3.0, which doesn't work pre JDK 9
Firebird generated code contains "DEFAULT" keyword in default expressions
Emulate RETURNING * in Firebird
Regression in Firebird's SUBSTRING() implementation
When using org.jooq.Meta, UniqueKey.getReferences throws NPE in Firebird

New in jOOQ 3.12.1 (Sep 2, 2019)

New in jOOQ 3.12.0 (Aug 29, 2019)

In this release, we've focused on a lot of minor infrastructure tasks, greatly improving the overall quality of jOOQ. We've reworked some of our automated integration tests, which has helped us fix a big number of not yet discovered issues, including a much better coverage of our 26 supported RDBMS dialects.
We're excited about these internal changes, as they will help us implement a lot of features that have been requested by many for a long time, including an immutable query object model, with all the secondary benefits like caching of generated SQL, and much more powerful dynamic SQL construction and transformation in the future.
Major new features include the new procedural language API shipped with our commercial distributions, new data types including native JSON support, MemSQL support, formal Java 11+ support, a much better parser, and reactive stream API support.
Procedural languages:
Following up on jOOQ 3.11's support for anonymous blocks, the jOOQ 3.12 Professional and Enterprise Editions now include support for a variety of procedural language features, including
Variable declarations
Variable assignments
Loops (WHILE, REPEAT, FOR, LOOP)
If Then Else
Labels
Exit, Continue, Goto
Execute
This feature set is part of our ongoing efforts to continue supporting more advanced vendor specific functionality, including our planned definition and translation of stored procedures, triggers, and other, ad-hoc procedural logic that helps move data processing logic into the database server.
New Databases Supported:
The jOOQ Professional Edition now supports the MemSQL dialect. MemSQL is derived from MySQL, although our integration tests have shown that there are numerous differences, such that supporting MemSQL formally will add a lot of value to our customers by providing much increased syntactic correctness.
Reactive streams:
The reactive programming model is gaining traction in some environments as new, useful streaming APIs emerge, such as e.g. Reactor. These APIs have agreed to work with a common SPI: reactive streams, and since JDK 9 the new java.util.concurrent.Flow SPI. jOOQ 3.12 now implements these paradigms on an API level, such that an integration with APIs like Reactor becomes much more easy. The implementation still binds to JDBC, and is thus blocking. Future versions of jOOQ will abstract over JDBC to allow for running queries against ADBA (by Oracle) or R2DBC (by Spring)
New data types:
We've introduced native support for a few new data types, which are often very useful in specific situations. These include:
JSON / JSONB: A native string wrapper for textual and binary JSON data. While users will still want to bind more specific JSON to maps and lists using custom data type Bindings, in a lot of cases, being able to just serialise and deserialise JSON content as strings is sufficient. jOOQ now provides out of the box support for this approach for various SQL dialects.
INSTANT: RDBMS do not agree on the meaning of the SQL standard TIMESTAMP WITH TIME ZONE. PostgreSQL, for example, interprets it as a unix timestamp, just like java.time.Instant. For an optimal PostgreSQL experience, this new INSTANT type will be much more useful than the standard JDBC java.time.OffsetDateTime binding.
ROWID: Most RDBMS have a native ROWID / OID / CTID / physloc identity value that physically identifies a row on the underlying storage system, irrespective of any logical primary key. These ROWIDs can be leveraged to run more performant, vendor specific queries. Supporting this type allows for easily using this feature in arbitrary queries.
Parser:
Our parser is seeing a lot of continued improvements over the releases as we gather feedback from our users. Our main drivers for feedback are:
The DDLDatabase which allows for generating code from DDL scripts rather than live JDBC connections to your database
The https://www.jooq.org/translate website, which translates any kind of SQL between database dialects.
SQL dialect translation will evolve into an independent product in the future. DDL parsing is already very powerful, and a lot of customers rely on it for their production systems.
In the next versions, we will be able to simulate DDL on our own, without H2, which will open up a variety of possible use cases, including better schema management.
Specific jOOQ 3.12 parser improvements include:
Being able to access schema meta information (column types, constraints) to better emulate SQL features / translate SQL syntax between dialects
A parse search path, similar to PostgreSQL's search_path, or other dialects' current_schema, allowing support for unqualified object references.
The DDL simulation from the DDLDatabase is now moved into the core library, supporting it also out of the box as a DDL script based meta data source
A new special comment syntax that helps ignoring SQL fragments in the jOOQ parser only, while executing it in your ordinary SQL execution.
A new interactive mode in the ParserCLI
Support for nested block comments
And much more
Formal Java 11 Support:
While we have been supporting Java 11 for a while through our integration tests, jOOQ 3.12 now fully supports Java 11 to help improve the experience around the transitive JAXB dependency, which we now removed entirely out of jOOQ.
The commercial editions ship with a Java 11+ supporting distribution, which includes more optimal API usage, depending on new Java 9-11 APIs. All editions, including the jOOQ Open Source Edition, have a Java 8+ distribution that supports any Java version starting from Java 8.
Commercial Editions:
Dual licensing is at the core of our business, helping us to provide continued value to our customers.
In the past, the main distinction between the different jOOQ editions was the number of database products each edition supported. In the future, we want to provide even more value to our customers with commercial subscriptions. This is why, starting from jOOQ 3.12, we are now offering some new, advanced features only in our commercial distributions. Such features include:
The procedural language API, which is available with the jOOQ Professional and Enterprise Editions
While the jOOQ 3.12 Open Source Edition supports Java 8+, the jOOQ 3.12 Professional Edition also ships with a Java 11+ distribution, leveraging some newer JDK APIs, and the jOOQ 3.12 Enterprise Edition continues supporting Java 6 and 7.
Since Java 8 still sees very substantial market adoption, compared to Java 11, we still support Java 8 in the jOOQ 3.12 Open Source Edition.
Starting from jOOQ 3.12, formal support for older RDBMS dialect versions in the runtime libraries is reserved to the jOOQ Professional and Enterprise Editions. The jOOQ Open Source Edition will ship with support for the latest version of an RDBMS dialect, only. The code generator is not affected by this change.
By offering more value to our paying customers, we believe that we can continue our successful business model, which in turn allows us to continue the free jOOQ Open Source Edition for free. Our strategy is:
To implement new, advanced, commercial only features.
To offer legacy support (legacy Java versions, legacy database versions) to paying customers only.
To continue supporting a rich set of features to Open Source Edition users.
H2 and SQLite integration:
Over the past year, both H2 and SQLite have seen a lot of improvements, which we have now supported in jOOQ as well. Specifically, H2 is moving at a very fast pace, and our traditional close cooperation got even better as we're helping the H2 team with our insights into the SQL standards, while the H2 team is helping us with our own implementations.
Other improvements:
The complete list of changes can be found on our website: https://www.jooq.org/notes
A few improvements are worth summarising here explicitly
We've added support for a few new SQL predicates, such as the standard UNIQUE and SIMILAR TO predicates, as well as the synthetic, but very useful LIKE ANY predicate.
The JAXB implementation dependency has been removed and replaced by our own simplified implementation for a better Java 9+ experience.
The historic log4j (1.x) dependency has been removed. We're now logging only via the optional slf4j dependency (which supports log4j bridges), or java.util.logging, if slf4j cannot be found on the classpath.
The shaded jOOR dependency has been upgraded to 0.9.12.
We've greatly improved our @Support annotation usage for better use with jOOQ-checker.
jOOQ-checker can now run with ErrorProne as well as with the checker framework as the latter still does not support Java 9+.
We've added support for a lot of new DDL statements and clauses.
There is now a synthetic PRODUCT() aggregate and window function.
We added support for the very useful window functions GROUPS mode.
Formatting CSV, JSON, XML now supports nested formatting.
UPDATE / DELETE statements now support (and emulate) ORDER BY and LIMIT.
When constructing advanced code generation configuration, users had to resort to using programmatic configuration. It is now possible to use SQL statements to dynamically construct regular expression matching tables, columns, etc.
Configuration has a new UnwrapperProvider SPI.
MockFileDatabase can now handle regular expressions and update statements.
Settings can cleanly separate the configuration of name case and quotation.
MySQL DDL character sets are now supported, just like collations.
A new Table.where() API simplifies the construction of simple derived tables. This feature will be very useful in the future, for improved row level security support.
A nice BigQuery and H2 feature is the " EXCEPT (...)" syntax, which allows for removing columns from an asterisked expression. We now have Asterisk.except() and QualifiedAsterisk.except().
A lot of improvements in date time arithmetic were added, including support for vendor specific DateParts, like WEEK.
Features and Improvements:
#714 Add support for non-standard ORDER BY .. LIMIT clauses in UPDATE, DELETE statements
#1699 Add support for the SQL standard UNIQUE predicate
#1725 Add support for SQL standard SIMILAR TO predicate
#2026 Add a new @Internal annotation to annotate API parts that are not supposed to be used
#2059 Add support for the MemSQL database for the jOOQ Professional Edition
#2132 Add support for non-standard date-time fields in the EXTRACT() function
#2208 Implement a MockFileDatabase
#2233 Add Result<?> DSLContext.fetchFromXML() to allow for loading results that were exported using Result.formatXML()
#2731 Add some sections to the manual helping users migrate from other popular ORMs
#3606 Emulate INSERT/UPDATE/DELETE (SELECT ...) by WITH v AS (SELECT ...) INSERT/UPDATE/DELETE v on SQL Server
#3607 Allow for emitting common table expression declarations to RenderContext
#4371 Let ResultQuery<R> extend Publisher<R>
#4473 Add ResultQuery<R1>.coerce(Field<?>[]), coerce(Table<R>), that coerce a new Record type on a ResultQuery
#4498 Emulate INSERT .. RETURNING via SQL Server OUTPUT clause
#5110 Add support for Derby's MERGE statement
#5576 Add support for SQLite 3.15's row value expression support
#5601 IN list padding setting should also apply to row IN predicates
#5640 MockFileDatabase should support all jOOQ import formats, including JSON, XML
#5700 Add support for Oracle's STATS_MODE() aggregate function
#5781 Add support for ALTER TABLE .. RENAME COLUMN in MySQL 8
#5895 Add support for TIME[STAMP] WITH TIME ZONE in HSQLDB
#5899 jOOQ-checker should provide both checker-framework and ErrorProne checks
#5909 Deprecate RenderNameStyle.QUOTED and replace feature by renderQuotedNames
#5939 Add PRODUCT() aggregate and window function
#5966 Add support for NATURAL FULL [ OUTER ] JOIN
#5969 Add <includeInvisibleColumns/> to code generator configuration to allow for hiding Oracle's and H2's INVISIBLE columns
#6234 Add newline configuration to code generator
#6260 Support loading multiple files in XMLDatabase
#6450 Javadoc should reference JDK 11 Javadoc
#6475 Add procedural language abstraction API
#6486 Add a JDK 11 build
#6548 Support multiple external configuration files through <configurationFiles/>
#6583 Work around MySQL's self-reference-in-DML-subquery restriction
#6709 Support custom Hibernate properties in JPADatabase
#6778 Support parsing PostgreSQL's dollar quoted string constants
#6944 Add a way to specify what object type a <forcedType/> should match
#6971 Allow Maven plugin to succeed in absence of valid DB connection if schema is up to date
#7005 Add support for MariaDB INTERSECT and EXCEPT
#7048 Document the FILTER clause
#7143 Support merging external <configurationFile/> into Maven configuration
#7153 Allow for configuring a locale to be used for upper/lower casing inside of jOOQ
#7163 Add Settings.parseWithMetaLookups
#7216 Add RecordN<T1, ..., TN> fetchSingle(Field<T1>, ..., Field<TN>)
#7235 DDLDatabase fails with ParserException on JSON field
#7268 Add support for MySQL's UNIQUE [ index_name ] syntax
#7297 Support deriving a WindowDefinition from another WindowDefinition
#7305 Add support for DECLARE statements inside of statement blocks
#7306 Add support for the SET command to assign values to variables
#7331 Add reference to <forcedType/> configuration in DataType, Converter, Binding
#7336 Add new flags to Settings to govern parser behaviour
#7337 Add Settings.parseDialect
#7361 Improve formatting of nested joins
#7397 Add a section to the manual about SELECT
#7426 Add support for Teradata QUALIFY
#7445 Support parsing PostgreSQL-specific interval literals
#7470 Add indexOf() methods to all TableLike types
#7485 Document jOOQ's auto-conversion utility
#7490 Upgrade jOOQ-meta-extensions dependency to Hibernate 5.4
#7545 ForcedType configurations should have include / exclude expressions
#7570 Add support for CREATE TYPE .. AS ENUM
#7587 Use --release flag in JDK 9+ based builds
#7591 Add new ResourceManagingScope which allows for Binding implementations to register resources which are freed after execution
#7595 Add support for Java 11
#7598 Add search box to Javadocs
#7599 Print row count in LoggerListener for ResultQuery
#7602 Upgrade jOOR dependency's Java 9 functionality
#7609 Add Setting to turn off ORDER BY clause in emulated OFFSET .. FETCH pagination
#7612 Add configuration to DDLDatabase to indicate whether unquoted names are reported in lower case, upper case or as-is
#7619 Don't ship old XSDs in binaries
#7628 Add support for PostgreSQL 11
#7633 ALTER TABLE .. ADD FOREIGN KEY .. REFERENCES references unqualified table name
#7646 Support for window functions GROUPS mode
#7647 Support window function EXCLUDE clause
#7678 Mention more ways to inline parameters in manual
#7705 Add support for PostgreSQL FOR NO KEY UPDATE and FOR KEY SHARE
#7712 Add support for Catalogs in JDBCDatabase
#7719 Add code generation flag to treat MySQL TINYINT(1) as BOOLEAN
#7727 Support parsing DEGREES() as a synonym for DEGREE() and DEG(), and RADIANS() for RADIAN(), RAD()
#7734 Make the JAXB implementation dependency optional with a custom fallback implementation
#7748 Add support for CREATE SEQUENCE flags
#7749 Support parsing CREATE INDEX .. ON .. USING btree (..)
#7751 Add support for ALTER TABLE ONLY
#7755 Add an integration test to discover all DSL API that is not covered by the parser
#7756 Improve SQLite repeat() emulation
#7757 Improve SQLite LPAD() and RPAD() emulation
#7759 Add DDLDatabase property unqualifiedSchema to specify what the unqualifiedSchema is
#7760 Upgrade SybDriver version in JDBCUtils.driver(String)
#7774 Add support for DROP TYPE
#7776 Add support for parsing custom data types
#7782 Record.formatJSON() should format nested records recursively
#7788 Support Java 6 and 7 only in Enterprise Edition
#7792 Support DatePart.DAY_OF_WEEK and DatePart.ISO_DAY_OF_WEEK
#7793 Support DatePart.DAY_OF_YEAR
#7794 Support DatePart.EPOCH
#7796 Support DatePart.QUARTER
#7799 jOOQ manual about Gradle code generation should not make explicit use of JAXB
#7800 Let Record extend Formattable
#7801 Record.formatXML() should format nested records recursively
#7802 Record.formatCSV() should format nested records recursively
#7809 Generate overridden Table.fieldsRow() method in generated tables
#7810 Add DSL.rowField(RowN)
#7839 Emulate { UPDATE | DELETE } ORDER BY and LIMIT
#7856 Upgrade maven-scala-plugin to scala-maven-plugin
#7862 Add SQLDialect.ORACLE18C
#7865 Add support for SQLite window functions
#7866 Add support for SQLite ALTER TABLE .. RENAME COLUMN
#7870 Add support for Java 11
#7872 Add support for HSQLDB EXPLAIN PLAN FOR
#7873 Add HSQLDB support for Sequence.currval()
#7882 Add Field.startsWithIgnoreCase() and Field.endsWithIgnoreCase()
#7885 Add Table.rowid()
#7902 Add parser support for negative numeric scales
#7904 Apply optimistic locking logic also for non-updatable TableRecords on insert()
#7905 Add a new org.jooq.RowId type that corresponds to java.sql.RowId
#7906 Add support for H2 window functions
#7907 Support parsing vendor-specific RESPECT NULLS / IGNORE NULLS syntax
#7909 ExecuteContext.sqlException(SQLException) should accept null
#7913 Add support for H2 standard MERGE statement
#7914 Overload fetchXYZ(T, Collection<? extends Condition>) and fetchXYZ(T, Condition...)
#7915 Add Query.poolable(boolean) to govern the JDBC Statement.setPoolable() behaviour
#7921 Add support for Asterisk.except(Field...) and QualifiedAsterisk.except(Field...)
#7922 Upgrade org.checkerframework:checker dependency in jOOQ-checker
#7924 Add a CompileOptions argument object to pass annotation processors and other things to Reflect.compile()
#7947 Let code generation patterns match also partially qualified object names
#7948 Use the new H2 1.4.198 INFORMATION_SCHEMA.COLUMNS.IS_VISIBLE column
#7952 Add SQLDataType.INSTANT
#7954 Document in Javadoc that JDBCUtils.dialect() and similar methods return DEFAULT, not null
#7956 Deprecate DSL.groupConcat(Field<?>, String)
#7966 Add Setting to turn off fetching generated keys from UpdatableRecord
#7971 Add delegation support to JDBC 4.3 methods in DefaultConnection and similar types
#7974 Add Reflect.initValue(Class)
#7999 Overload AbstractTable.createField(Name, ...) methods
#8000 Deprecate AbstractTable.createField(String, ...) methods
#8001 Overload all date time arithmetic API with Instant arguments
#8004 Handle edgecase with Kotlin boolean types
#8005 Improve the manual's section about serializability to disclaim any backwards compatible format
#8010 Add Table.where(Condition) and overloads
#8022 Support passing java.util.Date as a Field<Object> bind value
#8030 Remove the unnecessary Schema.getComment() override
#8034 Add DataType.isDate()
#8036 Add DataType.isTime()
#8041 Add support for DataType.characterSet()
#8061 Add functions xyz(date) for each extract(xyz from date) datepart
#8074 Support parsing nested block comments
#8075 Support parsing nested block comments in plain SQL
#8076 Allow for chaining DataType.asConvertedDataType(Converter) calls
#8077 Add org.jooq.types.YearToSecond to support PostgreSQL mixed interval values
#8083 Add Interval.toDuration()
#8087 Add support for overloaded functions in H2
#8093 Add support for result less statements in MockFileDatabase
#8102 Add RenderNameCase.LOWER_IF_UNQUOTED and UPPER_IF_UNQUOTED
#8103 Add RenderQuotedNames.EXPLICIT_DEFAULT_QUOTED and EXPLICIT_DEFAULT_UNQUOTED
#8107 Add Name.Quoted Name.quoted()
#8108 Add a CriteriaQuery vs jOOQ Example
#8109 Add org.jooq.tools.jdbc.LoggingConnection
#8114 [#8004] Handle edgecase for Kotlin boolean type
#8115 XMLDatabase configuration properties should be in camel case for consistency
#8124 Support regular expressions in MockFileDatabase
#8126 Add an external MockFileDatabaseConfiguration object
#8135 Add support for IF statements inside of statement blocks
#8138 Add indentation configuration to code generator
#8145 Add an UnwrapProvider SPI that allows for unwrapping underlying JDBC types through proprietary APIs
#8163 Deprecate synonym keywords and use suffix underscore instead
#8168 Add support for procedural blocks that do not generate BEGIN .. END
#8174 Add support for WHILE loops in procedural blocks
#8175 Add support for LOOP in procedural blocks
#8176 Add support for indexed FOR loops in procedural blocks
#8179 Provide empty base implementation for QueryPartInternal.clauses()
#8186 Add support for EXIT [ WHEN ] in procedural blocks
#8187 Add support for CONTINUE [ WHEN ] in procedural blocks
#8188 Add support for labels in procedural blocks
#8189 Add support for GOTO in procedural blocks
#8190 Remove private DSL.field(Row[N]) methods
#8206 Add new Settings.inlineThreshold
#8213 Move some DataKey values to a new BooleanDataKey enum
#8217 Add an annotation for commercial only API
#8219 Add additional documentation that explains DefaultGeneratorStrategy's role in disambiguating names
#8233 YearToSecond should be equal to YearToMonth or DayToSecond, if same interval is represented
#8235 Improve Sakila database example scripts
#8236 Add DataType.isTimestamp()
#8238 Add DSL.convert(DataType<?>, Field<?>, int) to support SQL Server CONVERT() function
#8240 Add a Javadoc link from all org.jooq.XYZ types to their respective DSL.xyz() constructor method
#8247 Add DSL.truncate(String) overload for consistency
#8249 Support configuring ParamType in /translate service
#8255 Add more Javadoc to common org.jooq.XYZ types
#8256 DefaultExecuteContext should contain only a single ThreadLocal list with resources
#8261 Add trim(String, char), rtrim(String, char), ltrim(String, char)
#8262 Add support for SQL Server 2017 TRIM()
#8264 Expose new Settings.parseDialect in ParserCLI
#8275 Improve SQLite's CEIL and FLOOR emulation
#8276 Add overloads CreateTableColumnStep.columns(Name...) and columns(String...)
#8280 Add CTE support for SQLite
#8285 Add support for REPEAT statements in procedural blocks
#8290 Add Parser.parseStatement() to parse procedural code
#8291 Create bug report / feature request / question issue templates
#8294 Add interactive mode to ParserCLI
#8297 Support inverse distribution functions in H2
#8298 Support hypothetical set functions in H2
#8299 Support FILTER clause on aggregate functions in H2
#8300 Support MODE() and MEDIAN() in H2
#8302 Emulate procedural languages in H2
#8308 Support ALTER TABLE .. ADD with multiple columns in PostgreSQL
#8309 Add parser support for declaring multiple variables in one procedural statement
#8317 Improve manual railroad diagrams for repetitions with comma
#8324 Parser should ignore { CREATE | DROP } EXTENSION statement
#8325 Add a special comment syntax to the Parser and DDLDatabase that allows for ignoring certain statements
#8331 Add DSLContext.truncateTable() as an alias for truncate()
#8333 Support INSERT .. ON ( DUPLICATE KEY | CONFLICT ) in Derby
#8346 Improve Javadoc on DSLContext.meta(Table...) etc.
#8360 Add new MatcherTransformType.LOWER_FIRST_LETTER and UPPER_FIRST_LETTER
#8383 Emulate { UPDATE | DELETE } table AS alias in SQL Server
#8386 Support inline constraint names in CREATE TABLE statements
#8390 Add support for unmapping Iterable
#8391 DSLContext.fetchFromJSON() should be able to read JSON without header information
#8407 Add code generation configuration flag to set Connection.setAutoCommit()
#8409 Add support for plain SQL CREATE VIEW statements
#8412 Add DSL.neg(Field<?>) as an alias for Field.neg()
#8415 Support PERCENT and WITH TIES in H2
#8421 Support various DDL statements in Informix
#8424 Better VALUES() emulation in Informix using TABLE(MULTISET)
#8430 Ignore ON { DELETE | UPDATE } NO ACTION in dialects that do not support the syntax
#8433 Add support for SQLite ON CONFLICT
#8438 Add support for CREATE SCHEMA in MySQL
#8446 Add <sql> to <forcedType> to allow for matching columns with SQL
#8447 Add <sqlMatchesPartialQualification>
#8451 Add SQL parser support for PostgreSQL ILIKE
#8463 Add <includeCheckConstraints/> flag to code generator
#8464 Log slow result set fetching in code generator
#8465 Add a new <logSlowResultsAfterSeconds/> code generation flag
#8471 Add a link in the manual from simple-crud to settings-return-all-on-store
#8477 Support views with renamed columns in SQLite's CREATE VIEW statement
#8479 Emulate INSERT .. ON DUPLICATE KEY UPDATE .. WHERE on MySQL
#8486 Add Settings.renderNamedParamPrefix to support dialect specific named parameter placeholders
#8498 Add more documentation to the RETURNING clause
#8504 Remove manual from OSS repository
#8505 Modules should reference managed H2 dependency
#8522 Emulate the PL/SQL BOOLEAN type in SQL functions in Oracle 12c
#8529 Improve documentation of INSERT ... ON CONFLICT related APIs
#8539 Add alias DSL.default_() for DSL.defaultValue()
#8542 Add support for LATERAL to MySQL
#8547 Add SQLDialect.SQLITE_3_28 and SQLDialect.SQLITE_3_25
#8551 Support old SQLDialects only in commercial distributions
#8552 Add SQLDialect.supports(Collection<SQLDialect>)
#8556 Support GROUP BY ROLLUP on SQL Data Warehouse
#8560 Add support for calling stored functions with defaulted parameters from SQL in Oracle
#8577 Add synthetic [NOT] LIKE ANY and [NOT] LIKE ALL operators
#8579 Support parsing the UNIQUE predicate
#8588 Add support for SQLite partial indexes
#8590 Add support for SQLite EXPLAIN
#8591 DSL#table(Object[]) calls DSL#table(Field) with incompatible @Support annotation
#8595 Support more DDL for MySQL
#8596 Support more DML for MySQL
#8600 Emulate CREATE TABLE (...) COMMENT syntax in DB2
#8601 Add code generator support for DB2 table and column comments
#8602 Add support for DB2 translate
#8604 Add support for DB2 multi ALTER TABLE ADD / DROP statements
#8616 Add Settings.parseSearchPath
#8619 Let Query subtypes extends RowCountQuery, which extends Publisher<Integer>
#8620 Replace Query references by RowCountQuery where appropriate
#8623 Add parser support for TOP (n) in DML
#8639 Improve documentation about custom syntax elements
#8646 Apply Settings.fetchSize also to other statements than ResultQuery
#8649 Add support for MySQL's ALTER TABLE .. DROP FOREIGN KEY syntax
#8650 Add support for MySQL's ALTER TABLE .. DROP PRIMARY KEY syntax
#8656 Add org.jooq.DDLExportConfiguration
#8657 Add DDLExportConfiguration.createSchemaIfNotExists and createTableIfNotExists flags
#8658 Improve manual's parser grammar and make better reuse of keywords in DDL
#8660 Add support for synthetic ALTER TABLE .. DROP PRIMARY KEY <name> syntax
#8671 Some @Support annotations have duplicated dialects
#8674 Complete parser test suite with tests for all supported built-in functions
#8675 Parse CONNECT_BY_ROOT expressions
#8678 Enable Settings.parseUnknownFunctions in DDLDatabase
#8685 Avoid generating unnecessary {@inheritDoc}
#8689 Generate LN function in H2, instead of LOG
#8693 Add support for generation of comments on HSQLDB schema objects
#8695 Use Configuration#family() convenience
#8696 Use SQL Server 2012's LOG() with base parameter
#8703 Add DSL#log(Field, Field) overload
#8704 Add support for MERGE in Vertica
#8710 Add support for generating comments on tables in Vertica
#8716 Support DSL#md5() for SQL Server
#8724 Add UpdateSetStep.setNull(Field<?>) for convenience
#8728 Parser cannot handle double quoted string literals in dialects that support them
#8735 Support DSL#offset[Date]Time() and DSL#instant() for SQLite
#8736 Avoid catching NumberFormatException when parsing potential numbers
#8739 H2: Support ALTER SCHEMA
#8742 H2: Support DROP SCHEMA ... [CASCADE | RESTRICT]
#8744 H2: Support INSERT ... ON CONFLICT DO UPDATE
#8745 Add Guava to the documented list of shaded dependencies
#8746 Add Settings.(execute|record|transaction|visit)Listener(Start|End)InvocationOrder to support REVERSE ordering on end() events
#8751 Improve rendering performance of SQL templates
#8753 Add additional Context.sql(long), sql(float), sql(double)
#8754 Avoid using plain SQL templating, internally
#8759 Add support for SET SCHEMA in Teradata
#8764 Add comments in old manual versions about the jooq-meta and jooq-codegen package renames
#8766 Add missing dialects to DSLContext#mergeInto(Table)
#8767 Complete @Support annotation on DSL#alterView() to include `DB2` and `FIREBIRD`
#8768 Complete @Support annotation on DSL#alterIndexIfExists() to include SQLDATAWAREHOUSE and TERADATA
#8769 Methods on TableOuterJoinStep should for now only support ORACLE
#8770 Align @Support annotations of SelectLimitAfterOffsetStep#limit() methods
#8771 Add LIMIT ... OFFSET ... WITH TIES support for Redshift
#8772 Fix @Support annotations of CreateIndexIncludeStep
#8774 Remove SQLITE from @Support annotations on AlterTableAlterStep
#8780 SQL Server: Support AlterIndexStep#renameTo()
#8781 Improve error message when org.jooq.util class cannot be found in code generator configuration
#8782 WindowRowsAndStep methods should declare VERTICA support
#8783 MergeNotMatchedSetStep methods should declare VERTICA support
#8784 MergeValuesStepN methods should declare MARIADB and AURORA_MYSQL support
#8789 Add support for parsing MySQL numeric interval literals
#8793 Add missing dialects to MergeValuesStepN#values()
#8794 Add missing dialects to OrderedAggregateFunction
#8795 Support AlterTableAlterStep#set() with SQLDATAWAREHOUSE
#8796 Implement InsertOnDuplicateSetStep#set() for FIREBIRD_3_0
#8797 Add Javadoc to StopWatchListener explaining that it should be wrapped in an ExecuteListenerProvider
#8803 Improve performance of StringUtils#replace()
#8825 Add support for additional DB2 and SQLDATAWAREHOUSE DateParts
#8827 SQLServerDatabase should read tables also from sys.all_objects
#8833 Oracle: Support DatePart WEEK
#8837 Add missing @Support annotations to Operator enum
#8850 Informix: Support LikeEscapeStep#escape()
#8852 Support parsing empty IN lists
#8853 Add support for [NOT] LIKE ANY (subquery) and [NOT] LIKE ALL (subquery)
#8854 Add more internal type safety by making Tools.fields() methods generic
#8856 Generate empty IN lists in SQL for H2 and SQLite
#8857 Spring Boot example should reference custom jOOQ version
#8863 Use imported class name in Tables.java to dereference singleton table instance
#8867 Add SQLDialect.supported()
#8883 Use noCondition() in fetchXYZ(Table), fetchXYZ(Table, Condition) overloads
#8887 Add SQLDataType.DECIMAL_INTEGER(int) as a shortcut for DataType.precision(int)
#8889 Upgrade scala 2.12 dependency to 2.12.8
#8899 Implement specialised emulation for Oracle single row INSERT .. RETURNING with expressions
#8900 Release 3.12: Make current master branch Java 6 compatible
#8903 Add Support annotations to DataType methods
#8905 GeneratorWriter should check the file size prior to opening existing files to compare contents
#8909 Upgrade jOOR dependency to 0.9.12
#8912 Add reference to noCondition(), trueCondition(), and falseCondition()
#8914 Always use MiniJAXB
#8918 MiniJAXB should warn about unknown XML elements
#8919 MiniJAXB#marshal() should output formatted XML
#8920 Implement UPDATE / DELETE .. RETURNING in SQL Server using OUTPUT
#8924 Add Settings.updateRecordVersion and Settings.updateRecordTimestamp
#8925 Add DAO.fetchRangeOf(Field<Z>, Z, Z)
#8932 Use diamond operator in jOOQ code
#8939 Support Flyway file ordering in DDLDatabase
#8943 Add org.jooq.JSON and org.jooq.JSONB
#8944 Add support for standard JSON functions
#8959 Add Settings.mapConstructorParameterNamesInKotlin
#8963 Manual page about SELECT should use DSL.inline() and DSL.val() in addition to selectZero() and selectOne()
#8972 jOOQ-meta should query dictionary views for column existence rather than the column itself
#8975 Log warning when user uses <inputSchema/> on a database that does not support schemas
#8976 [jOOQ/jOOQ#8939] Support Flyway file ordering in DDLDatabase
#8982 Add a SingleConnectionDataSource
#8985 Create a new jOOQ-extensions module
#8986 Move DDLDatabase DDL simulation via H2 to jOOQ-extensions and implement it through org.jooq.Meta
#8987 Improve MockResult Javadoc
#9001 DefaultRecordMapper should internally also use the RecordMapperProvider
#9006 Document logger name for SQL logging
#9009 AbstractMeta should consistently cache all information
#9011 DDLDatabase failed to parse MySQL NOW(6)
#9015 Add support for unqualifiedSchema in JPADatabase to prevent generating the H2 PUBLIC schema
#9018 Update Scala compiler to 2.12.9
#9022 Mention fetch sizes on the topic of lazy fetching
#9030 Add AlterSequenceStep.restartWith(Field<? extends T>) overload
#9032 Add a documentation example for usage of transactionResult()
#9035 Teradata support for InsertOnDuplicateStep#onDuplicateKeyUpdate()
#9036 Missing @Support annotations on SelectSeekStep<N> methods
#9037 Missing @Support annotations on CaseWhenStep#map[Fields|Values]() methods
#9048 Delete module-info.java.invalid files
#9051 Add section titles to multi page manual
#9058 Undocument use-attribute-converters in favour of useAttributeConverters
#9062 AlterTableImpl#dropColumn() should not use #dropColumns()
#9063 Support for ALTER TABLE ... DROP PRIMARY KEY for Derby and HSQLDB
#9064 HSQLDB: Support WEEK() function
#9070 Add Constants.CP_RUNTIME and other values
#9078 Improve MockFileDatabase error message "Invalid SQL"
#9082 ResultQuery.fetchStream() and similar overloads should add an explicit statement about resulting streams being resourceful
Breaking changes:
#5309 Add support for CREATE TABLE t(c1, c2, ..., cn) AS SELECT ...
#5538 Compilation error in Keys.java when two tables contain the same (unique) index name in SQL Server
#7242 Add support for JSON / JSONB types
#7565 Remove @javax.annotation.Generated annotation from jOOQ code
#7583 Add new <generatedAnnotationType/> flag to specify Generated annotation
#7643 Use slf4j directly for logging, remove log4j dependency
#7659 Support any Number type for LIMIT .. OFFSET
#7737 Remove the org.jooq.api.annotation package
#7747 Rename jooq-codegen.xsd Schema, Schemata, Catalog, Catalogs types to have a Type suffix
#7826 Constraints referencing columns that are not generated should not be generated either
#7851 DSL.coerce() should use argument field's qualified name
#7874 Pull up DAOImpl.getId() to DAO.getId()
#7925 Make org.jooq.impl classes Iif, NullIf, KeywordImpl package-private
#7953 Discover JPA annotations also from overridden super class methods
#8033 Relax generic constraint on DSLContext.executeInsert(), executeUpdate() and similar methods
#8173 SelectIntoStep.into() should return SelectFromStep, not SelectIntoStep
#8231 Negative YearToMonth() intervals are not correctly normalised
#8232 Negative DayToSecond() intervals are not correctly normalised
#8234 "Unnecessary" casts should no longer be ignored
#8362 <regexFlags/> is not applied to matcher strategy
#8434 Support H2 v1.4.198 array syntax
#8502 Add support for H2 1.4.198 row value expression subquery syntax
#8682 Parsing of LOG() function
#8877 fetchSingle() failure does not trigger ExecuteListener#exception() event
Bug Fixes:
#1535 Generate dummy ORDER BY clause for ranking functions on databases that require them
#5215 Companion object for routine classes generated by ScalaGenerator cause java.lang.IllegalAccessError at runtime
#6382 Fix Derby Support annotations
#6745 DDL statements on MySQL create CHAR column instead of VARCHAR column on unknown lengths
#6754 Significant amount of Object[] allocations due to internal EnumMap
#6920 Update API with Vertica Support annotations
#6932 Document <enumConverter/> in manual
#7161 Slow ROWTYPE discovery queries on large Oracle schemas
#7295 SQL Translation Error with MONEY data type
#7319 SQLDialectNotSupportedException: The ON DUPLICATE KEY UPDATE clause cannot be emulated for DEFAULT when using the Batch API with named parameters
#7389 UniqueKey.getReferences returns unnamed foreign keys
#7418 Error when using <matchers/> with <schemas/> in Maven code generation
#7429 Flawed Custom Logging ExecuteListener example in the manual
#7434 ORA-01861 when casting string as date
#7496 UDT data types are unqualified in PostgreSQL, when there is more than one UDT data type per schema
#7518 Various parser bugs / missing features
#7525 Support parsing DAYOFMONTH() function
#7551 Wrong type information associated to Row[N].operator(T1, ..., TN) predicates
#7554 UpdatableRecordImpl no longer work when globalObjectReferences is set to false
#7556 Add a specific error message if org.jooq.util packages are being used in 3.11+
#7562 Incomplete Support annotation on some of the H2 style mergeInto overloads
#7567 Support mixing constraint definitions and columns in the parser
#7568 Cannot parse CREATE INDEX statement on a field called "field"
#7569 Regression in UpdatableRecord.store() and update() methods when used with connection pools
#7571 Support alternative PostgreSQL array syntax in parser
#7573 Code generator should generate implicit join constructors in absence of inbound foreign keys
#7578 Spring boot example test repeats identical assertion
#7579 org.jooq.meta.xml.XMLDatabase does not generate target classes when project is compiled on JDK 9 or 10
#7584 Regression in DSL.or(Collection) when passing empty collection
#7589 Cannot bind double types to prepared statements when using Oracle and DBCP
#7594 Illegal reflective access when running jOOQ on Java 10
#7597 CREATE TABLE with enum types generates CHECK constraint rather than enum type reference in PostgreSQL
#7600 NullPointerException on Query.getBindValues
#7616 Support CREATE OR REPLACE VIEW in H2
#7622 Typo in manual, additional DDLDatabase and JPADatabase reference
#7627 Cannot parse comma separated identity specification elements
#7630 Close the Maven Plugin's URLClassLoader after code generation
#7634 Add remark to the Javadoc of <SQLDialect>DataType classes indicating what the deprecation replacement is
#7637 Manual refers to non-existent "configuration" element in Gradle code generation configuration
#7641 java.lang.NoSuchMethodException when calling createARRAY on JBoss WrappedConnectionJDK8
#7644 Code generator uses H2 TIMESTAMP precision instead of scale
#7649 jOOQ 3.11+ transitive dependency prevents it from being loaded on WebLogic 12.1.3
#7650 Issues with codegen generating PUBLIC always
#7651 Error Parsing Script for DDLDatabase when column name is called "index"
#7652 Upgrade to maven-compiler-plugin 3.7.1-SNAPSHOT
#7655 ResultImpl#intoMap produces an incorrect error message on duplicate key
#7660 EVERY() aggregate function emulation doesn't yield NULL when aggregating empty sets
#7663 Referenced WindowDefinitions should not be inlined in MySQL, Sybase SQL Anywhere
#7672 NPE in DefaultRecordMapper when returning it from custom RecordMapperProvider
#7680 Allow for overriding the order of generated import statements
#7688 NPE in MockResultSet.withTZ() methods
#7691 NullPointerException when aggregating row value expressions using ARRAY_AGG()
#7692 Compilation errors in generated code for PostgreSQL's pg_catalog schema
#7693 Compilation error in generated code when generated Javadoc contains unicode escape sequences
#7694 Cannot parse OTHER data type
#7696 Cannot parse H2 style ARRAY data type
#7706 ArrayIndexOutOfBoundsException when using double quotes in plain SQL as string delimiters
#7707 Dead link to MySQL manual on group by page
#7713 ASEDatabase doesn't work with older Sybase ASE versions
#7714 Meta.getCatalogs() should not return catalogs in databases that do not support them
#7724 Parser should support parsing pi() function
#7725 Support parsing unknown, parameterless functions
#7731 DAO methods do not profit from reflection cache when Settings.returnRecordToPojo = true
#7732 XJC generated classes should compare Pattern.pattern() in generated equals() and hashCode() methods
#7735 XJC generated classes should generate XmlElementWrapper element for Lists
#7741 Unclear code example in 'Sequence and serials' doc
#7742 Potential NullPointerException in custom Converter when running INSERT statement
#7761 JZ0NK: Generated keys are not available in Sybase ASE when calling UpdatableRecord.store() on a table without identity
#7764 Race condition in cached ImmutablePOJOMapperWithParameterNames
#7765 [#7764] Race condition in DefaultRecordMapper
#7767 DDLDatabase scripts path wild cards do not work correctly
#7769 Parser cannot parse MySQL's DEFAULT CHARSET clause
#7771 DDLDatabase should ignore storage clauses
#7785 Column pg_prog.proisagg does not exist in PostgreSQL 11
#7811 Array types cannot change nullability when generating DDL
#7813 Error during code generation when using DDLDatabase on a table with a MySQL enum type
#7814 DDLDatabase does not generate enum types when parsing MySQL ENUM syntax
#7816 Implement <includeUniqueKeys/>, <includePrimaryKeys/> and <includeForeignKeys/>
#7824 NPE when generating code for an index whose column(s) are not generated
#7827 InformationSchema.toString() methods generate empty <comment> elements
#7830 Manual section about CRUD should not display an N+1 example
#7834 AbstractMeta::get never returns an unqualified result
#7835 name("").append(name("a")) produces wrong result
#7846 Document the fact that <forcedType/> converters can be Java code
#7853 Code generator fails to parse partial index when using DDLDatabase
#7861 Oracle 18c ALL_ARGUMENTS.DATA_LEVEL no longer lists nested data types
#7864 Misleading example about bindings in manual
#7867 DSLContext.fetchCount(Select) should rename the select statement's column names to prevent ambiguities
#7878 Single element array expressions must generate trailing comma in H2
#7886 Parser doesn't correctly recognise Oracle MINUS operation
#7889 Typo in manual reading SQLiteDatabaes
#7892 Missing information_schema.routines table error when running code generator on CockroachDB
#7893 Invalid javadoc created for deprecated data types
#7894 [#7893] Generate valid javadoc for deprecated data types
#7908 Add documentation about UPDATE .. FROM
#7918 Bad formatting of constraints in CREATE TABLE statements
#7920 Missing implementation of AbstractRecord.formatCSV()
#7923 jOOQ checker fails with InternalUtils.symbol: tree is null error when checked code has no enclosing method
#7926 jOOQ-checker does not type check in absence of Require annotation
#7929 jOOQ-checker should not allow any jOOQ API usage in the absence of an Allow annotation
#7930 Missing Support annotation on various DSL.val(), value(), inline() overloads
#7937 Documentation examples using jOOQ with JPA show wrong Query.getParams() usage
#7938 Incorrect Javadoc entry for Field#containsIgnoreCase
#7939 Fix Javadoc entry for Field#containsIgnoreCase
#7942 Excess SELECT statement run on UpdatableRecord.store(), insert(), update() on MySQL
#7950 Illegal reflective access operation on JDK 11
#7959 Internal CursorResultSet does not implement JDBC 4.1 and 4.2 methods
#7961 CREATE INDEX IF NOT EXISTS should intercept error code 1913 in SQL Server
#7968 Document behaviour of unnamed expressions in the SELECT clause
#7982 Unnecessary alias generation in parser for derived tables
#7986 Significant time spent in OffsetDateTime.parse() when reading OffsetDateTime fields
#7991 NullPointerException in QueryPartList.removeNulls with Java 11 and immutable collections
#8006 INSERT .. RETURNING produces records with wrong attached Configuration
#8011 DDLDatabase cannot handle tables containing COLLATE clauses
#8013 Regression in OffsetDateTime parser when PostgreSQL timestamps have fractional seconds of 1, 2, 4, 5 digit precision
#8017 Oracle TIMESTAMP WITH TIME ZONE default binding truncates microseconds
#8024 Missing ORACLE Support on DSL.offsetDateTime() overload
#8026 Wrong SQL generated when H2 OffsetDateTime values are inlined
#8035 PostgreSQL DateAdd doesn't work correctly with LocalDate
#8037 DSL.localDate() and DSL.localTime() don't work correctly on SQLite
#8040 Avoid unnecessary loop in Fields.indexOf()
#8044 Code generation fails on JDK9+ with javax.xml.bind.UnmarshalException: unexpected element when using external <configurationFile/>
#8047 Error Importing Sakila database in Oracle Express 11g
#8048 CustomQueryPart manual section should explain how to implement accept()
#8063 Bad inlining of Double.NaN in HSQLDB
#8065 HSQLDB implementation of Field.add(Interval) cannot handle fractional seconds
#8067 Code generator doesn't generate length on VARCHAR(n) ARRAY types
#8070 Cannot create tables with VARCHAR(n) ARRAY types in HSQLDB
#8072 Code generator fails on PostgreSQL 9.3.9 because of unsupported not in predicate on row value expressions
#8086 Resolve relative paths in target directory in Maven plugin
#8096 Manual page about ParserCLI uses wrong classpath
#8110 Embedded UNIQUE INDEX specification in CREATE TABLE statement does not get generated
#8113 Cannot call MockStatement.getGeneratedKeys()
#8116 XMLDatabase should not distinguish between empty catalog and absent catalog
#8118 NullPointerException in XMLDatabase, when no schemas could be loaded
#8123 java.lang.ClassCastException: java.base/java.lang.String cannot be cast to java.base/java.util.UUID when using UUID types with MockFileDatabase
#8125 Incorrect implementation of MockFileDatabase.nullLiteral()
#8128 returningResult() returns generated record type when returning only the identity
#8131 ClassCastException in H2 when calling returningResult() to fetch an identity when the generated record does not implement Record1
#8143 java.lang.NoSuchMethodException when calling setBinaryDouble on org.jboss.jca.adapters.jdbc.WrappedStatement
#8149 No-arg DefaultConfiguration.derive() does not correctly derive
#8150 DefaultConfiguration is missing some JavaBeans setters
#8151 ClassCastException in ClobBinding when ConnectionProvider provides wrapped Connection
#8156 Wrong Javadoc on LoaderOptionsStep.onDuplicateKeyUpdate()
#8158 ORA-38104 when using ON DUPLICATE KEY UPDATE in Oracle
#8172 Document <includeIndexes/> in the manual
#8178 DefaultOffsetDateTimeBinding fails when year field is negative
#8181 Timezone Offset parser doesn't correctly parse offset seconds
#8197 Row[N].isDistinctFrom(T1, ..., TN) and others do not work correctly when passing null values
#8203 ORA-01745 executing a SELECT FROM WHERE column IN (large collection)
#8210 Fix a variety of compiler warnings when building jOOQ
#8221 StringIndexOutOfBoundsException when parsing a PostgreSQL TIMESTAMPTZ with microseconds precision
#8222 Resolves 8221: StringIndexOutOfBoundsException parsing PSQL Timestamp
#8241 Wrong results from field when forcedType references both converter and binding
#8243 Spelling in CONTRIBUTING.md
#8244 Outdated Javadoc on WindowDefinition referring WINDOW clause support
#8251 Documentation references inexistent org.util package
#8265 ParamType not supported: FORCE_INDEXED when calling Query.getSQL()
#8270 Wrong foreign key specification generated in MySQL, when foreign key shares name with unique key in different table
#8279 Emulate inline window specifications based on other window definitions in SQLite
#8281 PDF manual is missing content contained in tags
#8287 Change message "Please report this bug here" for cases which are not bugs
#8293 Wrong Javadoc on SelectQuery.addHaving(Operator, Condition...)
#8295 RenderKeywordStyle.PASCAL doesn't work when keywords contain whitespace
#8328 { UPDATE | DELETE } .. LIMIT isn't emulated correctly in the absence of unique key meta information
#8329 Lacking formatting for WITH [ NO ] DATA clause
#8332 Wrong documentation for forceIntegerTypesOnZeroScaleDecimals
#8336 DDLDatabase cannot load relative paths in Maven modules that do not contain wildcards
#8338 Redundant QualifiedField.name and AbstractNamed.name fields
#8339 RemovingPrefixMapper is not implemented correctly
#8342 Array of enums whose literals contain special characters cannot be bound in PostgreSQL
#8350 Parser parses (a, b) IS NULL as (a, b) IS NOT NULL
#8355 NullPointerException on Routine.toString() when routine is not attached to a Configuration
#8361 Cache Patterns in MatcherStrategy
#8363 Slow check for similar generated files that differ by case
#8368 Compilation errors in generated code for DB2 overloaded procedures
#8372 DB2 array types get generated as routines
#8375 DB2 array types get generated as UDTRecord types
#8393 Replace static field references in manual by instance references
#8394 Manual CAST() example shouldn't reference PostgresDataType.TEXT
#8397 Parser doesn't recognise BOOL data type
#8401 Add support for parsing REGEXP, RLIKE, and LIKE_REGEX operator
#8402 Bad SQL generated when setting data type and nullability in PostgreSQL's ALTER TABLE .. ALTER .. SET statement
#8413 Rollback should not be called when TransactionListener.commitEnd() throws exception
#8414 Don't emulate empty ORDER BY clause in H2's ROW_NUMBER() function
#8417 Syntax error when generating code on Informix 12.10 without DELIMIDENT=y
#8423 Typo in manual example code for dynamic SQL
#8429 Field.endsWith() and similar methods should escape argument lazily
#8454 <inputSchema/> doesn't work on Informix code generation
#8456 Calling Record.get(0, int.class) returns null if value is not convertible to int
#8460 Regression calling POJO setters twice from DefaultRecordMapper.MutablePOJOMapper
#8468 DataTypeException when org.jooq.Meta accesses PostgreSQL array column with default expression
#8478 ERROR: conflicting ColumnTypes while executing meta query on CockroachDB
#8484 3.11 vs. 3.12 version mismatches between Constants.java and XSD files
#8488 Manual page about matcher strategies should use "see MatcherRule", not "--> MatcherRule"
#8489 Overrides of AbstractTable#fieldsRow() in Scala don't work due to compiler bug
#8491 Remove unnecessary marker tokens in source code
#8493 Support JSR 310 types as <name/> in <forcedType/> data type rewriting feature
#8496 Regression in DefaultRecordMapper, calling matching setter for JPA annotated getter
#8503 Make SET clause in ON DUPLICATE KEY UPDATE optional in parser
#8511 Update SQLite identifier list in DefaultRenderContext#SQLITE_KEYWORDS
#8512 JPADatabase may not be able to properly detect AttributeConverter
#8513 Generator may fail with NPE for CUBRID enums with some <forcedType> definitions
#8515 InsertOnConflictWhereStep#where() should return InsertOnConflictConditionStep
#8527 MiniJAXB#append() doesn't work for enum types
#8531 Wrong Context.subqueryLevel() when emulating derived column lists
#8535 Generate @UniqueConstraint annotation instead of @Column(unique = true)
#8536 Missing constraint name in generated @UniqueConstraint annotation
#8537 Parsing CREATE SEQUENCE always leads to quoted sequence names
#8544 ExecuteListener#end() not last lifecycle event when using DSLContext#fetchOne()
#8550 Improve formatting of generated table-level JPA annotations
#8557 StackOverflowError when using same query instance on both sides of a set operation
#8561 Wrong cast generated for Informix and others when casting a LocalDateTime value
#8570 Wrong Javadoc on Record.setValue()
#8572 Add parser support for RATIO_TO_REPORT
#8573 Outdated Javadoc on ExecuteType.DDL
#8578 DefaultRecordMapper cannot map into generic type variable in Kotlin
#8581 Generator can fail picking up default values using SQLite 3.27.2.1 driver
#8582 MySQLDSL should support Aurora MySQL
#8584 SQLiteDatabase#loadPrimaryKeys() should use DSLContext#fetch(String, Object...)
#8593 DB2 ranking functions require an ORDER BY clause
#8603 DB2 CREATE TABLE IF EXISTS emulation should ignore SQLState 42710, not 42704
#8606 Bad SQL generated when writing multi row insert query with unknown column names (plain SQL table)
#8615 Missing NOTICE file from commons-lang
#8625 Missing DB2 dialect versions in SelectQueryImpl#WRAP_EXP_BODY_IN_DERIVED_TABLE
#8627 Some Support annotation mismatches between DSLContext and DSL methods
#8634 MySQL does not support DROP INDEX IF EXISTS
#8636 Missing PlainSQL annotations on some API
#8637 Support annotation mismatch between overloaded methods
#8645 Sakila/PostgreSQL: Replace nonexisting IF with CASE
#8686 jOOQ generation tool produces Vertica composite unique key columns in wrong order
#8691 Serialization fails when table contains SQLDataType.INSTANT columns or when using Converter.ofNullable() converters
#8694 Floor switch inconsistent wrt SQL dialects
#8697 Add missing MySQL dialects to switch in MD5#getFunction0()
#8698 Sign switch inconsistent wrt SQL dialects
#8699 Trim switch inconsistent wrt SQL dialects
#8700 No foreign key information generated in Vertica
#8701 Code generator produces empty strings as default expressions in Vertica
#8706 Error when translating a query with OFFSET only (no LIMIT) to Vertica
#8707 FunctionTable switch inconsistent wrt SQL dialects
#8708 Ranking functions without ORDER BY are not correctly emulated in Vertica
#8709 Work around Vertica's incorrect IS NOT NULL implementation
#8717 Support parsing SQL Server's UNIQUEIDENTIFIER data type
#8723 Wrong SQL generated when using qualified index references with H2 CREATE or DROP INDEX statements
#8727 Bad Support annotation on Row[N].op(QuantifiedSelect)
#8729 Translator loses quoted names
#8730 DSL#localDateTime(LocalDateTime) drops fractional seconds on SQLite
#8737 SQLite: Date arithmetic does not support fractional seconds
#8756 DSL.timestampAdd() produces wrong cast for teradata
#8758 Parse DEFAULT keyword in UPDATE
#8761 Fix missing Support annotations for Teradata
#8777 Formattable String formatCSV(boolean header, char delimiter) header value is always ignored
#8785 Remove DSL#alterIndex() support for TERADATA
#8786 Remove execution time from logging output in manual
#8791 Remove AlterTableStep#alter() support for TERADATA
#8806 Parser doesn't correctly parse identifiers that can conflict with keywords
#8808 Compilation error in generated code when sequence has the same name as its containing schema
#8810 Emulated ENUM types produce check constraint with bind variables
#8815 Add missing Javadoc to Configuration.visitListenerProviders()
#8817 Remove unnecessary {@inheritDoc} Javadoc tags in jOOQ's internals
#8820 Bad SQL generated in PostgreSQL when calling nextval on a sequence with apostrophes in its name
#8832 Wrong rendering of Oracle's CREATE SEQUENCE `NO` clauses
#8835 No ALTER SCHEMA ... IF EXISTS clause in Postgres
#8836 Correct CreateSequenceFlagsStep#noCache() for Postgres
#8859 Generator does not generate anything for schemas only containing sequences
#8862 Manual code doesn't compile for derived table and correlated subquery examples
#8876 Bad example in CSV import manual section
#8891 Bad code generated when an Oracle table valued function name exists both as a standalone function and as a package function
#8897 INSERT .. RETURNING emulation doesn't work on Oracle for single row inserts when returning expressions
#8898 INSERT .. RETURNING emulation doesn't work on Oracle when returned columns are aliased
#8902 Add missing Support annotation to DSL.collation
#8904 Add Support annotations to DSL.name() and DSL.keyword()
#8908 Statements ignored by the parser do not implement QueryPartInternal
#8910 Parse pg_catalog.set_config('search_path') as SET SCHEMA in DDLDatabase
#8913 TeradataDataType is missing type mapping for SQLDataType.UUID
#8915 COMMENT ON VIEW doesn't work on SQL Server
#8921 Wrong Support annotation on UpdateReturningStep and DeleteReturningStep methods
#8929 DAOImpl should short circuit Result.map(RecordMapper) calls
#8931 Oracle doesn't support asterisks in the RETURNING clause
#8933 DSL.unnest(Collection) doesn't work on PostgreSQL
#8954 NPE in code generator when generating Oracle UDTs
#8956 Document <includePrimaryKeys/> as being a flag influencing generated records
#8957 Parser.parseStatements() fails to parse empty block
#8960 DELETE .. LIMIT 1 generates a bind variable even if input is inlined
#8961 Parser doesn't support bind variables in LIMIT clauses
#8964 Bulk insert of BigDecimals with different scale get truncated to first rows scale
#8978 Make generatePojoMultiConstructor in JavaGenerator protected
#8979 Dead links for generator strategy examples
#8984 Potential NumberFormatException in FilenameComparator
#8993 NullPointerException when JDBC driver returns null on getGeneratedKeys call using ZDAL5 driver on MySQL
#9014 Fix typo in documentation
#9024 ExecuteListener documentation typo
#9028 Translated sequence flags in CREATE SEQUENCE statement get turned into bind variables
#9034 JDBCUtils.driver(String) returns deprecated "com.mysql.jdbc.Driver"
#9041 Manual typo: "catlogs"
#9049 Stop shipping the Sakila database over the zip files downloaded from the website
#9052 Some dead internal links in old manual versions
#9059 DSLContext.ddl(Catalog) does not correctly create cross schema foreign key constraints.
#9065 Parser does not support NVARCHAR2
#9072 Remove outdated information in manual's logging section
#9073 Manual section about custom query parts should not document internal API
#9088 Pro Oracle oracleTSTZ doesn't unwrap connection from pool prior to TZ constructor
#9090 CREATE TABLE fails with ParseWithMetaLookups.THROW_ON_FAILURE

New in jOOQ 3.11.12 (Aug 16, 2019)

New in jOOQ 3.11.11 (Apr 9, 2019)

New in jOOQ 3.11.10 (Mar 7, 2019)

New in jOOQ 3.11.9 (Jan 4, 2019)

New in jOOQ 3.11.8 (Dec 24, 2018)

New in jOOQ 3.11.7 (Nov 5, 2018)

New in jOOQ 3.11.6 (Nov 3, 2018)

New in jOOQ 3.11.5 (Sep 13, 2018)

New in jOOQ 3.11.4 (Aug 9, 2018)

New in jOOQ 3.11.3 (Aug 9, 2018)

New in jOOQ 3.11.2 (Jun 26, 2018)

New in jOOQ 3.11.1 (Jun 19, 2018)

New in jOOQ 3.10.7 (May 4, 2018)

New in jOOQ 3.10.6 (Mar 21, 2018)

New in jOOQ 3.10.5 (Feb 15, 2018)

New in jOOQ 3.10.4 (Jan 17, 2018)

New in jOOQ 3.10.3 (Jan 17, 2018)

New in jOOQ 3.10.2 (Nov 29, 2017)

Features and Improvements:
#6782 Clarify DSL.currentDate() Javadoc: It creates ANSI SQL DATE values, not Oracle DATE
#6784 Add explicit unit of time specification to Query.queryTimeout()
#6810 Provide maven-deploy script to install artifacts on remote repository
Bug Fixes:
#6682 Typo in ResultQuery Javadoc: thorws should be throws
#6685 Avoid creating a new DefaultConfiguration in DSLContext.select() and similar methods
#6687 Avoid allocation of CursorImpl.intern array
#6692 Prevent calling DSL.name() with empty arguments
#6697 Remove the DATA_LOCALLY_SCOPED_DATA_MAP in SelectQueryImpl
#6700 DSL.trueCondition() and DSL.falseCondition() should return constants
#6710 Parser.parse() fails on trailing whitespace
#6711 Avoid generating code with a redundant (Object) cast
#6713 Redundant Javadoc generated when deprecation for unknown types is generated
#6716 PostgreSQL RETURNING <col> AS <alias> is not rendered correctly
#6731 Typo in Cursor.fetchOne() Javadoc's deprecation hint
#6738 jooq-runtime-3.10.0 lists wrong version in namespace
#6743 Oracle OBJECT type declarations inside generated RECORD declarations are not bound correctly, if NULL
#6748 Avoid allocating a fresh "ExecuteListeners" instance in the absence of actual ExecuteListeners
#6750 Avoid adding the LoggerListener if the log level is more than DEBUG
#6753 Avoid various array allocations due to unnecessary varargs
#6756 Avoid unnecessary UnqualifiedName[] allocations in QualifiedField etc.
#6759 Avoid allocation of AbstractContext.visitListeners if unneeded
#6775 Improve MockDataProvider Javadoc about null or empty return values
#6780 Oracle's quoted string literals start with case-insensitive Q letter
#6786 Result.format() breaks when there is a tabulator in the content
#6788 Inefficient ProxyMapper allocates a new MutablePOJOMapper delegate every time
#6791 ConvertAll inefficiently unboxes and boxes primitive types
#6801 Optimise internal reflection cache by avoiding cache key arrays where possible
#6805 Override equals() and hashCode() in org.jooq.impl.Fields
#6808 Improve DefaultRecordMapper::init MappingException message
#6828 Error when passing java.util.Date to DSL.year(), month(), day(), hour(), minute(), second()
#6830 DayToSecond generates nanosecond precision for DAY_MICROSECOND interval
#6842 MockResultSet.getTimestamp(int, Calendar) ignores Calendar
#6844 SQLDataType.INTEGER.identity(true) not working for SQLLite
#6846 <deprecationOnUnknownTypes/> has no effect
#6848 Code generator doesn't work when Derby database uses non-standard collation
#6858 SQLiteTableDefinition.toString() prints "." after empty schema
#6869 Code generator doesn't work in Java 6 build, which calls java.lang.reflect.Method.getParameterCount()

New in jOOQ 3.10.1 (Oct 18, 2017)

New in jOOQ 3.10.0 (Oct 2, 2017)

Formal Java 9 Support:
JOOQ 3.10 is the first release that is formally integration tested with Java 9 along with the existing integration tests for Java 6/7 and for Java 8. To use jOOQ with Java 9 use the Java 8 distribution which has not yet been modularised, but contains Automatic-Module-Name specification to be forward compatible with future, modularised jOOQ distributions.
Cross release for Scala 2.10, 2.11, 2.12:
We've been offering cross releases for Java 6/7 and Java 8 in the past and we're now doing the same for Scala. In jOOQ 3.10, Scala 2.11+ will be supported by the jOOQ Open Source Edition and Scala 2.10+ by the commercial editions.
More and better stored procedure support for Oracle and SQL Server:
We've finally supported SQL Server's table-valued parameters (TVP), which are a great way of passing data sets to procedures in SQL Server.
In Oracle, we're now supporting a variety of cool PL/SQL features that are not supported directly by ojdbc.
Some of these features are:
UPDATE RETURNING and DELETE RETURNING
Oracle 12c implicit result sets
PL/SQL RECORD Types passed to and returned from stored procedures
PL/SQL %ROWTYPE references
SYS_REFCURSOR IN parameters (we have always supported them as OUT parameters)
Combinations of PL/SQL BOOLEAN and PL/SQL RECORD types
We believe that those excellent T-SQL and PL/SQL features would be used much more often by Java developers, if the serialisation was made easier. That's why jOOQ 3.10 greatly helps here.
New parser now fully supported:
In jOOQ 3.9, we've introduced an interesting new feature that will allow jOOQ to be used in non-classic jOOQ contexts, e.g. as a JDBC proxy to translate SQL from dialect to dialect, or as a formatting tool.
Users who have been using jOOQ's plain SQL API will be happy to hear that using the parser, they will be able to validate their plain SQL already in the client, and possibly normalise / transform it using the entire jOOQ tool chain including the VisitListener SPI.
One immediate benefit of having a parser is the new DDLDatabase, which can reverse engineer your DDL scripts to generate jOOQ code out of them, without any connection to a database!
Support for index types:
While we've supported DDL operations to create / drop indexes for a while, we haven't supported indexes in our meta model. We finally do with jOOQ 3.10.
They can now be used:
In code generation output
As plain SQL meta objects
As InformationSchema import / exports
And much more
Other great improvements:
We're now supporting MySQL 8.0 and its WITH clause and window functions.
Support for the SQL Server 2016 dialect
Better support for PostgreSQL's ON CONFLICT clause
Support for FETCH .. WITH TIES: Native and emulated using RANK() OVER (...)
More improvements for JSR-310 type support
Many improvements to the org.jooq.Name API for manipulating qualified names
More DDL support and emulations for DB2, Oracle, and SQL Server
Many improvements to the org.jooq.Queries API (batches of org.jooq.Query)
A new RecordUnmapper SPI - the inverse of the existing RecordMapper
Record unstructuring in Kotlin
Results can now be formatted as ASCII charts
Features and Improvements:
#1735 Add Setting to indicate that bind values should not be cast
#2520 Add RecordUnmapper<E, R extends Record> to allow for the inverse operations of RecordMapper
#2830 Add JavaDoc on Settings classes
#3062 Add support for conversion into Collection types
#3593 Add support for packages and routines in XMLDatabase
#4111 Cross-release several jooq-scala deliverables
#4846 Add <orderProvider/> SPI to allow for injecting meta data ordering
#4900 Add support for LIMIT .. WITH TIES
#4990 Deprecate Context.keyword() and Context.literal()
#5149 Pull up AttachableInternal.configuration() to Attachable. Remove AttachableInternal
#5171 Support SQL Server table valued parameters
#5189 Generate synthetic ArrayRecord and UDTs for SQL Server table types
#5191 Support multi-row UPDATE and DELETE RETURNING for Oracle using PL/SQL RETURNING .. BULK COLLECT INTO
#5231 Add a subsection to the manual explaining each setting from the Settings.xml
#5361 Add ResultQuery.fetchStreamInto()
#5411 Add support for ResultQuery.fetchSingle(), which returns exactly one record
#5493 [#2123] Combining INSERT..RETURNING and ON DUPLICATE KEY
#5551 Add support for MySQL 8.0 CTE
#5552 Add a MySQL 8 SQLDialect version
#5568 #3062 Work on adding ability to convert between collections and arrays.
#5619 Add Field.containsIgnoreCase() to support Postgres' ILIKE operator
#5637 Add support for PostgreSQL ON CONFLICT DO UPDATE WHERE
#5638 Add org.jooq.Index
#5645 Add DSL.localDateAdd() localDateSub(), localDateDiff()
#5666 Add support for Oracle 12c implicit result sets returned from procedures
#5667 Review jOOQ's reflection usage for JDK 9 / Jigsaw compatibility
#5724 Add support for MySQL's ALTER TABLE .. RENAME INDEX
#5732 Emulate { ALTER | DROP } .. IF EXISTS in Oracle using a PL/SQL block
#5733 Add a configuration option for varargs setters
#5738 Add DSLContext.parsingConnection() to expose the new Parser API through the JDBC API
#5742 Stop distributing third party dependencies through zip distribution
#5745 Make JDBC driver configuration optional in code generator configuration
#5746 The <database/> element in the code generator configuration should be optional
#5747 Mention JPADatabase in jooq-codegen.xsd
#5750 Deprecate and undocument the <customTypes/> element
#5754 Remove copyright (and dates) from file headers
#5762 Add DataType.getSQLType(Configuration)
#5764 Add support for inlining SQL Server table valued parameters in SQL
#5767 Add a comment to the manual's section about MatcherRules regarding unqualified / qualified identifier matching
#5770 Add Field.notContains()
#5772 Implement Converter.toString() of Converter.of() and ofNullable() results
#5790 Add Setting.returnRecordToPojo to disable copying record values back into inserted / updated POJOs
#5791 Implement DefaultRecordContext.toString()
#5806 Add support for H2's TIMESTAMP WITH TIME ZONE data type
#5809 Add code generation support for %ROWTYPE references in Oracle
#5823 Add native support for HSQLDB UUID type
#5824 Add Convert support for converting UUID to byte[] and vice versa
#5826 Add Settings.delimiter to specify the standard delimiter for batches
#5828 Add Queries.fetchMany()
#5829 Enhance jooq-meta.xsd to include INFORMATION_SCHEMA.ROUTINES and PARAMETERS dictionary views
#5833 Add support for routines in XMLGenerator
#5834 Improve formatting of multi-argument named parameter procedure calls
#5850 Add support for Oracle SYS_REFCURSOR IN parameters
#5853 Add XMLFormat, an XML export / import formatting configuration
#5854 Support indented XML output in formatXML()
#5862 Rename Generator.fluentSetters() to Generator.generateFluentSetters() for API naming consistency
#5877 Add <enumConverter/> flag in <forcedType/> to auto-generate EnumConverter
#5878 Add DelegatingConverter<T, U>
#5884 Allow for specifying Java expressions as Converter / Binding configurations
#5885 Document the fact that only the first matching <forcedType/> is a applied to a data type definition
#5894 Add Record.formatXML(), formatJSON()
#5904 Improve Javadoc on ExecuteContext.rows()
#5920 Add several Binding.of() convenience constructors
#5924 Add the Table.fullJoin() and SelectJoinStep.fullJoin() aliases
#5927 Undeprecate Parser
#5942 [5619] Add Field.containsIgnoreCase() to support Postgres' ILIKE operator
#5947 Add TypedElementDefinition.getDefinedType()
#5956 Add DSL.{rank|denseRank|percentRank|cumeDist}(Collection<? extends Field<?>>)
#5968 Add JavaGenerator.printPackageComment() to allow for overriding this
#5973 Allow for formatting / indenting JSON output through JSONFormat
#5987 Add DSLContext.map(Schema) and map(Table) to expose the schema mapping feature
#5993 Add Name DSL.quotedName() and unquotedName()
#5995 Add Context.quote()
#5996 Add Field.as(Name) and Table.as(Name), Table.as(Name, Name...)
#5997 Field.as(Field) and Table.as(Table) should retain quotation flag from Name
#5998 Add DSL.name(Name...) to construct a Name from Name.last() elements
#6000 Add TableImpl.rename(Name)
#6005 Add DDLDatabase to reverse engineer DDL files
#6006 Add DSL.primaryKey(Name...), unique(Name...), foreignKey(Name...)
#6009 Add support for CREATE INDEX ON with on(Name, Name...) arguments
#6011 Add better documentation for the JPADatabase
#6012 Implement specialised Name for unqualified Names
#6013 Add Name Name.qualifier()
#6014 Implement QualifiedTable.getSchema() and QualifiedSchema.getCatalog()
#6021 Add DSLContext.with(Name, Name...)
#6022 Add Name.fields(Name, ...)
#6035 Detect third-party JDBC URL plugins in JDBCUtils
#6044 Add DSLContext.currval(Name) and nextval(Name)
#6052 Create an internal Keyword cache
#6053 KeywordImpl should cache the AS_IS, UPPER, LOWER renderings
#6056 Upgrade optional logger dependencies
#6063 Use eq / ne / etc in manual, rather than equal / notEqual / etc
#6068 Add Name { Field | Table | Schema | Catalog }.getQualifiedName()
#6070 Add Name Name.unqualifiedName()
#6072 Add code generation flag <recordsImplementingRecordN/> to configure whether generated Records should implement Record[N]
#6073 Add Name[] Name.parts()
#6074 Implement QueriesImpl.equals() and hashCode()
#6079 Add JoinType.qualified()
#6082 DSL.condition(Field) and field(Condition) should unwrap previously wrapped QueryPart
#6084 Let { Update | Delete }ReturningStep extend { Update | Delete }FinalStep
#6086 Add Row Parser.parseRow(String)
#6087 Make ParserException public
#6088 InsertSetStep.select() should return InsertOnDuplicateStep
#6093 Add Field.pow[er](Field)
#6094 Support Oracle's PARTITION BY prefixed OUTER JOIN
#6099 Document Parser's BNF
#6104 Improve VALUES constructor formatting
#6105 Add Name { Field | Table | Schema | Catalog }.getUnqualifiedName()
#6108 Add PostgresDSL.arrayOverlap()
#6114 [#6063] change Field.equal() and Field.notEqual() to Field.eq() and Field.ne() in manual pages
#6120 Add support for DB2 RENAME INDEX statement
#6121 Add support for DB2 RENAME TABLE statement
#6123 Emulate CREATE TABLE AS for DB2 using CREATE TABLE and INSERT
#6125 Support different DB2 sqlstates when emulating IF NOT EXISTS
#6128 Add more Javadoc to JPADatabase
#6136 [#6022] add Name.fields(Name...) method along with the generated ones
#6139 Put XJC generated sources under version control
#6143 Rename Queries.stream() to Queries.queryStream()
#6144 Let Queries extend QueryPart
#6146 Add DSLContext.queries(Query...)
#6147 Let Queries extend Attachable
#6148 Add Queries.executeBatch()
#6154 Remove test dependencies from OSS distribution
#6155 Remove unneeded javax.validation dependency
#6156 Add Configuration.recordUnmapperProvider()
#6162 Deprecate plain SQL DSL.sequence(String) constructors
#6167 GenerationTool should debug-log input Configuration as XML
#6169 Document exception propagation in transaction API Javadoc
#6194 Add a section to the manual about the Query By Example API
#6195 Add DSLContext.fetchByExample(TableRecord)
#6196 Override Iterable.forEach(Consumer) in ResultQuery to provide Javadoc
#6212 Generate deprecation for all objects referencing DataType<Object> (unknown type)
#6214 Pull up jOOQ-meta's AbstractDatabase.getProperties() to Database
#6215 Add localDateAdd() localDateSub(), localDateDiff() support to DSL
#6217 Add more details to QueryPart.toString() Javadoc
#6218 Add a section to the manual about the plain SQL templating part
#6219 Add Parser.parseResultQuery()
#6222 Generate IDENTITY information on data type
#6239 Add SQLServer2016 dialect
#6245 Add Record[N].component[1-N]() methods for better Kotlin interoperability
#6246 Add Kotlin operators on Field
#6247 Add more Kotlin examples
#6253 Add a jOOQ / JPA example to GitHub
#6254 Deprecate the ResultQuery.intern() and Result.intern() features
#6255 Add better Enum to Enum conversion support in org.jooq.tools.Convert
#6258 Emulate MySQL / T-SQL DROP INDEX .. ON for other databases
#6268 Support DROP SCHEMA IF EXISTS for SQL Server
#6269 Support CREATE SCHEMA IF NOT EXISTS in SQL Server
#6271 Improve onKey() join error messages, when join expression is ambiguous
#6273 Document <configurationFile/> Maven plugin property
#6275 Add SQL Server support for ALTER VIEW .. RENAME
#6276 Add SQL Server support for ALTER TABLE IF EXISTS
#6280 Deprecate DSLContext.bindContext() and renderContext()
#6281 Add DSL.arrayAggDistinct()
#6285 Add Javadoc to code generator Configuration classes
#6287 Upgrade Spring Boot example to version 1.5.3
#6296 Update Hibernate Dependency in jooq-meta-extensions and examples
#6297 Add "development versions" link to the manual
#6299 Remove unneeded config files in spring-boot-example
#6300 Remove unneeded config files in spring-boot-example
#6304 Improve internal TableAlias discovery
#6306 Add org.jooq.True and org.jooq.False
#6307 Add code generation support for indexes
#6312 Document DISTINCT predicate emulation using INTERSECT
#6313 Add List<Index> Table.getIndexes()
#6315 Add SortField Field.sortDefault()
#6319 Add INDEXES and INDEX_COLUMN_USAGES views to jooq-meta.xsd
#6320 Import / Export index information with DSLContext.meta(InformationSchema) / DSLContext.informationSchema()
#6321 Export indexes using XMLGenerator
#6322 Import indexes using XMLDatabase
#6323 Generate javax.persistence.Index annotation
#6325 Add ResultQuery.fetchGroups(Field[], Field[]) and similar overloads
#6336 Add another Kotlin example using apply
#6352 Add Result.formatChart() to produce ASCII text charts
#6355 Improve Kotlin example in manual
#6362 Auto-wrap Select as Field in overloaded API like DSL.least()
#6363 Rename Cursor.fetchXXX() methods to fetchNextXXX()
#6368 Port Sakila database to DB2
#6372 Add DSLContext Configuration.dsl()
#6374 In jOOQ-spring-boot-example, use jooq starter instead of jdbc starter
#6381 Add Derby support for RENAME { TABLE | COLUMN | INDEX }
#6386 Add Scope.dsl()
#6391 Add ResultOrRows.exception() to improve support for SQL Server's RAISERROR
#6410 Don't generate empty Keys.java or Indexes.java files
#6411 Code generator should generate VARCHAR(length) and NUMBER(precision, scale) method
#6413 Add Setting.throwExceptions to define how SQLException should be propagated out of jOOQ
#6416 Add Name.unquotedName() and Name.quotedName()
#6418 Change SQLite's VALUES constructor implementation to support standard multi-row VALUES() clause
#6422 Add support for MySQL 8.0 window functions
#6426 Add support for MySQL 8.0 FOR UPDATE { NOWAIT | SKIP LOCKED }
#6427 Deprecate partitionByOne() API
#6428 Add missing overload WindowPartitionByStep.partitionBy(Collection<? extends Field<?>>)
#6430 Add support for MySQL 8.0 FOR UPDATE OF [ tables ]
#6434 Enhance "Forcing type" INFO message with the full <forcedType/> specification
#6441 Improve TableLike.field(Field) Javadoc
#6443 Explain in TooManyRowsException Javadoc that the exception has no impact on the statement causing it
#6445 Allow for overriding timestamps used for optimistic locking
#6447 Add Clock Configuration.clock()
#6451 Add a JdbcTemplate example to the manual
#6463 Add bind variable capability to Parser API
#6465 Add no-args constructor to some exceptions
#6466 Support fetching HSQLDB arrays from plain SQL results
#6468 Add DSLContext.fetchSingle() to return exactly one record
#6471 Improve manual section about LOBs
#6472 Add support for ALTER TABLE .. ALTER COLUMN .. { SET | DROP } NOT NULL
#6473 Add DataType.nullable(Nullability) to support a three valued nullable flag
#6487 Add DSL.groupId()
#6488 Add support for Oracle's WIDTH_BUCKET() function
#6517 JPADatabase should map JPA AttributeConverter types to generated jOOQ Converter
#6519 Improve JPA example by reusing a JPA AttributeConverter in jOOQ
#6522 Add JPAConverter to bridge between Converter and JPA's AttributeConverter
#6525 Add Setting for formatting options
#6527 Support START WITH .. CONNECT BY (reverse syntax order)
#6530 Add runtime support for procedure calls with top-level %ROWTYPE parameter types in Oracle
#6531 Add support for Oracle OBJECT types nested in PL/SQL RECORD types
#6532 Add UDT.isSynthetic() and UDTDefinition.isSynthetic()
#6533 Add support for PL/SQL BOOLEAN types inside of PL/SQL RECORD types
#6534 Add Name.append(String) and append(Name)
#6545 Support formatting of multi dimensional arrays in Result.format()
#6567 Support using org.jooq.impl.EnumConverter as a <converter> configuration
#6575 Enhance plain SQL templating language documentation with parsing rules
#6584 Improve DSLContext.batchStore() Javadoc, indicating that it does not execute MERGE / UPSERT semantics
#6599 In manual ExecuteListeners example, use ConcurrentHashMap.computeIfAbsent
#6611 Add Automatic-Module-Name to MANIFEST.MF
#6617 Specify <pluginManagement> in parent pom.xml
Breaking changes:
#5734 Bad type mapping for PostgreSQL TIME[STAMP] WITH TIME ZONE and SQL Server DATETIMEOFFSET types
#5818 Plain SQL fetch() methods should return update count in Result
#5921 MockFileDatabase shouldn't trim lines
#5990 Allow for case-sensitive OWNERs in Oracle's code generation
#6020 values(RowN...) columns are named c0, c1, ... c[N-1] instead of c1, c2, ... cN
#6051 Don't include StopWatchListener with Settings.isExecuteLogging()
#6327 Add OrderField as a common super type of Field and SortField and accept that in ORDER BY clauses
#6342 No-args call to Field.sortAsc(), sortDesc() and empty Map call to Field.sortMap() should not return null
#6373 InsertQuery.newRecord() doesn't generate additional record unless values are set
#6388 Relax type constraints on various set(Map<Field<?>, ?>) to set(Map<?, ?>)
#6440 Throw TooManyRowsException in { Insert | Update | Delete }ResultStep.fetchOne() and fetchOptional()
#6521 Upgrade the optional/provided JPA API dependency to 2.2
#6523 JPADatabase, H2Database, and OracleDatabase should not generate any system sequences
#6529 Move generated PL/SQL RECORD types in a udt subpackage
#6613 Add TransactionContext.causeThrowable() to allow for Throwable causes for transaction rollbacks
#6615 Allow for TransactionRunnable and TransactionCallable to throw Throwable
Bug fixes:
#2123 Cannot combine INSERT .. RETURNING with INSERT .. ON DUPLICATE KEY .. due to DSL API flaw
#2738 Bad inlining, setting, and registering of LocalDate, LocalTime, LocalDateTime, OffsetTime, OffsetDateTime bind values
#3704 Emit warning on conflict between <customType/> and type rewriting when <forcedType/> name is "Boolean"
#3805 Emulate ALTER TABLE .. ALTER TYPE .. NULL / NOT NULL with anonymous blocks, where supported
#3823 Regression: Date <-> Timestamp converter ignored after upgrading from 3.4.2 to 3.5
#4402 Bulk insert fails when records have different sets of changed columns
#4629 Support INSERT INTO t VALUES with plain SQL tables
#5213 NullPointerException when generating code in single-uppercase-named-database setup on MariaDB and MySQL
#5299 MySQL enum type doesn't generate correct DDL via DSLContext.ddl()
#5344 SchemaMapping and TableMapping are not applied for table(Name)
#5354 Add <javaBeansGettersAndSetters/> to the code generator to support JavaBeans
#5403 IF EXISTS emulation using THROW doesn't work for SQL Server 2008
#5451 Oracle 12c support for OFFSET .. FETCH causes ORA-00918 regression on queries with ambiguous column names
#5453 Work around Oracle 12c issue with INSERT .. SELECT into tables with IDENTITY column
#5587 Oracle's quoted string literals aren't parsed correctly
#5720 Convert doesn't correctly convert Strings to EnumType
#5735 jOOQ-checker is not deployed to Maven Central
#5744 Log WARN if users combine nested catalog configurations with top-level inputSchema configuration
#5755 Parser cannot parse bind variables
#5763 Generated TableValuedFunction.call() methods should wrap arguments with DSL.val(T, DataType)
#5765 Compilation error in generated schema when table-valued function literal clashes with class name
#5771 MockResultSet should call Converter to transform MockResult's back to <T>
#5776 DefaultBinding cannot parse +HH timezone offset
#5779 DataType.getSQLType() doesn't return the right value for java.time types
#5783 KeepNamesGeneratorStrategy generates wrong Keys.java
#5794 git push tag
#5804 Various Javadoc warnings
#5807 Exception thrown when creating table with SQLDataType.UUID in MySQL
#5812 InformationSchema export contains wrong column name
#5820 Missing @Support annotations for PostgreSQL on InsertOnDuplicateSetStep.set()
#5840 Shouldn't DEBUG log OUT parameters on procedures that don't have any
#5845 ClassNotFoundException occures when generate codes form JPA entity by maven plugin
#5848 [#5845] Use the correct ClassLoader to load the jpa entity classes de…
#5855 Outdated link to jooq-export.xsd in Result.formatXML() Javadoc
#5858 Data loader unable to decode Base64 encoding binary types
#5872 <types/> cannot match user-defined types (e.g. PostGIS GEOMETRY)
#5879 Schema version check does not work with Scala
#5881 NullPointerException when running Maven code generator plugin without <target/> specification
#5886 Manual typo: >U> should be
#5888 <expressions/> deprecation message is logged several times by the code generator
#5890 H2Database orders tables by ID instead of NAME
#5892 File does not get renamed on Windows when TABLE_A is renamed to TABLEA
#5901 Bind variable index should be logged in stack trace when there is a JDBC data type problem
#5922 Parser doesn't accept FULL JOIN
#5929 java.util.impl.Contains should check both sides of the expression for array types
#5936 Ignore strategy/name when strategy/matchers is present, in code generator
#5938 Fix typo in manual's having example java code
#5940 Do not return ID on Record.update() when updatablePrimaryKeys is set to false
#5943 Boolean data type rewrites on Oracle procedures conflict with PL/SQL BOOLEAN data type logic
#5946 Compilation error in generated code when applying converter to Oracle NUMBER procedure parameter
#5954 Support JTDS limit of 2000 bind variables also for SQL Server
#5955 Various parser bugs / missing features
#5967 Improve performance of Result.formatJSON() by avoiding List and Map allocation
#5971 Do not throw UnsupportedOperationException in DefaultResultSet etc
#5979 ArrayIndexOutOfBoundsException when generating DSLContext.ddl() for DefaultSchema
#5981 LIMIT examples in manual are not consistent
#5989 Case insensitive OWNER search in Oracle code generator causes slow execution for large schemas
#5994 DSL.name() Javadoc points to wrong DSL.field() methods
#6007 Bad formatting of CASE WHEN EXISTS expressions
#6019 Wrong SQL generated on Query.toString() on SELECT .. OFFSET (no LIMIT)
#6025 Unstable alias generation for derived tables
#6031 DefaultBinding.pgFromString() doesn't support TIMESTAMP WITH TIME ZONE data type
#6033 Manual documents incorrect restriction on ConnectionProvider.acquire() method
#6034 Param.equals() doesn't work for binary data
#6038 Possible leaking JDBC Arrays in DefaultExecuteContext.ARRAYS
#6042 DefaultBinding should register java.sql.Array for later freeing
#6048 UDTRecordImpl.readSQL(SQLInput) and writeSQL(SQLOutput) optimisations
#6055 NullPointerException thrown when calling Oracle Function with BOOLEAN parameter
#6058 StackOverflowError when DefaultBinding.pgFromString() encounters unknown type
#6064 SQL Server doesn't generate any code when top-level inputSchema is specified, but not inputCatalog
#6065 JOIN .. USING emulation doesn't work with plain SQL
#6069 Bad Javadoc on Catalog.getName()
#6077 Replace usage of String.split() by Pattern.split()
#6078 NullPointerException in GenerationUtil with Postgres CITEXT extension applied
#6081 Jsr310 LocalDateTime fail on batch insert queries but works in standard queries
#6083 Cannot combine INSERT .. DEFAULT VALUES with ON DUPLICATE / ON CONFLICT
#6085 Bad Javadoc on DeleteResultStep
#6103 Excess whitespace in formatted MySQL WITH ROLLUP clause
#6106 Bad formatting when combining constraints in CREATE TABLE statement
#6109 Prefer Java 8 syntax (method references, lambda expressions) in manual example
#6110 Broken code in docs
#6117 DB2 doesn't support qualified column references in FOR UPDATE OF
#6118 RESTRICT is a mandatory keyword in DB2's DROP SCHEMA command
#6122 Fix DDL Support annotations for DB2
#6127 DELETE RETURNING must be emulated on DB2 with OLD TABLE() not FINAL TABLE()
#6129 ConstraintForeignKeyReferencesStepN.references() should return ConstraintForeignKeyOnStep
#6130 Cannot combine ON DELETE and ON UPDATE actions on foreign key specifications
#6141 Add identity column support to XMLGenerator
#6150 Oracle LocalDate bind variables aren't cast to DATE
#6163 XMLGenerator doesn't export <is_nullable/> for columns
#6165 XMLDatabase doesn't correctly load UNIQUE keys
#6171 DefaultTransactionProvider should not roll back to savepoint in top transaction
#6173 Dead link in Oracle examples
#6189 JPADatabase doesn't correctly generate tables for multi-schema entities
#6191 Compilation error in generated code when column is called RESULT or PRIME
#6198 Manual incorrectly refers to term "paging" rather than "pagination"
#6204 PL/SQL Records not generated depending on the order of procedures in a package
#6207 Compatibility issues in Sakila database for SQL Server 2016
#6213 Document XMLGenerator
#6221 DSLContext.ddl() doesn't generate identity correctly
#6223 Field.contains(T) doesn't delegate to Field.contains(Field<T>) when using plain SQL
#6226 NoSuchFieldError when using commercial dialect with open source edition in Maven code generation
#6235 Manual does not correctly order versions > 3.9
#6236 Improve inListPadding implementation
#6238 Typo in AlterTableRenameConstraintToStep Javadoc
#6249 Null batchSQL when running a batch with a single query
#6251 XMLGenerator: UniqueConstraintCatalog set to referenced key instead of catalog
#6267 Missing SQLDialect.SQLSERVER annotation on CREATE SCHEMA and DROP SCHEMA
#6274 Configuration.dialect() should return SQLDialect.DEFAULT when null
#6289 Don't generate type length modifier for PostgreSQL bytea types in DDL
#6292 Improve support for SQL Server date time literals
#6303 Oracle flashback query for aliased table results in invalid sql
#6316 ALTER TABLE .. ADD COLUMN ignores column type's DEFAULT clause
#6329 Clarify in the manual that INSERT .. SET is emulated for all dialects
#6330 Exception thrown when creating table with converted VARCHAR type
#6331 DataType.hasLength(), hasPrecision(), hasScale(), and others should depend on Binding's <T> type
#6332 JPADatabase with GeneratedValue does not account for dialect
#6333 Error when passing java.util.Date to DSL.timestamp()
#6339 Recognise H2 SYSTEM_SEQUENCE in INFORMATION_SCHEMA.COLUMNS.COLUMN_DEFAULT as an Identity column
#6357 Remove outdated section about Oracle not supporting IDENTITY columns
#6367 PostgreSQL enums aren't linked correctly from generated tables when <outputSchemaToDefault/> is true
#6370 Improve misleading MockDataProvider example in the manual
#6375 INSERT .. SELECT .. ON DUPLICATE KEY emulations using MERGE don't work
#6377 Remove outdated jOOQ-codegen-gradle example
#6383 Derby requires RESTRICT on DROP SCHEMA statement
#6390 SQL Server multiple errors are not propagated if an update count precedes them
#6394 SQL Server Sequence.currval() regression
#6395 Definition.getQualifiedName() is wrong when <outputSchemaToDefault/> is set to true
#6399 Spring Boot example should use official documentation recommendation to configure dialect
#6401 Don't generate javax.validation.NotNull for identity columns
#6404 NullPointerException when fetching unnamed nested records in plain SQL with PostgreSQL
#6406 NullPointerException when trying to get mvn help on goal generate
#6423 Compilation error in generated code when both SchemaVersionProvider and CatalogVersionProvider are applied
#6444 Fix some slightly out of date links in README.md
#6453 Code generation regression for <dateAsTimestamp>
#6467 Manual erroneously claims that routine / udt / table / sequence generation cannot be deactivated
#6478 Typo in DSLContext.fetchCount() and error in DSLContext.fetchExists() Javadoc
#6491 Add support for Oracle SYS_REFCURSOR IN OUT parameters
#6493 XMLDatabase doesn't work when dialect is not a SQLDialect.family()
#6495 Update manual's list of supported databases
#6498 "Invalid column index" on Oracle stored procedure call when return type is converted to boolean and argument type is defaulted
#6513 ClobBinding and BlobBinding don't correctly inline their bind values
#6536 Generated deprecation doesn't work on function / procedure convenience methods
#6537 NullPointerException in AbstractRecord.intern0()
#6540 Oracle IDENTITY columns aren't recognised correctly by code generator
#6557 Error in Record.compareTo(...) Javadoc
#6561 Manual section about optimistic locking has invalid code
#6563 Result.formatJSON() does not correctly format array types
#6571 Trigger generated errors are not fetched through jOOQ's plain SQL API
#6574 "A constant expression was encountered in the ORDER BY list" when calling Field.sortAsc() with empty parameter list on SQL Server
#6593 Incorrect handling of Oracle quoted string literals in plain SQL
#6602 Code generation for routines fails on MySQL 8
#6608 Transaction API does not roll back on Throwable, but Exception only
#6609 Manual section about ForcedTypes uses <converter> instead of <binding>
#6614 Typo in manual section about dynamic SQL

New in jOOQ 3.9.6 (Sep 27, 2017)

New in jOOQ 3.9.5 (Jul 31, 2017)

New in jOOQ 3.9.4 (Jul 17, 2017)

New in jOOQ 3.9.3 (May 31, 2017)

New in jOOQ 3.9.2 (Apr 21, 2017)

New in jOOQ 3.9.1 (Apr 8, 2017)

New in jOOQ 3.1.0 (Jul 1, 2013)

Features and improvements:
Add SQLDialect.family() to group several SQLDialect versions of the same RDBMS
Improve MySQL Stored Procedure support using MySQL 5.5's
INFORMATION_SCHEMA.PARAMETERS dictionary table
Add integration tests for both jconn3 and jTDS JDBC drivers for Sybase and SQL Server
Map SQL Server TINYINT to UByte
Add support for Sybase SQL Anywhere unsigned number types
Add Field DSL.coerce(Field, DataType) and similar methods,
to coerce a field to a given data type (as opposed to casting it)
Document using jOOQ with Spring for transaction support
Add test to count opening and closing of Statements and ResultSets by jOOQ
Add support for SQL Server 2012 windowing clauses in window functions
Add support for the MariaDB database
Document 's feature of forcing a column onto a SQL type
Add Result DSLContext.fetchFromTXT() to allow for loading results that were exported using Result.format()
Add DSLContext.batch(String...) and batch(String, Object[]...) to easily create batch statements from SQL strings
Add DSLContext.fetchAny(Table, Condition) method and others
Allow for setting ResultSet flags (e.g.
ResultSet.TYPE_SCROLL_INSENSITIVE through
ResultQuery.resultSetConcurrency(), resultSetType(), resultSetHoldability()
Add DSL.using(Connection) and DSL.using(Connection, Settings) which auto-detect the SQLDialect from the jdbc url
Add Configuration.recordMapperProvider() to override jOOQ's internal default ReflectionMapper
Support CUBRID 9.1's new features
Add a new ControlFlowSignal that is used to explicitly jump out of a control flow
Add support for Postgres / HSQLDB's TRUNCATE [...] RESTART / CONTINUE IDENTITY
Add support for Postgres' TRUNCATE [...] CASCADE statement
Simulate row value expression IN predicate using EXISTS
Add Setting to influence parameter rendering (indexed, named, inlined)
Add Result.intoXML(org.xml.sax.ContentHandler) to generate a SAX event stream from a jOOQ result
Add support for SQL Server 2012 native OFFSET .. FETCH clause
Integration-test jOOQ with the SQLite xerial driver
Add DSLContext.batch(Query, Object[]...) as a convenience for calling batch(Query).bind(Object...).bind(Object...)
Add more Javadoc to ResultQuery.fetchResultSet() explaining that underlying PreparedStatements are closed with ResultSet.close()
Simulate row value expression comparison predicates using EXISTS
Add CustomQueryPart for use with plain SQL and other places
Add Field.compare(Comparator, Select) and Field.compare(Comparator,
QuantifiedSelect) to allow for more dynamic SQL
Add RenderContext.paramType() and deprecate RenderContext.inline() and
.namedParams()
Expose the DataSource contained in the DataSourceConnectionProvider
Add DSL.cast(Field, XXX) for increased API consistency
Add JDBCUtils.dialect(Connection) to "guess" the jOOQ SQLDialect from a
JDBC Connection
Add a public DefaultDSLContext implementation that can be used by users to override the default behaviour
Allow for treating Field as Condition
Add support for SQL Server 2012 sequences
Add JDBCUtils.safeClose(Connection)
Expose CHECK constraints in jOOQ-meta
Add Record.from(Object, Field...) from(Object, String...), from(Object, int...) to copy only a select set of values from a POJO, Array, Map
Add {Row|Record}.fields(Field...), {Row|Record}.fields(String...),
{Row|Record}.fields(int...) to extract Field[] from a row or record
Add org.jooq.tools.jdbc.DefaultResultSet to provide a default ResultSet delegation implementation
Add integration tests mapping binary(16) to java.util.UUID
Let batch executions debug-log executed queries
Convert.convert(Object, Class) should support simple casting
Document some SQL language to jOOQ DSL API mapping rules in the manual
Upgrade integration test jTDS version to 1.3.1
Add a new RecordType type to make up for the missing recursive type definition on Record
API changes (backwards-incompatible):
API bug: MergeNotMatchedSetStep.set(Field, Select) returns
MergeMatchedSetMoreStep instead of MergeNotMatchedSetMoreStep
Bug fixes:
Handle Ingres', SQLite, SQL Server's, Sybase ASE's limitations of 1024,
, 2100 or 2000 maximum bind values per query
Postgres ENUM data type isn't supported correctly, if the ENUM needs full qualification
NullPointerException when calling Schema.getTables() on a meta schema
with SQLite
Bad package name generated when contents are not trimmed
Cannot combine with if both match
jOOQ Meta does not recognise non-uppercase IN, OUT, INOUT keywords in
MySQL stored procedures
Suppress warnings in generated code (@SuppressWarnings("all") doesn't
suppress "rawtypes" warnings with javac)
RenderContext.data() is not passed on to QueryParts when being rendered
Upgrade RSyntaxTextArea to 2.0.7
Manual refers to a package-private DefaultConfiguration constructor
AbstractStoreQuery.execute() doesn't correctly operate on the
Configuration's ConnectionProvider in SQLite IDENTITY fetching queries
JDBCDatabase doesn't recognise Oracle's VARCHAR2 data type (and other vendor-specific data types)
Tables collected through DSLContext.meta() return duplicate columns if
multi-schema environments contain identical tables
JDBCDatabase doesn't use DataType.length(), precision(), and scale()
Cannot set precision on TINYINT, SMALLINT, INT, BIGINT data types
Generator Encoding Error for Database-Objects with Unicode-Names
Bad SQL rendered from DELETE statements with aliased tables
NullPointerException in AbstractResultQuery.fetchOneMap()
MySQL's unsigned types cannot be used in other dialects
IngresDatabase erroneously joins IIINDEXES to get constraint columns, rather than using IIKEYS
Possible null pointer passed to ConnectionProvider.release()
Code generation fails to generate valid java for stored procedures that accept parameters named configuration.
SQLDialectNotSupportedException on DSL.inline(T, Class), when jOOQ's
internals are not (yet) properly initialised
Compilation errors when generating code for artefacts that differ only by a trailing underscore(s): A and A_ and A__
Statement.close() may be called upon previously closed statements
Combining renderFormatted with inlined bind variables will change bind$ values when they contain newlines
Bad SQLDialect reference in Oracle and MySQL package-info.java
Error when rendering SQL Server procedures with Settings.renderSchema == false

New in jOOQ 3.0.1 (Jun 3, 2013)

New in jOOQ 3.0.0 (Apr 29, 2013)

This major release is a great move towards better integration of SQL as a language in Java. Unlike any other database abstraction framework, jOOQ now formally supports the notion of "row value expressions". The jOOQ API uses Xtend-generated API types from Row1 .. Row22, as well as Record1 .. Record22 to bring you even more compile-time typesafety on a record-level.
In SQL, you can typesafely write
SELECT * FROM t WHERE (t.a, t.b) = (1, 2)
SELECT * FROM t WHERE (t.a, t.b) OVERLAPS (date1, date2)
SELECT * FROM t WHERE (t.a, t.b) IN (SELECT x, y FROM t2)
UPDATE t SET (a, b) = (SELECT x, y FROM t2 WHERE ...)
INSERT INTO t (a, b) VALUES (1, 2)
In jOOQ, you can now (also typesafely!) write
select().from(t).where(row(t.a, t.b).eq(1, 2));
// Type-check here: -----------------> ^^^^
select().from(t).where(row(t.a, t.b).overlaps(date1, date2));
// Type-check here: ------------------------> ^^^^^^^^^^^^
select().from(t).where(row(t.a, t.b).in(select(t2.x, t2.y).from(t2)));
// Type-check here: -------------------------> ^^^^^^^^^^
update(t).set(row(t.a, t.b), select(t2.x, t2.y).where(...));
// Type-check here: --------------> ^^^^^^^^^^
insertInto(t, t.a, t.b).values(1, 2);
// Type-check here: ---------> ^^^^
This also applies for existing API, which doesn't involve row value expressions:
select().from(t).where(t.a.eq(select(t2.x).from(t2));
// Type-check here: ---------------> ^^^^
select().from(t).where(t.a.eq(any(select(t2.x).from(t2)));
// Type-check here: -------------------> ^^^^
select().from(t).where(t.a.in(select(t2.x).from(t2));
// Type-check here: ---------------> ^^^^
And for UNIONs
select(t1.a, t1.b).from(t1).union(select(t2.a, t2.b).from(t2));
// Type-check here: -------------------> ^^^^^^^^^^
These type-checks are preformed by your Java compiler, considering the generic type information of your SQL statement's Record data types. These include:
Record1
Record2
Record3
Record22
The highest degree of typesafety was chosen to be 22, to match Scala's Tuple22, Product22 and Function22 types. Higher degree records are still supported by jOOQ, just without the additional typesafety.
This Record typesafety is applied to:
SELECT statements
INSERT and MERGE statements: the VALUES() clause
UPDATE statements: SET A = (SELECT...)
UPDATE statements with row value expressions: SET (A, B) = (SELECT...)
Quantified comparison predicates: ANY(SELECT...) and ALL(SELECT...)
Comparison predicates: = (SELECT...)
IN predicates: IN (SELECT...)
BETWEEN predicates: BETWEEN (SELECT...) AND (SELECT...)
Generated records
The new VALUES() constructor
Scala integration for conversion of jOOQ Record[N] to Scala's Tuple[N]
Apart from this major improvement, there had been many minor changes throughout the jOOQ API. Here are some important ones:
Factory has been split into DSL (static QueryPart construction) and DSLContext (Query execution, "attached" QueryPart construction). This greatly improves the overall DSL experience while allowing for more fine-grained Executor lifecycle control.
A ConnectionProvider has been introduced as an abstraction of the JDBC Connection lifecycle. The standalone Connection and pooled DataSource modes are still supported, but you can now inject your own ConnectionProvider for more control.
A lot of performance improvements have been implemented within the jOOQ API removing most of the overhead caused by jOOQ when fetching data from JDBC
A JDBC Mock API has been added to help you create simple unit tests for your application built on top of jOOQ.
A VALUES() constructor is now supported, and derived column lists to alias tables and columns in one go.
The data type API has been greatly simplified. This allowed for the introduction of runtime precision, scale, and length information.
CRUD has been improved through many more CRUD batch operations, explicit INSERT and UPDATE (in addition to store()), and explicit handling of jOOQ's internal changed flags.
As this is a major release, some backwards-incompatibilities were inevitable.
For those users among you, migrating from jOOQ 2.x to 3.0, here are a couple of useful hints
Note, that for technical reasons, jOOQ 3.0.0 could not yet be integration tested with DB2, Ingres, and Sybase ASE. Consider using jOOQ 2.6, instead
Note, that further code generation and model API improvements were postponed to a later release
Note, previous release candidates contained more features, improvements and bug fixes. See their respective sections for details.
Features and improvements:
Add some more API usage examples to the section about ResultSet fetching
Add Constants.MINOR_VERSION and Constants.FULL_VERSION for internal and external reuse
Bug fixes:
Wrong screenshots in the manual's section about code generation. jooq-meta.jar is missing
Fix bad references to pre-3.0 Factory in Javadoc

New in jOOQ 3.0.0 RC 3 (Apr 13, 2013)

Features and improvements:
Remove the standalone tutorial, link to the manual
Implement various Key.toString() methods
Add Javadoc to Configuration.executeListenerProviders()
Add hint to the manual about mvn eclipse:clean and eclipse:eclipse when building jOOQ
Change the readme file to use Markdown
Add org.jooq.util.example package to jOOQ-codegen with some example GeneratorStrategies
Add aliases for arithmetic operators to be able to use Groovy default operator overloading
Make org.jooq.impl.DefaultConfiguration public
Add Configuration.set() methods. They should allow for modifying a Configuration
Add DSL.function(Name, Class, Field...) and DSL.function(Name, DataType, Field...) to allow for custom, fully-qualified function references
API changes (backwards-compatible):
Allow for overriding getIdentity() and getReferences() in CustomTable
API changes (backwards-incompatible):
Remove UpdatableTable marker interface, pulling up methods to Table
Change Configuration.data() to return Map
Decouple lifecycle of Configuration and ExecuteContext
Do not statically reference a Connection from GenerationTool
Decouple org.jooq.Context from Configuration. Choose composition over inheritance
Decouple org.jooq.DSLContext from Configuration. Choose composition over inheritance
Replace 3.0-RC1 Executor type by a contextual DSL type constructed from DSL.using()
Rename org.jooq.impl.Factory to org.jooq.impl.DSL
Let DAO reference a Configuration instead of a DSLContext
Replace Configuration's List with ExecuteListenerProvider[] to simplify correct and thread-safe client implementations
Change Configuration API to reflect jOOQ-style getter / setter naming
Rename dialect-specific Factories [Dialect]Factory to [Dialect]DSL
Remove support for the USE statement
Behavior changes (backwards-incompatible):
Relax ConnectionProvider contract, allowing acquire() to return new Connections even before release() is called
Bug fixes:
Cursor.close() doesn't terminate the ExecuteListener life cycle
"HsqlException: incompatible data type in conversion" when binding a UUID[] to an HSQLDB prepared statement
Compilation error in generated tables, when a table contains a UNIQUE key but no PRIMARY key
Documentation example regarding DSL.concat() does not compile
jOOQ 3.0 regression: NoClassDefFoundError caused by missing log4j dependency
Tutorial example unclear: There are three artefacts in Maven, not one
org.jooq.Meta's generated Schema and other objects are Serializable, but their enclosed Meta instance is not
Let equals() implementations succeed early on identity
Single page manual display errors on Firefox
Inaccurate Configuration Javadoc explaining wrong ExecuteListener lifecycle
SQLite identifiers that collide with keywords should be quoted
Do not add TableFieldImpl to table in constructor of TableFieldImpl
fetchOne() and fetchLazy() don't terminate the ExecuteListener life cycle when an exception occurs
Fully qualified name not used for user-defined aggregate function

New in jOOQ 3.0.0 RC 2 (Mar 8, 2013)

Features and improvements:
Add Executor.fetchCount(Select) and Select.fetchCount() to replace the projection by a COUNT(*) query
Add section to the manual indicating that the jOOQ generator can only handle schemas of a certain size
Add code generation option to avoid the generation of "global object references"
Add List Database.getIdentities(SchemaDefinition) for convenience to jooq-meta
Restore private and deprecated versions of the Factory constructors, adding some Javadoc about the changes between jOOQ 2.x and 3.0
Add section to the manual indicating how to build jOOQ with Maven
Add a paragraph to the manual's preface, explaining "why not just use SQL"?
Add Result Executor.fetchFromStringData(List) in order to reuse logic from fetchFromCSV
Add more verbosity to the code generator, when configured badly
Add Database.getUniqueKeys() and getForeignKeys to jOOQ-meta
Add section to the manual indicating how the various generator flags depend on each other
Do not generate "final" Tables.java, UniqueKeys.java, etc.
Bug fixes:
"code size too large" in generated SchemaImpl, when the number of tables exceeds 15k
Code generation runs extremely slow for large schemas (Inefficient DefaultRelations.getUniqueKeys() and getForeignKeys() methods)
Code generation runs extremely slow for large schemas (Inefficient AbstractDatabase.filterSchema() methods)
Javac's max constant pool of 64k can be exceeded in generated Keys.java or Tables.java
ArrayIndexOutOfBoundsException, when rendering plain SQL that is terminated by a comment
RenderMapping has no effect, if not supplied to the Executor constructor
RenderSchema has no effect, if not supplied to the Executor constructor
SQLDialectNotSupportedException: Type class org.postgis.PGgeometry is not supported in dialect null, when binding PG* objects
jOOQ Unit tests fail when not run in CET / CEST
Tutorial bug, referencing wrong Maven dependency. jOOQ 3.0.0 is not yet released, only RC1
Wrong MockDataProvider manual example
Postgres (UUID and other) ARRAY types aren't correctly inlined as string literals
UUIDs aren't correctly deserialised from Postgres UDTs
Improve supported formats for MockFileDatabase
Class loading issues in GenerationTool when called by Gradle
Compilation errors when code generator is configured with true and false
Suppress warnings in generated code (@SuppressWarnings("all") doesn't work with javac)
Annotate org.jooq.Support with java.lang.annotation.Documented to make it part of the public API (in Javadoc)
Outdated GenerationTool Javadoc

New in jOOQ 2.6.3 (Feb 26, 2013)

New in jOOQ 3.0.0 RC 1 (Feb 18, 2013)

Features and improvements:
Add runtime support for PRECISION, SCALE, and LENGTH attributes
Add support for the Firebird / Postgres UPDATE .. RETURNING clause
Add Table Factory.values(Row[N]...), to create ad-hoc tables from data
Introduce new type GroupField for cube(), rollup() and groupingSets() functions. Accept only GroupField... in groupBy() clauses
Add org.jooq.Catalog, a type modelling an entity combining several org.jooq.Schema
Overload Executor.fetch[One|Lazy](ResultSet, X...) with X being Field, DataType, Class
Allow for treating Condition as Field
Add support for row value expressions in UPDATE statements: UPDATE ..SET (A, B, C) = (SELECT X, Y, Z)
Add support for java.util.UUID as a type
Document RenderContext and make it part of the public API
Add UpdatableRecord.insert() and update()
Generate E into(E) and R from(E) methods to generated records
Add UpdatableRecord.key() returning a Record holding PK values
Add Factory.all() and Factory.any() to create quantified expressions
Add Executor.batchDelete(UpdatableRecord...) to mass-delete a set of UpdatableRecords
Add Table.as(String, String...) to allow for creating a table aliases (correlation names) with derived column lists
Add Record1, Record2, ... Record[N] similar to Row1, Row2, ... Row[N] to support record type-safety
Add a section to the manual about the migration to jOOQ 3.0
Make some JDBC-related utility methods publicly available in org.jooq.tools.jdbc.JDBCUtils
Duplicate SELECT API between Executor and Factory
Add Executor.fetch(ResultQuery), Executor.execute(Query), and similar methods
Add Row[N].equal(Select), changed(int), changed(String) to check whether a single field's value has changed
Add T Record.original(Field), original(int), original(String) to get a Field's original value
Reflect changed flag in Result.toString() (and thus also Record.toString())
Add Record.changed(boolean) changed(Field, boolean) changed(int, boolean) changed(String, boolean) as setters for the changed flag
Add Record.reset(), reset(Field), reset(int), reset(String) to restore original values in a record
Add elementFormDefault="qualified" to XSD specifications to allow for XML validation of jOOQ configuration files
Let org.jooq.ExecuteListener extend java.util.EventListener
Add UpdatableRecord.refresh(Field...) to allow for refreshing a subset of the Record's values
Document semantic versioning rules as understood by jOOQ
Add Batch.size() to indicate the number of queries that will be executed by a batch operation
Add reusable wrapper types for JDBC Connection, Statement, ResultSet,
etc.
Add various TableRecord.fetchParent(...), fetchChild(...) and fetchChildren(...) methods to follow foreign key relationships
Add gt() / ge() / lt() / le() to Row[N] types
Add [not]Between[Symmetric]() to Row[N] types
Add is[Not]Null() to Row[N] types
Add Executor.extractBindValues(QueryPart), extractParams(QueryPart) to extract bind values in the context of an Executor (i.e. Configuration)
Let UDTRecordImpl and ArrayRecordImpl.toString() return a valid constructor expression
Add Postgres to @Support annotation of SelectForUpdateWaitStep.wait()
Support generation of bean validation annotations on records and interfaces
Generate an "empty" DefaultSchema for those databases that do not have any schema (CUBRID, Firebird, SQLite)
Add unit tests for org.jooq.tools.Convert
Let Record implement Comparable
Improve org.jooq.Record Javadoc, to explain the various Record subtypes
Add Row.types() and Row.dataTypes() as a convenience
Document Record.hashCode() and equals() through Javadoc
Allow for mapping to "" (empty) in order to avoid the generation of a schema
Add Row.type(int), type(String), dataType(int), dataType(String) for convenience
Add Executor.fetchLazy(Table) and fetchLazy(Table, Condition) for convenience
Let ExecuteListener extend Serializable
Add Executor.batchUpdate(UpdatableRecord...) to mass-update a set of UpdatableRecords
Add Executor.batchInsert(UpdatableRecord...) to mass-insert a set of UpdatableRecords
Add some more Javadoc to JooqLogger
Add 0.0 and 1.0 to Convert.FALSE_VALUES and Convert.TRUE_VALUES
Allow for converting booleans to numbers through org.jooq.tools.Convert: TRUE => 1, FALSE => 0
Add set(Field, Select>...) to Collection>...
Relax bounds of R on Executor.newRecord() from TableRecord to Record
API changes (backwards-incompatible):
Remove support for the code generation ant task
Move org.jooq.tools.unsigned contents to org.jooq.types (along with the INTERVAL types)
Relax usage of generic [] are sufficient
Optimize DAOImpl by using the new ReflectionMapper instead of calling Record.into() all the time
Change all Javadoc tags to (To fix Java 7 standard Javadoc style layout issues)
Executor.fetchFromCSV() shouldn't mark resulting records as "changed"
Improve example in the "jOOQ for CRUD" section. Use only columns from the sample database
SQL injection is possible in org.jooq.impl.Val, if client code doesn't correctly enforce generic typesafety, and bind variables are inlined
Field.in(T...) doesn't convert argument values to the Field's type

New in jOOQ 2.6.2 (Feb 5, 2013)

New in jOOQ 2.6.1 (Dec 27, 2012)

New in jOOQ 2.6.0 (Oct 26, 2012)

Minor feature improvements include:
Lots of new fetchGroups() and intoGroups() methods, thanks to Ivan Dugic
JDBC execution control support, such as cancel(), maxRows(), queryTimeout()
Allowing for re-using JDBC PreparedStatement between Query executions
Support for the SQL standard OVERLAPS predicate
A new RecordMapper, similar to the existing RecordHandler
Features and improvements:
Allow for keeping open statements in a Query
Add support for Oracle / SQL Standard linear regression functions
Add Factory.row(T1, T2, .. TN) and Factory.row( Field, Field ... Field) to allow for creating tuples / rows
Add support for the SQL standard OVERLAPS predicate
Improve formatting for DECIMAL data types in Result.format(). Nicely align the decimal point and reserve space on both sides
Let XJC-generated artefacts implement Cloneable
Support for converting String to java.net.URL, java.net.URI, and java.io.File
Export data types with Result.formatXML() and Result.formatJSON() exports
Add Factory.table(String, QueryPart...)
Add Map ResultQuery.fetchGroups(Field, Class)
Add Map ResultQuery.fetchGroups(Field[])
Add Map ResultQuery.fetchGroups(Field[], Class)
Make logic from ResultQuery.fetchArray() available in Result.intoArray()
Add support for the MySQL COUNT(DISTINCT expr, expr...) aggregate function syntax
Add support for the CUBRID DECR() function
Add RecordMapper, similar to RecordHandler, mapping records to custom types
Add package-info.java to add Javadoc documentation to all packages
Simulate row comparisons where they are not supported
Add a new jOOQ-Scala project and jooq-scala artefactId, to contain jOOQ extensions in the Scala language
Move JAXB bindings out of XSD, in order to support more advanced bindings
Generate @SuppressWarnings("all") in jOOQ-generated artefacts
Enhance the BETWEEN predicate, introducing the AND keyword
Add Map ResultQuery.fetchMap(Field, Class) and Result.intoMap(Field, Class)
Add support for materialized views in Oracle's code generator
Reduce log level for Factory deserialisation to TRACE
Add support for @java.beans.ConstructorProperties when fetching into immutable POJOs
Add SortField Field.sort(SortOrder) to allow for dynamic sorting
Add Condition Field.compare(Comparator, Field) to allow for dynamic comparisons
Add Table Table.join(TableLike, JoinType) to allow for dynamic joining
Add Factory.schemaByName(String) for plain SQL schemata
Add Record.changed() to indicate whether a Record contains "dirty" values
Add Record.original() to obtain the originally fetched values from a Record
Add ResultQuery.maxRows(int) to limit the number of actually fetched records
Add Query.cancel() to support for interrupting statements prematurely
Add Query.queryTimeout(int) to support for JDBC's Statement.setQueryTimeout()
API changes (backwards-compatible):
Deprecate AliasProvider
Result.intoArray() declares "throws MappingException", which isn't true
Deprecate the various Result.getValuesAs[Type] and Record.getValueAs[Type] methods
Deprecate org.jooq.Store
Deprecate [Schema-Name]Factory, remove reference to it from the tutorials
Deprecate org.jooq.NamedQueryPart
Deprecate org.jooq.NamedTypeProviderQueryPart
Improve jOOQ's RenderContext pretty printing behaviour
Deprecate ConditionProvider, OrderProvider, LockProvider types
Bug fixes:
Factory.field("{1} + {0} + {0}", val(1), val(2)) doesn't work. Cannot re-use / re-order placeholders
Improve performance by using Record.getValue(int) instead of Record.getValue(Field) internally, where more than one value is retrieved from a record
Result.intoResultSet() generates wrong ResultSetMetaData if runtime schema mapping is applied
Add missing @Support({ ... FIREBIRD ... }) annotations
NullPointerException when DAO.fetchOne() returns no record
QueryPart.toString() does not load default settings from classpath
Fix SEQUENCE support for Firebird
Log a table's input/output names, and PK name when generating code
Factory.fieldByName() and tableByName() do not correctly escape quotes
SQL syntax errors when plain SQL contains comments with question marks and SQL is executed as StatementType.STATIC_STATEMENT
Result.into(Table) doesn't work correctly, if the same field name appears twice in Result
Let Record.toString() wrap the record in a temporary Result and call Result.toString() instead
MappingException in Record.into(Class), when POJO setters have applicable names but non-applicable argument types
Cannot fetch into non-public POJO classes. Their members / getters / setters should be made accessible
Factory.execute(String) may cause errors when plain SQL returns results
Allow for passing null or empty arrays to intoMap(Field[]) and intoGroups(Field[])
Record.equals() returns true as soon as both records hold a "null" value for a given field
Bad Results returned from plain SQL "select *" queries, if several selected columns share the same name
NULL constraint violation when storing a copied record

New in jOOQ 2.5.1 (Sep 24, 2012)

New in jOOQ 2.5.0 (Aug 27, 2012)

Optimistic locking. jOOQ's UpdatableRecord API transparently implements optimistic locking on its store() and delete() methods. By default, the in-memory record is compared with the one in the database at write time. But you can also let jOOQ handle incremented VERSION or TIMESTAMP columns for you.
Oracle feature increment. Many nice Oracle features are now supported: user-defined aggregates, regular expressions,
Oracle Text, CONNECT_BY_ROOT and ORDER SIBLINGS BY clausess, partitioned outer joins and more
jOOQ's convenience API has been greatly enhanced. This includes many improved fetch methods and new short forms for equal=eq, notEqual=ne, greaterThan=gt, etc. to better align jOOQ with JPA, XSL, QueryDSL and many other tools that abbreviate these keywords
Many types and methods have been deprecated to help you foresee
the upcoming changes in jOOQ 3.0
Please consider also the updated manual with its new, more
user-friendly structure
Features and improvements:
430 - Add support for the Firebird database
457 - Add support for Oracle user-defined AGGREGATE functions
620 - Add support for the SQL:2008 standard LIKE_REGEX operator
722 - Remove casting of bind values in Ingres
727 - Simulate RPAD and LPAD in SQLite
816 - Add support for Oracle Text functions
1339 - Add option to generate immutable pojos
1547 - Support "optimistic locking" in UpdatableRecord.store()
and delete()
1552 - Generate fetchBy[ColumnName] methods in generated DAO
classes
1553 - Add some Javadoc to document the difference between using
a Factory with a Connection or with a DataSource
1556 - Add javax.validation API to full deliverable
1565 - Add Factory.connectByRoot(Field) to support the Oracle
CONNECT_BY_ROOT pseudo column
1570 - Add Factory.condition(String, QueryPart...) similar to
Factory.field(String, QueryPart...)
1582 - Add support for Oracle's ORDER SIBLINGS BY clause, in
combination with CONNECT BY
1586 - Add missing constructors taking DataSource to dialect-
specific factories
1587 - Generate missing constructors taking DataSource in
schema-specific factories
1595 - Simulate REPEAT() in SQLite
1596 - Add support for optimistic locking using generated
information about "timestamp" or "version" columns
1627 - Handle NULL in CSV imports/exports
1645 - Add support for Oracle's PARTITION BY clause in OUTER
JOINs
1657 - Reorganise the manual
1664 - By default, activate in the code generator
1665 - Add support for the empty GROUP BY () clause
1675 - Add support for the SQL standard IS [NOT] DISTINCT FROM
predicate
1680 - Overload all plain SQL DSL methods to also accept
QueryPart arguments
1681 - Simulate empty GROUP BY () clause in Sybase ASE and
Ingres, joining a dummy table and grouping by a constant
field
1684 - Add Setting to indicate that fetched
records shouldn't be automatically "attached"
1685 - Improve Javadoc of Attachable.attach(). Document how
"detaching" works
1688 - Add E Record.into(E) as a complement to
E> E Record.into(Class)
1692 - Replace Factory.executeInsert(), Factory.executeUpdate()
and similar methods with more succinct variants
1696 - Add short versions of comparison predicate methods, such
as eq, ne, gt, ge, lt, le
1698 - Add support for the SQL standard BETWEEN SYMMETRIC
predicate
1701 - Add Factory.not(Condition) as a synonym for
Condition.not()
1704 - Document the behaviour of Factory.newRecord(Table,
Object) and Record.from(Object) with respect to
UpdatableRecord.store()
1707 - Add Map ResultQuery.fetchGroups(
Field) and Result.intoGroups(Field)
1712 - Add is set to true

New in jOOQ 2.4.0 (Jul 9, 2012)

Features and improvements:
Add Result.intoResultSet() to wrap a Result in a JDBC
ResultSet
Avoid JDBC escape syntax for date/time literals
Generate DAO classes and interfaces for POJOs
Document the lifecycle of an ExecuteListener in the
Javadoc
Add support for Postgres "any" data type (with quotes!).
This seems to map well to java.lang.Object
Support case-insensitive schema names in code generation
Add some WARN-level logging when the source-code
generator doesn't generate any artefacts
Add Field.likeIgnoreCase() to support Postgres' ILIKE
operator
Add Factory(DataSource) and similar constructors
Add Factory.batchStore(Collection>) for convenience
Add DataType.convert(Object...) and DataType.convert(Collection) for convenience
Add org.jooq.Name Factory.name(String) to construct QueryParts that are escaped according to
Settings.getRenderNameStyle()
Add Factory.fetch(String, QueryPart...) and Factory.execute(String, QueryPart...) and similar methods to support arbitrary QueryParts in plain SQL
Add UniqueKeyDefinition.isPrimaryKey() for completeness
Add Result Factory.fetchFromCSV(String)
Add top-level pom.xml for jooq-parent artefact (GitHub Issue #14)
Converting arbitrary strings to Number / Date should return null, instead of throwing an exception
Generate some meaningful Javadoc into the generated schema-name]Factory classes
Add line breaks to generated Javadoc where appropriate
Add option to let generated Record / POJO objects implement a common generated interface
Support interface types in ResultQuery.fetchInto(Class), Result.into(Class), and Record.into(Class) methods, returning a proxy
Upgrade internal jOOR dependency to jOOR 0.9.4
Add IdentityDefinition to jooq-meta
Add support for conversion of String to java.sql.{Date, Time, Timestamp}. GitHub issue #22
Document behaviour of fetch() and fetchOne() in case jOOQ cannot fetch actual records
Minor improvements in the generator source code. GitHub pull request #23
Generate additional setters for foreign keys, accepting records as arguments
Expose Connection methods, such as commit(), rollback() and similar transaction-related methods in Factory
Support ROW_NUMBER() OVER() for the latest version of Derby and H2, which support it
Simulate ROW_NUMBER() OVER() in HSQLDB using ROWNUM()
Let generated interfaces extend Serializable
Clarify the lifecycle of Configuration.data in the Javadoc
Generate more meaningful Javadoc where "an uncommented item" stands now
Add documentation to the FOR UPDATE OF clause, indicating that DB2 may have stricter requirements regarding updatability of fields
Add support for the H2 MERGE syntax - GitHub Issue #18
Simulate the H2 MERGE syntax in other dialects supporting the SQL standard MERGE statement - GitHub Issue #18
Website and Documentation anchors should be links to themselves, visually recognisable
Features and improvements (jOOQ Console)
Allow for adding breakpoints in jOOQ Console
API changes (backwards-compatible)
Relax bounds of in Factory.truncate() to Record, instead of TableRecord
Change Convert.convert(List, XXX) to accept Collection instead of List
Bug fixes:
Improve Oracle's LIMIT .. OFFSET clause simulation.
GitHub Issue #16
Compilation errors in generated source code when Oracle
overloaded procedures collide with procedures that end
with numbers
Error in Javadoc of FactoryOperations.fetchOne(). This
method may return null
Performance issue with AbstractDataType.convert(Object).
Avoid conversions when they're obviously unneeded
Handle String to Enum conversion (when Java Enums are stored as Strings in the database) - GitHub issue #15
Generated Keys.java static class too large (static initialiser can become bigger than 64kb)
Table.getReferencesTo(Table) doesn't work correctly for
aliased tables
Exception when rendering of {fn datetimeadd(...)} for HSQLDB and Derby
Document missing GeneratorStrategy features, such as getJavaClassImplements()
custom generator strategy's printImplements() is called
with Mode == RECORD for tables
Caching SQLDialect in AbstractDatabase heavily improves code generation performance
Inefficient cloning of default settings using JAXB unmarshalling leads to non-negligible overall overhead.
Use serialisation instead (short of a useful XJC clone
plugin)
Fix manual where it claims to throw SQLExceptions
Compilation error when a SQL Server stored procedure has a parameter named "value"
Bad syntax for SELECT /*+hint*/ DISTINCT ... in Oracle
jOOQ does not compile using JDK 7 / JDBC 4.1. GitHub
Issue #24
Generated members of Tables.java are not final
Bad exception message when ON DUPLICATE KEY IGNORE cannot be simulated
Splitting of large NOT IN conditions is wrong. The parts
should be connected with AND, not with OR
fetch().into(Table) doesn't initialise records correctly,
such that subsequent calls to store() will execute an
INSERT, rather than an UPDATE
Generate missing Javadoc to getters for procedure OUT
parameters
Factory.batchStore() logs all single statements to DEBUG
output. Find a more accurate log output
Factory.batchStore() renders bad SQL for Postgres. The RETURNING clause is not allowed in batch INSERTs

New in jOOQ 2.3.2 (Jul 2, 2012)

New in jOOQ 2.3.1 (May 11, 2012)

New in jOOQ 2.3.0 (May 7, 2012)

Features and improvements:
Add support for Oracle KEEP (DENSE_RANK FIRST...)
aggregate function clause
Add ExecuteListener extension to allow for overriding
exception translator to handle vendor-specific error
codes
Add "renderSchema" flag to Settings, to completely
disable rendering of schema names
Generate setter methods for JAXB annotated configuration
properties
Add support for MySQL's INSERT IGNORE clause
Simulate the FOR UPDATE clause for SQL Server, CUBRID,
using JDBC's ResultSet.CONCUR_UPDATABLE
Add Factory.inline() to allow for flagging inline-only
"bind values"
Add connection-less Factory constructors for convenience,
when jOOQ is only used as a SQL query builder
Add option to generate JSR-303 @NotNull and @Size
annotations to generated POJO's
Let HSQLDB dialect render NVL2() as NVL2() instead of
CASE expression
Allow for omitting , and generate all
available schemata in that case
Let generated factories use their associated Schema as
the Settings' RenderMapping's defaultSchema
Move jooq-spring's FactoryProxy to the core jooq project
Add Factory.dateAdd() and timestampAdd() for convenience
Add DataType.isLob()
Add Field inline(char), inline(Character),
inline(CharSequence) for convenience
Add support for the Oracle TRUNC function, for numeric
arithmetic
Let Record.into(Class) and similar methods accept
"immutable" classes, i.e. setter-less classes that take
several constructor arguments
Use Constructor.setAccessible(true), if no default
constructor is available on the target type of
Record.into(Class)
Improve Javadoc on Factory.function(). Document arguments
Add support for the CUBRID Click-Counter INCR()
Allow for creating syntax-error and SQL-injection safe
qualifiers for org.jooq.Field and org.jooq.Table
Add Factory.batchStore(TableRecord...), to allow for
batch UPDATE/INSERTs of many records
Make configured ExecuteListeners default constructors
accessible
Let org.jooq.Batch extend Serializable
pgrade internal jOOR dependency to jOOR 0.9.3
Upgrade internal jOOU dependency to jOOU 0.9.1
Add RenderContext.qualify() to indicate whether
QueryParts should render qualified versions of themselves
or not
Features and improvements (jOOQ Console):
Upgrade jOOQ Console dependency on RSyntaxTextArea from
1.5 to 2.0.2
Allow for filtering incoming statements in jOOQ Console
Implement a communication protocol between Console server
types and Console client types to allow for more
sophisticated functionality
API changes (backwards-compatible)
Deprecate Factory.literal() in favor of Factory.inline(),
and Factory.field()
Promote AbstractQuery.isExecutable() to the public API
Bug fixes:
INSERT and UPDATE statements always render non-qualified,
escaped field names. This may cause trouble when using
plain SQL fields
Standalone TABLE or VARRAY types are not correctly
initialised before referencing tables load them
NullPointerException when leaving empty
The LIKE escape character needs escaping, too, in
contains(), startsWith(), endsWith()
Add missing INTERVAL data types to HSQLDBDataType
Oracle's DataTypeDefinition reports the length of a BLOB
CLOB data type to be 4000
and match only table names, not
fully qualified names
Add support for byte[] in Postgres UDTs
Code generation error in Oracle 10g when generating
stored procedures
Error when deserialising BLOBs from Oracle UDTs
NullPointerException when passing null to
timestampDiff(Field, Field)
Regression in insertInto(...).values(...). Cannot pass
Field to values()
Initialise Result ArrayLists to their expected size, if
that size is known.
jOOR issue 12: "Don't reset the accessible flag to false,
if setting it to true is required, to avoid race
conditions in concurrency contexts"
Missing conversion when using unsafe Field types in
BATCH statements
Oracle UDTs in REF CURSORs are not deserialised correctly
from procedure OUT parameters
Oracle UDTs are not deserialised correctly when the same
UDT name is present in multiple schemata
NullPointerException when omitting element in
code generation configuration

New in jOOQ 2.2.2 (Apr 23, 2012)

New in jOOQ 2.2.1 (Apr 13, 2012)

New in jOOQ 2.2.0 (Apr 10, 2012)

New in jOOQ 2.1.0 (Mar 19, 2012)

New in jOOQ 2.0.5 (Feb 28, 2012)

Features and improvements:
Add Field.equalIgnoreCase(), Field.notEqualIgnoreCase()
Add class prefixes, suffixes and other options to the code generator
Add runtime configuration
Let Field.contains() support the Postgres ARRAY @> ARRAY operator
Add ResultQuery.fetchResultSet() to return the underlying JDBC result set
Add Result.isNotEmpty() for convenience
Add runtime configuration to specify whether jOOQ should execute java.sql.PreparedStatement (with bind variables) or a java.sql.Statement (with inlined parameters)
Add Query.getSQL(boolean) to indicate that bind values should be inlined (as a convenience for Factory.renderInlined(QueryPart))
Add Cursor.resultSet() to expose the underlying ResultSet
Allow for optional "http://www.jooq.org/xsd/jooq-codegen-2.0.4.xsd"
namespace in jooq-codegen configuration
Add E MySQLFactory.enumType(Class, int) for enum reverse lookups of MySQL-specific enums
Support matching numbers with LIKE, e.g. ID LIKE '3%'
Implement Field.contains(), .startsWith(), .endsWith() for numeric values, too
Use reflection to remove compile-time dependency on ojdbc for creating ARRAYs
Integrate jOOR into jOOQ for simpler reflection
Distinguish between Definition.getInputName(), .getOutputName()
Add constraint name to generated javadoc
Trivial issue with org.jooq.Factory.exists Javadoc - GitHub issue #10
Add Configuration.setData(), getData() to convey custom data in a configuration's lifecycle
Add runtime configuration to deactivate JooqLogger
Add jOOQ-Console module to jOOQ
Add DataType.isArray()
API changes (backwards-compatible):
Rename Result.exportXML() to Result.intoXML() to stay more consistent
Deprecate SchemaMapping in favour of new runtime configuration
Bug fixes:
Schema.getTables() and similar methods return empty lists when Schema is mapped with SchemaMapping
Bad inlining of booleans in Sybase ASE / DB2 / Oracle
SQL Server / SQLite
Bad inlining of byte[] in most dialects
byte[] are erroneously converted to String when using Record.intoArray()
Bad inlining of DATE / TIME / TIMESTAMP data types in
Ingres (and other dialects, when the setting differs from the default)
Some generated Javadoc uses naming strategy or plain output name, instead of qualified output name
Oracle packages are generated as static, instead of static final
Factory.use() seems to render SQL with the Schema name still present
Oracle-generated ArrayRecords need a reference to org.jooq.Schema to read TABLE of OBJECT from stored procedures
Test cases:
Add integration tests for executing SQL generated using Factory.renderInlined()

New in jOOQ 2.0.4 (Feb 13, 2012)

This release introduced many improvements to source code generation. These improvements include:
Maven and standalone code generation now use the same XML configuration, which is read by jOOQ-codegen using JAXB. This allows for more complex configuration elements in the future jOOQ-codegen can now handle multi-schema databases and generate code for tables referencing tables from other schemata. This is integration tested against the SQL Server AdventureWorks database jOOQ now allows to generate simple POJOs in addition to Records and to annotate both POJOs and Records with JPA annotations such as @Entity, @Table, @Id, @Column, @UniqueConstraint, etc.
You can migrate your existing .properties configuration by running org.jooq.util.GenerationTool /your.properties migrate
Besides that, there is a lot of ongoing work to improve the integration of Oracle's TABLE and VARRAY types.
Features and improvements:
Add JPA annotations to generated POJOs / Records
Add support for multi-schema databases
Add support for Oracle TABLE types
Use XML configuration file instead of properties file
Add Field.contains(), .startsWith(), .endsWith() as a
convenience for Field.like() (including escaping)
Move master data table configuration from
generator.generate to generator.database namespace
Add support for generator.strategy in Maven source code
generation
Add support for generator.database.date-as-timestamp in
Maven source code generation
Move generator.generate.unsigned-types to
generator.database namespace
Add support for generator.generate.unsigned-types in
Maven source code generation
Add support for SQL Server data type uniqueidentifier
Add Factory.escape(Field, char) for use with LIKE
Add support for multi-schema databases using Maven code
generation
Add support for Oracle VARRAY/TABLE of OBJECT types
Add support for POJO classes generation
Allow for using Param in LIMIT .. OFFSET clauses
Add RenderContext.castMode() to allow for avoiding casts
where this is not really needed
Add generation option to enable/disable generating
navigation methods
Bug fixes:
Derby generated artefacts are not sorted alphabetically
Internal API leak exposed through covariance in
AbstractTable.joinXXX() methods
VARRAY element type information is lost when unnesting
VARRAY's in Oracle
VARRAY element type information is lost when unnesting
VARRAY's returned from functions in Oracle
Syntax error when unnesting TABLE of OBJECT in Oracle.
The unnested table contains several columns but jOOQ only
unnests "COLUMN_VALUE"
NullPointerException when passing an ArrayRecord
containing a null array to a stored function in Oracle
Postgres needs casting for date time data types in
queries like SELECT ? FROM DUAL
DB2: [Noauthorized routine named "LIKE" of type
"FUNCTION" having compatible arguments was found] when
using Field.like(concat(x, y))
Compilation errors in generated source code if the same
constraint name exists in several schemata
NullPointerException in code generation when a foreign
key constraint references a table from another schema
that is not being generated
Generated Javadoc references inputSchema instead of
outputSchema
Test cases
Add more integration tests for proper handling of
java.sql.Date, Time, Timestamp
Run jOOQ tests against AdventureWorks SQL Server sample
database
Add integration tests for multi-schema source code
generation and querying
The 10k lines of integration test code are too heavy for
the compiler. Create test modules with fewer lines of
code, each.

New in jOOQ 2.0.3 (Feb 1, 2012)

This release focuses on increased compatibility between various SQL dialect integrations as far as ARRAY and JOIN support is concerned:
ARRAY types are only available in H2, HSQLDB, Oracle, Postgres. Nevertheless, they can be somewhat simulated in other dialects using nested selects with UNION ALL. Increased compatibility leads to a nicer API, where ARRAYs are used along with ALL/ANY quantifiers, for instance.
JOIN syntaxes can be quite powerful in SQL. Apart from simulating NATURAL JOIN, JOIN USING clauses, as well as a synthetic "KEY JOIN" syntax, jOOQ now also supports nesting
JOIN expressions to create more complex table sources.
Features and improvements:
578 - Add KEY JOIN syntax to simulate joining using generated
foreign keys
577 - Simulate NATURAL JOIN syntax, where this is unavailable
582 - Simulate JOIN USING syntax, where this is unavailable
671 - Allow for nesting JOIN clauses
676 - Add Table.join() methods to create more flexible table
sources
993 - Add Field.equalAny(T[]), .equalAny(Field) methods
1048 - Simulate (array) syntax for dialects
that do not support arrays
1051 - Add Factory.execute(String, Object...) as a convenience
method for Factory.query(...).execute()
1055 - Simulate Factory.table(Object[]) and table(List) using
UNION ALL in dialects that do not support arrays
1060 - Improve debug logging of H2 arrays. The syntax is not
ARRAY[1, 2], but (1, 2)
1065 - Add OracleFactory.sysContext(String, String) to support
Oracle's SYS_CONTEXT function
1069 - Add support for INSERT INTO table(field1, field2, ...)
SELECT syntax - as opposed to the existing INSERT INTO
table SELECT
1072 - Add support for LIKE .. ESCAPE .. syntax
1074 - Add Field.notBetween(T, T) for convenience
1080 - Add support for JDBC's Statement.setFetchSize() in
ResultQuery.fetchLazy()
1082 - Add some more DEBUG logging in AbstractResultQuery
API changes (backwards-compatible)
1059 - Change SelectFromStep.from(Collection>)
API changes (backwards-incompatible)
1087 - Change the NTILE function to return Field
instead of Field
Bug fixes:
1071 - Make Sequence Serializable
1081 - Derby error in NULL handling when simulating unnested
arrays that contain NULL values
1084 - Bind index mismatch in val(null).equal(null) and in
val(null).notEqual(null)
1091 - Add missing @Support annotations on Table.crossJoin()
methods
Test cases
1026 - Add integration tests for NTILE window function and
document compatibility
1073 - Add integration tests for NOT IN queries holding NULL
arguments

New in jOOQ 2.0.2 (Jan 9, 2012)

The main improvements include:
The whole jOOQ API is now annotated with a new org.jooq.Support annotation to help you assess whether a certain SQL clause is available in your database or not. This is particularly useful when your application should support several databases at once (e.g. MySQL, Postgres, Oracle)
The Oracle PIVOT clause is now formally supported for advanced statistical queries in Oracle. This clause will be simulated in other dialects in the future.
The DATE data type can be mapped to TIMESTAMP. This important when you query a legacy Oracle database, where DATE columns can also contain time information
Several convenience methods have been added for more fluent syntax, when using plain SQL result queries, subqueries as tables, or when unnesting arrays in ANY() and ALL() quantifiers
Features and improvements:
Add support for Oracle's PIVOT clause
Add support for using ANY, ALL with arrays, not just with subselects
Formally document the API methods to indicate whether something is supported by any given SQL dialect
Add code generation configuration parameter to avoid generating @Generated annotation
Render LIMIT x OFFSET y also for MySQL, instead of LIMIT y, x
Add missing Sybase ASE implementation for Factory.use()
Add Factory.resultQuery(String, Object...) to allow for arbitrary execution modes of plain SQL queries (lazy, later, into, array, etc)
Add missing SQLite implementation for Factory.deg() and Factory.rad()
Generate table comments into generated Tables.java as Javadoc
Add Object[][] Result.intoArray() and Object[] Record.intoArray() for convenience. Let E Record.into(Class) also support array types.
Add Table Factory.table(Select) convenience method for more fluency
Add support for DISTINCT keyword in SUM, AVG, MIN, MAX aggregate functions
Generate Ingres table and column comments in generated source code (only Ingres 10)
API changes (backwards-compatible):
Deprecate usage of SOME quantifier in predicates, such as equalSome()
API changes (backwards-incompatible):
Fixed API typo in WindowsRowsStep.rowsBetweenUnboundedFollwing()
The fluent API allows for JOIN clauses without FROM clause
Bug fixes:
The MERGE INTO .. WHEN NOT MATCHED THEN INSERT .. syntax may cause type-safety issues in some databases. VALUES should be converted before binding
FindBugs: Latent risk of infinite recursion due to typo in QueryPartList.retainAll();
FindBugs: 7 occurrences of "Bad attempt to compute absolute value of signed 32-bit hashcode". In extreme cases, this could lead to SQL syntax errors
The Oracle CONNECT BY cond1 AND cond2 syntax erroneously creates a WHERE cond2 CONNECT BY cond1 statement
Syntax errors when using untyped param() in HSQLDB (and other strongly typed dialects)
Postgres can't bind NULL values in cases, where bind type is Object.class and bind value was created with Factory.param()
UnsupportedOperationException when calling Query.bind(int, Object) on a query containing plain SQL fields
Incorrect debug logging when plain SQL QueryParts like field("?") bind null values
Incorrect debug logging when plain SQL QueryParts contain String literals, such as 'Hello? Anyobody out there?'
Field.notEqualAny() erroneously renders ALL()
Test cases:
Add explicit integration tests for LEFT|RIGHT|FULL OUTER JOIN

New in jOOQ 2.0.1 (Jan 9, 2012)

The main improvements include:
Better integration for using jOOQ with Spring Data. This includes support for named parameters, as well as allowing to change bind values on previously constructed Query objects
The MERGE statement has been enhanced for better integration with Oracle.
jOOQ is now ready to use with Scala / Groovy
There is now also experimental support for a custom type mapping.
This mapping allows to rewrite data types at code generation time as well as to specify custom enum data types (e.g. boolean Y/N).
Not all integration tests run smoothly for custom data types, hence, this feature is not yet fully supported.
Features and improvements:
Add support for Oracle CURSOR REF IN / INOUT parameters
Add type-mapping configuration, enforcing types for columns
Add custom type mapping support (experimental)
Allow for custom enum types, configured in the code generator (experimental)
Add Schema.getTable(String), getSequence(String), getUDT(String) for better runtime Schema meta-navigation
Add Sequence.getName(), getSchema(), getDataType()
Add support for named parameters, to better interact with Spring
Add Query.bind(String, Object) and bind(int, Object) to easily modify existing bind values
Document thrown DataTypeException in Convert methods
Enhance MERGE statement for Oracle extensions: WHEN MATCHED THEN UPDATE .. WHERE .. DELETE WHERE .. WHEN NOT MATCHED THEN INSERT .. WHERE ..
Add support for MySQL's INSERT INTO .. SET .. syntax in MERGE statement's WHEN NOT MATCHED THEN INSERT clause
API changes (backwards-compatible):
Cannot insertInto(table("my_table")), as plain SQL tables return Table, not Table. Relax bound on R
Change Factory.field(String) to return Field instead of Field
#999 - Make MERGE's WHEN MATCHED .. and WHEN NOT MATCHED .. clauses optional
Identity.getField() should return TableField instead of Field
#1006 - Add Factory.value(...) as a synonym for Factory.val(...) for increased Scala / Groovy compatibility
Bug fixes:
EnumType renders name() instead of getLiteral() in formatXXX() methods
#977 - EnumType renders name() instead of getLiteral() in Convert.convert() method
Record.from() sets all changed flags to true. That's not necessarily correct in the event of storing the record back to the DB
AbstractRecord.equals() does not correctly compare arrays. Compare them using Arrays.asList()
Postgres / DB2 / Sybase ASE foreign-key namespace is unique-per-table. jOOQ forces all foreign keys from all tables into the same namespace
Problems when encoding arbitrary byte[] as String(byte[]) in inlined SQL. This can cause issues when DEBUG-level logging is activated
Routines don't respect SchemaMapping - Github issue #8
TableRecord.storeUsing() doesn't update IDENTITY column values, if the column is not part of the main unique key
Sybase / SQL Server / MySQL / Ingres / H2 / Derby's INSERT .. RETURNING simulation returns null if a table has an IDENTITY column, but no primary/unique key
The INSERT INTO .. VALUES .. syntax may cause type-safety issues in some databases. VALUES should be converted before binding
Test cases:
Detach IDENTITY column tests from UNIQUE KEY tests, create a dedicated test suite instead

New in jOOQ 2.0.0 (Jan 9, 2012)

Most important changes:
The API became more static. This applies to many Factory methods, such as val(), literal(), as well as to many Field methods that have been moved over to the Factory. For example, when before, you wrote this using "postfix function notation":
NAME.replace(" ", "_").trim()
you will now write (just as in SQL):
trim(replace(NAME, " ", "_"))
Using static imports of Factory.*, jOOQ makes SQL look even more like SQL. The current "postfix notation" is maintained for backwards compatibility.
By default, jooq-codegen will now generate a "dynamic" meta model as opposed to the existing static one. Generated tables covariantly override the as(String) aliasing method, leading to a much more convenient aliasing style. When before, you wrote:
Table parent = T.as("parent");
Table child = T.as("child");
Condition join = parent.getField("ID").equal(child.getField("PARENT_ID"))
You can now write:
T parent = T.as("parent");
T child = T.as("child");
Condition join = parent.ID.equal(child.PARENT_ID)
Of course, the existing notation still works
Exceptions are no longer checked. When previously, the DB's SQLException was propagated to client code, there is now an unchecked DtaAccessException hierarchy, similar to that of Spring. This will eventually give way to a standardised error handling abstraction, in future developments.
Window functions are now constructed from their underlying aggregate functions just like in SQL. For example:
sum(AMOUNT)
sum(AMOUNT).over().partitionBy(ACCOUNT)
This makes for a more concise API, especially when considering future extensions, such as Oracle's KEEP (DENSE_RANK FIRST...) syntax.
More type safety has been introduced regarding various places where generic and types are involved.
This is especially true for INSERT / UPDATE / DELETE statements
Sequences now also have a type
Unsigned number types are now supported in those databases that use them. Unsigned numbers are implemented in jOOU, a spin-off open source project. For convenience, this library is "internalised" into jOOQ, to avoid adding a dependency http://code.google.com/p/joou/
Features and improvements:
Implement improved exception handling
Improve DSL support for field and table aliasing (decrease verbosity)
Add support for MySQL UNSIGNED numeric types
Create static function access
Add support for bitwise operators
Sequences should be mapped to appropriate type (e.g. SMALLINT, INT, BIGINT, etc)
Add support for Oracle / SQL Server CUBE() and ROLLUP() grouping functions
Add support for Oracle / SQL Server GROUPING SETS() function
Add support for Oracle PL/SQL's object-oriented MEMBER PROCEDURES and MEMBER FUNCTIONS
Add to Insert, Update, Delete
Review API typesafety for InsertSetMoreStep set(Field, T) and similar methods
Add Factory.selectCount() convenience method
Let min() max(), etc functions return a new type AggregateFunction. This type can then be used as an entry-point for window functions
Add support for Oracle / SQL Server GROUPING() and GROUPING_ID() functions to be used along with CUBE() and ROLLUP()
Simulate ROLLUP() function for MySQL, using the WITH ROLLUP grouping modifier
Move functions from Field to org.jooq.impl.Factory and make them static
Add power(..., Field) methods
Add {Record.into(Table) | Result.into(Table) | ResultQuery.fetchInto(Table) | Cursor.fetchInto(Table)}
Add various Cursor.fetchOneInto() convenience methods
Add CustomTable, CustomRecord as base classes for more convenience when used with various into(Table) methods
Allow for accessing non-public constructors of Record subtypes
Move some utilities to org.jooq.tools
Generate a reference to every table in a new Tables.java class for improved static access
Add DataTypeException extending DataAccessException in case something went wrong when converting data types
Support converting date time types to java.util.Calendar. This applies to various into(Class) methods, as well as Result.getValue(xx, Class)
Allow for conversion between Long and date/time types, and vice versa
Let the bound of R in TableRecord extend TableRecord, in UpdatableRecord to extend UpdatableRecord
Add support for type Character in Record.into(Class) methods and similar
Accept primitive types, such as int.class for type conversion
CODEGEN: Add static/instance table field configuration
Include license.txt and readme.txt in .jar files' META-INF directory
Make DefaultGeneratorStrategy methods non-final to allow for overriding
Add examples for source code generation of multiple schemata with Maven
Generate a reference to every type in a new UDTs.java class
Add R Factory.newRecord(UDT) for constructing attached UDTRecords
CODEGEN: Add generation-time schema mapping, allowing for re-writing schemata in jooq-codegen
CODEGEN: Add code generation configuration parameter to avoid using the new UByte, UShort, UInteger, ULong wrappers for UNSIGNED number types
Use Oracle's SYS.ALL_SEQUENCES.MAX_VALUE to determine the type of a sequence.
Add List ResultQuery.fetch(Field, Class) and similar methods
Don't consider final member fields in reflection utilities when used with Record.into(Class) and similar methods
In the event of name clash (same name for table and field) generated code has errors
Calling UpdatableRecord.setValue() twice with the same argument causes the changed flag to be reset to false
Always set the changed flag to true in Record.setValue()
Compilation errors in generated source code if MySQL enum values match Java reserved words, such as 'true', 'false', 'new', etc...
Postgres ordering of generated enum literals is unstable
Better document type conversion

New in jOOQ 1.7.0 (Nov 26, 2011)

New in jOOQ 1.6.5 (Aug 29, 2011)

New in jOOQ 1.6.4 (Aug 8, 2011)

New in jOOQ 1.6.3 (Jul 25, 2011)

Features and improvements:
Improve H2 NVL2 support as of H2 1.3.156
Improve H2 ROUND support as of H2 1.3.156
Add README documentation to GitHub
Add more info regarding number of generated artefacts in jooq-codegen logging
Add DataType.isNumeric(), .isString(), .isTemporal(), .isBinary()
Log query as executed by JDBC PreparedStatement when
TRACE logging (without inlining variables)
CURSOR: Add support for selecting from ARRAY types
Use H2's native support of NVL, instead of COALESCE
CURSOR: Add support for selecting from ARRAY types returned from stored functions
API changes (backwards-incompatible):
Map DECIMAL(n, 0) and NUMBER/NUMERIC(n, 0) data types to Byte/Short/Integer/Long/BigInteger instead of BigDecimal in generated source code. Re-generated code will not be compatible!
API changes:
Inconsistent API with Field.lessOrEqualToXXX(). Removed "To" from method name
Deprecate Factory.constant() methods
Test cases:
Add missing integration tests for equalAll(), equalSome() and similar methods
Upgrade H2 to 1.3.158
Bug fixes:
Sybase error : column @p0 not found in nested SELECT
Restore HSQLDB ARRAY support with INFORMATION_SCHEMA change in HSQLDB 2.2.3, and some fixes in 2.2.5
Cannot insert byte[] data with plain SQL
H2 changed JDBC type for ResultSet/CURSOR from 0 to -10, like Oracle
Compilation errors in generated source code if table fields contain spaces
Compilation errors in generated source code if MySQL procedure parameter type contains two comma-separated arguments (like DECIMAL(10,2))
Postgres navigator methods and keys are not re-generated in the same order
Formatting is broken on Result.format() with some special newline characters
Make SQL Server INFORMATION_SCHEMA independent from HSQLDB again, to prevent incompatibility issues
Ingres REAL and FLOAT4 types are generated as FLOAT/FLOAT8 which maps to java.lang.Double, instead of java.lang.Float
Postgres error when binding array that contains null values
NullPointerException when converting an array containing a null value
Bad decoding of JDBC Types BIGINT (to BigInteger instead of Long) and REAL (to BigDecimal instead of Float) when plain SQL tables are involved

New in jOOQ 1.6.2 (Jul 11, 2011)

Features and improvements:
EXPORT: Add Result.formatXML()
CURSOR: Add support for ResultSet type returned from Oracle stored procedures / functions
Allow for fetching Map (instead of Record) and List (instead of Result)
Add Factory.function() for plain SQL functions
Simulate RPAD and LPAD in SQL Server, Sybase
Add support for Postgres FOR UPDATE OF [table-name] clause
Add support for REPEAT (SQL Server: REPLICATE) function
Nicely format time in StopWatch logging output
Simulate Postgres FOR UPDATE OF [table-name] clause in other dialects
CURSOR: Add Cursor.fetch(int) .fetchOne() .fetchResult(int) .fetchResult()
Add support for MySQL encryption and compression functions
Clarify Javadoc of UpdatableRecord to explain its behaviour when changing the main unique key
EXPORT: Add Result.formatHTML()
Add convenience method UpdatableRecord.copy() in order to reset primary key values for a subsequent INSERT
EXPORT: Add Result.formatCSV()
Implement ResultImpl.equals() and .hashCode()
Implement AbstractStore.equals() and .hashCode()
Add Store.size() to indicate the maximum index of the Store
EXPORT: Add result.formatJSON()
Create separate builds: jooq-core.zip and jooq-with-dependencies.zip
CURSOR: Add support for ResultSet type returned from H2
stored functions
CURSOR: Add support for ResultSet type returned from Postgres stored functions
Add Factory.fetch(String) for executing plain SQL queries that return results
Add ResultQuery.fetchArray() and .fetchOneArray to return Object[][] and Object[]
Always add top and bottom line in Result.format()
Right-align numeric values in Result.format()
Add SUBSTRING function Field.substring(Field, Field) taking fields as arguments
Document risk of SQL injection in plain SQL and literal factory methods
Add LENGTH function as a synonym for CHAR_LENGTH
API changes:
Inconsistent API with Factory.fetch(Table [,Condition]) Let method return Result instead of List
Let Result extend List
Decrease verbosity of plain SQL methods. They will just be called Factory.field() .condition() .table() .query()
Test cases:
Add integration test for code generation of invalid and incomplete types in Oracle
Add integration tests for master data tables with PK types other than NUMBER/INT
Add missing integration tests for TRIM function
Bug fixes:
Improve plain SQL integrity checks for bind variables
CODEGEN: Compilation error in generated source code for databases with table named 'system'
An empty Java package is generated for an empty PL/SQL package. This is unnecessary
CODEGEN: Avoid importing datatypes in generated source code to prevent collisions NullPointerException when creating a Factory with a null SchemaMapping
Master data table code generation is broken for tables with more or less than 3 columns
Add support for the missing Postgres data type "bpchar"
Add support for the missing Sybase data type "int"
Ingres INTEGER data types are not correctly generated HSQLDB Datatype CLOB and BLOB are not supported, when selecting from plain SQL tables
The evil bug: Ingres TRIM function only executes RTRIM UpdatableRecord.store() doesn't work if called after .delete()
Add support for the missing SQLite data type "NULL"
CURSOR: Ensure that Query.execute() runs in a single transaction when Postgres refcursor is involved in the query (this fixes a Postgres JDBC driver flaw) NullPointerException when passing a single literal null bind value to plain SQL methods without casting to Object DB2, Derby, Ingres, Oracle cannot bind null values in plain SQL

New in jOOQ 1.6.1 (Jun 20, 2011)

New in jOOQ 1.6.0 (Jun 6, 2011)

New in jOOQ 1.5.9 (May 16, 2011)

Features:
Added support for window functions
Add support for multi-record INSERT's
Added support for retrieval of IDENTITY values
Use bind variables for LIMIT and OFFSET
Added foreign key relationship meta information to the generated source code
Beautify ResultImpl.toString() method
Automatically cast CONCAT parameters to Field if
necessary
Added support for trigonometric functions
Added support for the sign function
Added support for GREATEST/LEAST functions
Added support for "hyperbolic" functions SINH, COSH, TANH,
and COTH
Added DSL API for INSERT statements
Added DSL API for UPDATE statements
Added DSL API for DELETE statements
Added "Registry" for client code to provide Configurations to jOOQ Attachables
Added support for the TRUNCATE TABLE statement
Generate source code for IDENTITY columns
Added support for boolean conversion to Result, Record, and Store
Allow for schema navigation via generated artefacts
Let stored procedures reference owner package
if applicable
Added NULLS {FIRST | LAST} clause to ORDER BY constructs
Added Factory.getDataType() convenience method
Added Factory.zero() and Factory.one() convenience methods
API changes (jooq):
Weakened type-safety on Field.nvl2()
Deprecated Factory.select(Object...), added .selectOne() and .selectZero() instead
API changes (jooq-meta):
Add ParameterDefinition for stored procedures, instead of reusing ColumnDefinition
Add reference to TableDefinition in ColumnDefinition
Add AttributeDefinition for UDTDefinition, instead of reusing ColumnDefinition
Bug fixes:
Adapt H2 relations generation to H2's correction of information_schema.cross_references
Added integration tests for NESTED SELECTs holding LIMIT clauses
Syntax error when using a field with a reserved name
Fixed Javadoc broken links
Don't cast when cast is unnecessary
INSERT statement should not set all fields for a table
Derby referential code generation is broken, for named foreign keys
Oracle package content is generated in arbitrary order
Syntax error when creating an empty IN condition
Corrected Javadoc in Field.coalesce()

New in jOOQ 1.5.8 (Apr 30, 2011)

New in jOOQ 1.5.6 (Apr 1, 2011)

Features
Added possibility for lazy fetching of data
Added convenience methods for direct invocation of sequences' currval() and nextval() attributes
Created one factory per dialect for better separation of dialect-specific support
Generate a factory for each schema
Opened up base implementations for Field and Condition to allow for custom implementations by client code
Integrate H2 ARRAY types with stored procedures
Documented usage of log4j and java.util.logging
Added support for the NULLIF function
Added Field.between(Field, Field) method
Added trace logging for variable binding and SQL generation methods
Added Field.in(Field...) method
Include release version number in delivered .jar files
Improved configuration setup documentation page
Let Result implement Serializable
Added fetchMap() convenience methods
Added more functions and aggregate functions examples to documentation
Visually improve code generation logging
Removed skipping of unreferenced UDT's, ENUM's and ARRAY's
Improved generated referential code by using fetch() and fetchOne() API
Let UpdatableRecord.store() and delete() return an int to indicate whether the record was actually modified
API changes:
Allow for joining TableLike instead of Table
Added generic type to InsertSelectQuery
Fixed API flaw where SelectOnConditionStep.and() methods and similar ones returned SelectConditionStep, instead of SelectOnConditionStep
Bugfixes:
Corrected referential code generation for foreign keys that reference non-primary unique keys
Corrected referential code generation for multi-field foreign keys
Covered more Factory.executeXXX() methods with integration tests
Fixed NullPointerException when executing SELECT * from aliased tables
BetweenCondition does not bind left hand side Field correctly
InCondition does not bind left hand side Field correctly
Avoid method overloading where binding to Object may lead to compile-time ambiguities (with javac)
Add more foreign key navigation method integration tests
Add explicit integration tests for schema artefacts excluded from code generation
Disambiguate navigation methods if several foreign keys reference the same entity
Disambiguate navigation methods if a table ending on S references itself
Added integration test for compilation of generated artefacts with javac (as opposed to the Eclipse compiler)
Error when storing an UpdatableRecord that has no changed values

New in jOOQ 1.5.5.2 (Apr 1, 2011)

New in jOOQ 1.5.5.1 (Mar 14, 2011)

New in jOOQ 1.5.5 (Mar 14, 2011)

New in jOOQ 1.5.4 (Mar 14, 2011)

Features:
Support for the Derby RDMBS
Add support for JDBC type ARRAY (with Postgres)
Add support for DB2 sequences
Add support for H2 sequences
Add support for HSQLDB sequences
Support for SQL casting using as cast type
Support for SQL casting using dialect-specific data types
Add HSQLDB support for ARRAY types
Add Oracle support for VARRAY types
Integrate ARRAY types with stored procedures
Add a global type mapping to the generated Schema object
Add DataTypeDefinition for further abstraction of data types in code generation
Add H2 support for ARRAY types
If log4j is not on the classpath, use java.util.logging instead, as fallback
API Changes:
Allow for results to be accessed by index, not by field
Corrected bad method signature: Record.getValueAsLong(Field, Integer)
Extended Result and Select API's to be more similar to that of Record
Add more convenience plain SQL support to the API
Add convenience methods to Record, Result and Select for access of data via field name
Refactor DataType implementations in order to allow for the use of generics
Add field type to database meta data (ColumnDefinition)
Add field type to database meta data (Field)
Add default behaviour for Record.getValue(Field)
Add Javadoc as a ZIP file to the jOOQ distribution
Bugfixes:
Add more plain SQL integration tests
Add more integration tests for nested unions
Implemented workaround for handling Postgres stored functions with UDT OUT parameters
Fixed NPE when generating a stored function with an unknown parameter type
Fixed some cases where binding of BigInteger is not done correctly
Syntax error when using select statement in a CASE clause
Corrected integration tests for combined update and select statements
Added integration test for INSERT statements having nested SELECT statements for their fields
Correctly cast array types in Postgres
Potential misuse of Blob and Clob in H2's JDBC types
Factory.fetchAny() is not implemented for SQLite
Fixed peculiar MySQL casting support where cast types do not match any data types
Fixed NPE when reading null dates in SQLite
Added ARRAY type integration tests
Stored procedure bind variables get mixed up when any argument is null
Correctly handle Postgres function overloading
Ambiguous funciton calls when calling overloaded functions with null parameter
Handle compilation errors when generating stored procedures with > 254 parameters
Fixed compilation errors in generated source code for Oracle's UDT table type
Fixed compilation errors in generated source code for Oracle procedures in packages, when they have no parameters
Fixed compilation errors in generated source code for Oracle tables with the same name in different schemata
Fixed name collisions in generated objects with the java.lang.* package
Prevent the creation of UNION queries with bad syntax in MySQL
Correctly alias fields within UNION queries for some dialects, which then only require the "AS" keyword
Cannot create an aliased field called "year" in Postgres