jOOQ Open Source Edition

jOOQ (Java Object Oriented Querying) Open Source Edition is an open source and freely distributed version of the jOOQ command-line software implemented in Java and designed from the ground up to act as a tool for generating Java code from various databases.

The application includes a fluent API (Application Programming Interface) that allows you to build type safe SQL queries. It is also distributed as two commercial editions, Professional and Enterprise.

Features at a glance

Key features of jOOQ Open Source Edition include support for generating Java code generation, support for active records, type safe SQL query support, SQL standard support, as well as vendor-specific feature support.

In addition, the software offers support for stored procedures, support or shared-schema or multi-schema multi-tenancy, hooks for SQL generation lifecycle, and support for SQL transformations.

Supports a wide variety of open-source databases

As expected, the Open Source Edition of jOOQ supports a wide variety of open-source databases, among which we can mention CUBRID, Apache Derby, Firebird, HSQLDB (HyperSQL DataBase), MySQL Community Edition, PostgreSQL, H2, as well as SQLite.

The commercial editions of jOOQ come with built-in support for all the aforementioned open-source databases, as well as for all the commercial databases, including Microsoft SQL Server, Oracle XE, Oracle Standard Edition, Oracle Enterprise Edition, Informix, IBM DB2, MySQL Enterprise Edition, Sybase Adaptive Server Enterprise and Sybase SQL Anywhere.

Under the hood and supported operating systems

Taking a look under the hood of jOOQ, we can immediately notice that the application has been written entirely in the Java programming language, which means that is is supported on any computer operating system where the Java Runtime Environment (JRE) is available.

At the moment, it has been successfully tested with numerous distributions of Linux, as well as with Microsoft Windows and Mac OS X operating systems, supporting both 32-bit and 64-bit computer architectures.

What is new in this release:

• Features and Improvements:
• #659 - Add support for SQL Azure
• #1206 - Add Table.leftAntiJoin(Table).on(...) and Table.leftSemiJoin(Table).on(...) to simplify usage of [NOT] EXISTS / IN
• #1350 - Add support for the VERTICA database
• #1364 - Generate toString() on POJOs
• #1503 - Emulate INSERT .. ON DUPLICATE KEY IGNORE in remaining dialects, using INSERT .. SELECT WHERE NOT EXISTS
• #1711 - Add Map ResultQuery.fetchGroups(Class, Class) and many others
• #1843 - Add section to the manual showing how to use jOOQ with JPA native query
• #2728 - Add support for Amazon Redshift
• #2920 - Emulate CROSS APPLY as LATERAL JOIN for PostgreSQL
• #3082 - Let generated POJOs reference Java array types, instead of ArrayRecords
• #3645 - Let jOOQ require Java 8 - Keep supporting Java 6 in commercial editions
• #3772 - Publish manual also in EPUB format
• #3783 - Add Field DSL.currentSchema()
• #3887 - Support SAP HANA UPSERT
• #3955 - Add a flag to DefaultTransactionProvider to disable the support for nested transactions via savepoints
• #4006 - Add Field array(Field...)
• #4016 - Add support for the SQL Standard NTH_VALUE window function
• #4113 - Add Field[] { Cursor | Record | RecordType | Result | Row | TableLike | UDT }.fields( { Field... | int... | String... } ) for convenience
• #4133 - Add table name to formatJSON(), formatXML() export formats
• #4212 - Add LoaderSourceStep.loadRecords(Iterable)
• #4476 - Issue a warning when Record.field(Field) runs into ambiguous columns
• #4479 - DSLContext should implement AutoCloseable, in case it was constructed via DSL.using(String)
• #4489 - Upgrade Hibernate dependency in jOOQ-meta-extensions to 5.0
• #4502 - Add org.jooq.Results extends List and return this type on fetchMany() calls
• #4505 - Add Maven plugin skip property
• #4508 - Add DSL.condition(Map) to construct a predicate from a field=>value map
• #4511 - Log a warning when a user accidentally sets the fetchSize with autoCommit == true in PostgreSQL
• #4515 - Emulate POSITION() with INSTR() in SQLite
• #4523 - Add the @ SafeVarargs annotation to all methods taking Field... and similar arguments
• #4524 - Add missing DSL.field(String, DataType, QueryPart...) method
• #4530 - Add support for boolAnd(Condition), boolAnd(Field), boolOr(Condition), boolOr(Field)
• #4535 - Make existing join() a synonym for a new innerJoin() method
• #4536 - Make existing { left | right } OuterJoin() a synonym for a new { left | right }Join() method
• #4537 - Let GenerationTool accept multiple argument configurations
• #4538 - Add Constants.XSD_EXPORT and NS_EXPORT
• #4552 - Add DSLContext.connection(ConnectionRunnable)
• #4553 - Add @FunctionalInterface annotation to all relevant callback types
• #4555 - Ensure batches are sent
• #4562 - Do not escape dot in table names during code generation, but use capital case after it
• #4565 - Add Optional support to org.jooq.tools.Convert
• #4566 - Let ArrayRecord extend List
• #4587 - Add Schema ArrayRecord.getSchema()
• #4591 - .zip deliverable should contain a project folder inside of the .zip file
• #4594 - Add DSLContext.query(SQL) etc
• #4597 - Log warning when doesn't have any matching SQLDataType or
• #4600 - Add support for plain SQL APIs via Scala string interpolation
• Breaking changes:
• #4326 - CREATE SEQUENCE statement lets sequences start with MIN_VALUE, not 1 in Derby
• #4423 - Relax type constraint of DSL.shl() and DSL.shr()
• #4459 - Result.formatHTML() doesn't escape HTML content, which might produce XSS vulnerabilities
• #4488 - Relax bound on for Table.getIdentity() from
• Bug Fixes:
• #2364 - Multi-Result queries may mix ResultSets with update counts. jOOQ doesn't correctly check both in fetchMany()
• #2529 - Cannot combine INSERT .. SELECT with INSERT .. ON DUPLICATE KEY .. due to DSL API flaw
• #2870 - TableOnStep.onKey() generates wrong join condition when left-hand side contains aliases
• #3707 - UDTRecord.toString() doesn't correctly serialise attribute values
• #3779 - Cannot combine INSERT ... SELECT with RETURNING
• #4162 - Malformed record literal when using PostgreSQL array of user-defined types
• #4224 - ORA-00904: "SYS"."ALL_PROCEDURES"."OBJECT_ID": invalid identifier when using the code generator with Oracle 10g
• #4225 - ScalaGenerator logs that it generates XXX.java files
• #4227 - ScalaGenerator should have its own list of reserved words
• #4229 - ScalaGenerator generates unneeded imports
• #4235 - JDBCDatabase calls Meta.getPrimaryKeys() for all schemas, not just for input schemas
• #4236 - Compilation error in compiled code when column is called "null"
• #4240 - JDBCDatabase fetches tables from all schemas, not just from input schemas
• #4246 - HANADataType isn't initialised in SQLDataType's static initialiser block
• #4248 - daoImplements option in MatcherStrategy not generating an implements statement in DAO class
• #4258 - Bad SQL generated for quantified row value expression predicates in Oracle
• #4262 - Manual tutorial should import java.sql.*;
• #4268 - INSERT .. VALUES clause should be rendered on a new line when rendering formatted SQL
• #4269 - No columns generated for PostgreSQL SETOF [ scalar type ]
• #4280 - Document MySQL connector's fetchSize behaviour in ResultQuery.fetchSize()
• #4286 - Manual SQL vs. jOOQ code example are not equivalent
• #4287 - Remove unused import org.jooq.Row in generated records
• #4290 - DefaultTransactionProvider should not cache Connection instance
• #4291 - Add HANA to manual documentation page about DUAL
• #4292 - Wrong emulation of "grand total" GROUP BY () clause in dialects that do not natively support them
• #4295 - Common Table Expression declarations don't set the Context.subquery() flag
• #4300 - DROP SEQUENCE IF EXISTS implemented incorrectly in Sybase SQL Anywhere
• #4306 - ArrayRecord doesn't correctly implement runtime schema mapping for Oracle
• #4308 - SQLSERVER2014 dialect doesn't generate correct LIMIT .. OFFSET clause
• #4313 - NullPointerException in code generator when bypassing GenerationTool without initialising all Lists and String[] to empty objects in Database
• #4314 - SQL Server UPDATE .. FROM illegally declares aliased tables in UPDATE clause
• #4321 - Invalid SQL generated when using nullable data types in Derby CREATE TABLE and ALTER TABLE statements
• #4324 - DROP SEQUENCE statement has a mandatory RESTRICT keyword in Derby
• #4328 - Bad implementation of ALTER TABLE .. ALTER COLUMN .. SET DATA TYPE in Derby
• #4331 - REFERENCES .. ON { DELETE | UPDATE } SET DEFAULT is currently not supported by Derby
• #4333 - Firebird CREATE TABLE regression when columns are nullable
• #4335 - Missing @Support for Firebird for CREATE TABLE statements
• #4341 - No Results are fetched from SQL Server procedures that contain update counts
• #4344 - MockStatement returns wrong update counts
• #4347 - Bad code generated for OBJECT type referencing OBJECT type from different schema
• #4348 - Missing documentation for
• #4349 - The trial / pro license is accidentally delivered with the Open Source Edition
• #4354 - Javadoc warning generated for Result.into(Field, Field, ..., Field)
• #4355 - Regression with caused by formatting of @Generated annotation
• #4358 - Wrong @Support value for SQLite which doesn't support ALTER TABLE .. DROP, SET, ADD CONSTRAINT, etc.
• #4360 - DSL.timestamp() generates wrong output in SQLite
• #4367 - Wrong implementation of MergeImpl.andNot(Field) and orNot(Field)
• #4372 - UDTRecord is not "attached" when fetched from standalone stored function call
• #4381 - No enums generated in MySQL when contains matcher
• #4385 - Missing @Support annotation in MySQLDSL
• #4391 - Example exception translator should only translate SQLException
• #4399 - DSLContext.meta().getTables() returns empty fields list for table that are not in the current schema in MySQL
• #4406 - Manual refers to bad list of supported RDBMS
• #4409 - Bad syntax generated for MySQL's ALTER TABLE .. SET DEFAULT statement
• #4412 - Manual section about custom data type binding contains bad link
• #4417 - Typo in some plain SQL query part Javadocs
• #4428 - DELETE .. RETURNING is unavailable without WHERE
• #4430 - Fix routine parameter code generation for types with a binding
• #4437 - Row value expression IN predicate fails with empty rows collection
• #4440 - fetchMany() doesn't work with CUBRID
• #4447 - Empty GROUP BY () clause emulation fails in CUBRID
• #4466 - Missing CAST() in DSL.dateAdd() when the whole expression is wrapped in a cast
• #4471 - Record.getValue(Field) returns wrong value if ambiguous column names are contained in the record, and the schema name is not present in the argument
• #4481 - Missing parentheses when DSL.dateDiff(d1, d2) or timestampDiff(d1, d2) renders "d1 - d2"
• #4490 - Record not attached to Configuration yet, when RecordListener.exception() is called.
• #4494 - getSQL() method not available in CustomField.bind() as documented in the manual
• #4506 - Wrapping condition as field should produce parentheses
• #4510 - Manual typo. Local variable does not exist
• #4526 - ScalaGenerator generates broken code when using xxxImplements
• #4531 - Generated schema and generated Sequences classes import each other, which generates warnings (unused import)
• #4540 - Performance of org.jooq.impl.Fields.field(Field) could be improved heavily, if checking for identity first
• #4545 - Error generating code for Oracle Package in Oracle 10g
• #4547 - Package is not generated when an exception is thrown
• #4554 - DSLContext#batch(Query) silently discards queries
• #4557 - ExceptionTranslator in spring examples shouldn't use dialect.name() for SQLErrorCodeSQLExceptionTranslator
• #4563 - Incorrect Javadoc on DefaultRecordMapper claims that only public members / methods are considered
• #4569 - Manual refers to deprecated DefaultGenerator
• #4575 - SQL comments with javadoc terminators break generated code
• #4576 - JavaWriter uses regex syntax unsupported in Java

What is new in version 3.5.1:

• Bug fixes:
• #3378 Error when fully qualifying PostgreSQL table-valued functions in SELECT clauses
• #3803 CREATE TABLE statement does not generate NOT NULL constraint
• #3811 Potential NullPointerException in Cursor.fetchOne(RecordMapper) and other methods
• #3817 When used with set operations, ORDER BY must not contain any qualified fields
• #3819 Add Constants.XSD_META and Constants.NS_META to describe the new jooq-meta-x.x.xsd
• #3822 Invalid SQL for Postgres created with values(Row1...)
• #3824 PostgreSQL dateAdd() erroneously returns a TIMESTAMP value
• #3831 deprecation warning is displayed even if the flag is not active
• #3833 org.jooq.CreateTableAsStep.column(Field field, DataType type) SQLite
• #3835 SQLite's CREATE VIEW statement doesn't allow to rename columns
• #3838 Bad @Support annotations on ALTER TABLE statements, which are not supported by SQLite
• #3855 Oracle REAL and FLOAT types cause code generator to produce BigInteger instead of Double types
• #3863 CSV-Export with delimiter only does not work properly
• #3880 Cannot access private JavaGenerator.newJavaWriter() method
• #3888 Data type conversion fails when using a Binding and passing a byte[] as user input
• #3895 The free trial version no longer works after Jan 01, 2015

What is new in version 3.5.0:

• The new Binding SPI:
• The main improvement of this exciting release is the new org.jooq.Binding SPI which can be used to fully control all aspects of a user-type's JDBC interaction. This goes much further than the existing org.jooq.Converter SPI that can be used to map standard JDBC types to user-types. With the new Binding SPI, virtually *ALL* vendor-specific types can be supported now. Examples include PostgreSQL's JSON or HSTORE types, or Oracle's DATE type - which is really incorrectly represented via java.sql.Timestamp, which is why we have retrofitted the existing feature to use such bindings, now.
• Stored procedures are everywhere:
• Stored procedure support was generally improved in this release. This includes lots of new little features and conveniences for use with PL/SQL or Transact-SQL. For instance, jOOQ 3.5.0 now supports cross-schema references of PL/SQL OBJECT and TABLE types, which allows for binding directly to Oracle Spatial. We've blogged about this exciting improvement here: http://blog.jooq.org/2014/11/04/painless-access-from-java-to-plsql-procedures-with-jooq/
• And while we were at it, we've also added basic support for Oracle AQ, which integrates very nicely with our OBJECT type support!
• In Transact-SQL and MySQL, we now support fetching arbitrary numbers of Results from stored procedures, and we've also implemented support for Firebird PSQL, including Firebird's very interesting syntax for table-valued functions.
• By the way, we support user-defined aggregate functions for a variety of databases, including Oracle, PostgreSQL, and HSQLDB. Definitely something you should look into!
• SQL improvements;
• In this release, we've finally got support for UNION, INTERSECT, and EXCEPT right with respect to nesting such operations, as well as combining them with ORDER BY and LIMIT .. OFFSET.
• Let's talk some more DDL:
• We've continued to add support for DDL statements, including
• CREATE TABLE
• CREATE TABLE AS SELECT
• CREATE VIEW and DROP VIEW
• CREATE INDEX and DROP INDEX
• CREATE SEQUENCE and DROP SEQUENCE
• DROP .. IF EXISTS
• We'll continue to add support for more DDL statements also in the future.
• Code generation improvements:
• We've added support for the new XMLDatabase, a code generation configuration that allows to read meta information from XML formats, e.g. from a standard INFORMATION_SCHEMA.xml, or from Vertabelo's XML export format: http://blog.jooq.org/2014/09/05/importing-your-erd-export-into-jooq/
• Future versions of jOOQ will include built-in support for a variety of XML formats.
• We've had an awesome contribution by Etienne Studer from Gradleware to help our users integrate the jOOQ code generation with their Gradle builds.
• Last but not least: Informix!:
• Oh, and by the way, we now also support IBM's second most popular database: Informix. Support for this database will be included in the jOOQ Enterprise Edition.
• Features and improvements:
• #561 Add support for the Informix database
• #994 Add support for the Postgres "hstore" data type
• #1341 Add DSL.using(String url) and other methods that mimick DriverManager.getConnection()
• #1380 Generate equals(), hashCode() on POJOs
• #1392 Add formatInsert() to render insert statements from a Result
• #1410 Add support for the Postgres "DISTINCT ON" clause
• #1658 Add support for SQL standard UNION syntax. jOOQ's current understanding of UNION is just convenience
• #1761 Reference manual versions between each other
• #2054 Implement quantified comparison predicates for Row[N] row value expressions
• #2155 Add Converter support to Routines and UDTs
• #2209 Add Result Result.into(Field, Field, .., Field) in order to transform Results / Records into another type
• #2289 Add jOOQ-flyway-example, a documentation module to show how to integrate with Flyway
• #2604 Add section to the manual explaining how asynchronous querying can be achieved
• #2674 Add support for stored procedures in MockConnection / MockDataProvider / MockExecuteContext
• #2788 Add support for the PostgreSQL "json" data type
• #2886 jooq-codegen-maven should look into project dependencies for jdbc driver
• #2907 Emulate UPDATE .. RETURNING through SELECT FROM FINAL TABLE (UPDATE ...) in DB2
• #2925 Add support for Firebird stored procedures
• #3121 Skip code re-generation when schema is known to be the same
• #3151 Add "question mark" with tool-tip to the manual to allow for jumping to the "how to read this manual" section
• #3248 Add support for Binding (i.e. "Type Providers")
• #3337 Add support for the CREATE TABLE statement
• #3339 Add support for CREATE INDEX and DROP INDEX statements
• #3340 Add support for CREATE VIEW and DROP VIEW statements
• #3346 Allow for omitting the JDBC driver property in the code generator
• #3355 Add support for CREATE SEQUENCE and DROP SEQUENCE statements
• #3370 Allow for overriding the class Javadocs for generated objects
• #3375 Add support for PostgreSQL table-valued functions
• #3381 Add support for CREATE TABLE AS statements
• #3386 Add some test cases using Java 8 Streams for functional-relational transformation
• #3388 Replace SQL Server's ROW_NUMBER() OVER(ORDER BY @@version) by ORDER BY (SELECT 0)
• #3389 Add DSLContext.currval(String) and nextval(String) for convenience
• #3412 Add List DSLContext.fetchValues(...) similar to the existing fetchValue(...) methods
• #3418 Add DSL.defaultValue(Field) for convenience
• #3425 Add support for Oracle AQ
• #3431 Add support for MySQL index hints
• #3435 Add support for SQL Server's SELECT .. INTO [new table] syntax
• #3442 Implement MockResultSet.getArray() methods
• #3443 Add support for conversion of values / arrays to the JDBC Array type in Convert
• #3444 Add MockArray, a mock implementation of JDBC's Array type
• #3451 Add XMLDatabase to generate a database schema from an XML file
• #3477 Add Field.as(Field) to rename a field to another field's name
• #3480 Add XXXContext.dialect() and XXXContext.family() for convenience
• #3483 Let 's match both fully qualified column names as well as unqualified column names
• #3495 Add an example project showing how to use jOOQ's code generator with Gradle
• #3496 Log a DEBUG message when a Query is executed which returns Query.isExecutable() == false
• #3501 Add ResultQuery.fetchSet() and Result.intoSet() methods to return LinkedHashSets
• #3506 Instrument the jOOQ API during integration tests to verify correct application of @Support annotations
• #3511 Improve DISTINCT predicate emulation through INTERSECT
• #3512 Add DSL.count(Table) and DSL.countDistinct(Table) to support the PostgreSQL-specific COUNT() extension
• #3513 Streaming version of formatCSV/formatXML
• #3519 Document the PostgreSQL JDBC's limitations with respect to large cursors when using Connection.autoCommit = true
• #3525 Implement more verbose DEBUG logging for jOOQ-meta's include / exclude mechanism
• #3532 Add support for DROP ... IF EXISTS clauses in DDL
• #3551 Copy plain SQL query construction API to DSL from DSLContext
• #3557 Add support for PostgreSQL user-defined aggregate functions
• #3558 Add Setting to enable / disable fetching of warnings
• #3559 Propagate jOOQ-codegen's relations flag also to jOOQ-meta, to prevent (possibly expensive) queries to fetch relations
• #3565 Add XXXContext.settings() for convenience
• #3566 Add GenerationTool.generate(String) to generate code from an XML string
• #3569 The tag is no longer mandatory in the code generator configuration
• #3579 Emulate nested set operators in databases that don't support them natively
• #3592 Add Setting to enable Oracle scalar subquery caching for stored function calls
• #3595 Add MockResult(Record data) convenience constructor
• #3596 Let code generator empty generated packages on a per-schema basis
• #3597 Generate table and column comments also for PostgreSQL
• #3598 If tables define their own comments, don't generate "This class is generated by jOOQ." in Javadocs
• #3599 Implement nicer formatting of @Generated annotation
• #3600 Add support for SQL standard SELECT .. WITH CHECK OPTION
• #3610 Explain the differences between keeping generated sources under version control or not
• #3611 Add a jOOQ / Nashorn example to the repository
• #3612 Add an example project showing how to import an ERD export format to the code generator
• #3622 Add support for Field.in(Result) and Row[N].in(Result)
• #3623 Add ParamType.NAMED_OR_INLINED to render named parameters only if a name is given
• #3626 Add Map Result.intoGroups(Table)
• #3627 Add simplified API for CASE WHEN [ condition ] THEN [ select ] expressions
• #3628 Add Field DSL.field(Select)
• #3752 Make element optional in code generation configuration
• #3754 Explain primitive type conversion in Convert.convert() Javadoc
• #3756 Regenerate files only if there is a difference
• #3760 Add Record.intoList()
• #3769 Add org.jooq.Converters, a chained Converter implementation
• #3773 Explain jOOQ's understanding of Configuration thread safety in the Configuration Javadoc
• #3775 Let QueryPart.toString() generate formatted SQL
• #3782 Add a method to create a org.jooq.util.Database by SQLDialect
• API changes (backwards-compatible):
• #3345 Deprecate org.jooq.api.annotation.State and Transition annotations
• #3356 Deprecate Select.fetchCount()
• #3703 Deprecate CastMode.SOME and RenderContext.cast()
• #3770 Deprecate
• API changes (backwards-incompatible)
• Behavioural changes (backwards-incompatible):
• #2486 Allow to specify precision, scale, length for type-rewrites in
• #3000 Add Setting to enable MySQL backslash escaping
• #3407 DDL statements accepting String names should generate quoted names, not plain SQL
• #3541 Change DSLContext.nextval(String) and currval(String) to internally call DSL.sequenceByName() instead of DSL.sequence()
• Bug fixes:
• #2080 Syntax error in rendered SQL when using limit().offset() with aliased projections in SQL Server
• #3206 DSL.field(Condition) doesn't correctly handle NULLs when emulating boolean fields with a CASE expression
• #3347 Field.in(T...) should defend against Collection arguments
• #3353 Manual Javadoc anchors are no longer correct with the recent changes of JDK 8 Javadocs
• #3359 store() after copy() executes an UPDATE instead of an INSERT, when Settings.updatablePrimaryKeys is set
• #3360 SQLite regression when using special characters in identifiers
• #3362 DSLContext.batchStore() executes INSERT if records are batch stores are executed two times in a row on new records, if Settings.updatablePrimaryKeys is set to true
• #3363 UpdatableRecord.store() executes UPDATE instead of INSERT after delete(), if Settings.updatablePrimaryKeys is set to true
• #3369 Render CAST(? AS DATE) for java.sql.Timestamp bind values that are bound to Oracle DATE columns
• #3372 The syntheticPrimaryKeys code generation option is currently undocumented
• #3373 The manual's page about the DUAL table does not list all the supported databases
• #3382 NOT NULL constraints and type information are incorrectly generated when using Firebird DOMAINs for data types
• #3390 Add missing documentation about the new jOOQ 3.4 transaction API
• #3392 Call setAccessible(true) only if really needed
• #3400 ALTER TABLE generates invalid syntax on Firebird when data types are nullable
• #3402 Wrong character length generated by jOOQ for Firebird
• #3408 Remove the default log4j.xml configuration file from the maven plugin again
• #3413 Oracle generated ArrayRecords cannot be constructed through reflection if deprecated flag is set to off
• #3420 NullPointerException when generating code for Oracle AQ Tables
• #3427 Internal QueryCollectorSignal exception escapes into user code when not dealt with in ExecuteListener
• #3430 JDBC escape syntax is not correctly rendered from plain SQL when plain SQL contains newlines
• #3436 Manual sections about transactions documents ctx to be a DSLContext instead of Configuration
• #3437 QualifiedField does not respect RenderContext.qualify()
• #3445 Cannot run Maven code generator with professional edition
• #3450 Backslashes in SQL comments don't get escaped
• #3455 UPDATE .. FROM statement renders incorrect SQL for derived tables or aliased tables
• #3456 Name clash in generated code when Routine argument is called "f" (functions) or "p" (procedures)
• #3462 Field.in(Object...) can be called with Select arguments, accidentally
• #3463 Field.in(...) methods shouldn't return trueCondition() or falseCondition()
• #3473 java.lang.IllegalArgumentException: Field (null) is not contained in Row
• #3488 Compilation error in generated code, when a similar tables T_A and TA exist
• #3489 DefaultTransactionProvider does not call Connection.releaseSavepoint(Savepoint) after commit
• #3507 Bad @Support annotation on Select.intersect() and Select.except()
• #3514 ResultQuery.fetchLazy() ignores fetchSize()
• #3520 Duplicate column information in foreign key references for foreign keys that share the same name in different tables
• #3526 Unnecessary warning logs introduced in code generation
• #3533 Avoid using named parameters for Oracle, if not really needed
• #3537 Incorrect call to releaseSavepoint()
• #3542 Oracle DDL statements do not allow for using bind variables
• #3544 Add a DDLQuery marker interface, which all DDL Query types should extend
• #3545 Error when using qualified, case-sensitive sequence names in H2
• #3547 DSLContext.batch(String) doesn't accept bind variables
• #3552 Oracle Stored procedures using type synonyms in signatures cannot be used through jOOQ
• #3556 Generated Oracle Stored procedures do not reference types from other schemas
• #3560 Slow discovery of primary keys in very large MySQL databases
• #3567 Code generator error message refers to wrong XSD
• #3577 Don't render "empty" OFFSET 0 clauses
• #3578 Slight manual bug referring to inexistent ExecuteContext.dialect() method
• #3582 Record.from(Object) does not consider DataType.nullable() which may lead to constraint violations when inserting
• #3586 Context.paramType() is initially null instead of INDEXED
• #3590 Manual erroneously claims that the SQL standard allows SELECT without FROM
• #3591 Compilation error generated in manual's tutorial code
• #3602 Cannot INSERT into view
• #3608 Typo in documentation of transaction method
• #3624 Compilation errors when Converters are applied to generated Routines and UDTs
• #3630 ArrayOutOfBoundsException when using backslash escaping in MySQL with jOOQ plain SQL
• #3634 Record.into(Table) maps to the wrong table when passing an aliased table after a self-join
• #3639 java.lang.NoSuchMethodException: createARRAY when using Oracle arrays with Spring TransactionAwareDataSourceProxy
• #3648 Use JDBC Escape syntax for MySQL Date / Time literals to circumvent a known MySQL bug
• #3650 NullPointerException on TableRecord.insert() when primary key information is not present
• #3664 UNION ALL, ORDER BY, and LIMIT regression
• #3665 Typos in Javadocs
• #3673 OracleDSL.toChar() methods shouldn't require String types
• #3682 PostgreSQL INSERT .. RETURNING doesn't work with plain SQL table
• #3696 OutOfMemoryError with SQL Azure, caused by long-running loop of consuming further exceptions
• #3705 The jOOQ "flash log" doesn't display nicely when using java.util.logging
• #3711 Incorrect code generated for cross-schema OBJECT type references
• #3718 Exceptions on rollback hide the original exceptions causing the rollback
• #3723 Add org.jooq.Scope to unify all Configuration, Settings, and data map access in a single API
• #3730 Cannot use regex COMMENTS in 's
• #3732 Improve performance of regex evaluation
• #3733 Code generator should use CHAR_LENGTH columns for Oracle, instead of DATA_LENGTH
• #3741 MySQL ResultSet streaming conflicts with internal SHOW WARNINGS call
• #3758 ExecuteListener.warning() is not listed as a method in the Javadoc
• #3762 Bad emulation of DUAL table in HSQLDB when connecting with a DBA user on a database with more than one user
• #3792 Code generator erroneously refers to "singleton instances" of tables in generated Javadoc

What is new in version 3.3.0:

• Features and improvements:
• #531 Add support for the WINDOW clause
• #845 Add support for the T-SQL and Oracle 12c CROSS APPLY clause
• #846 Add support for the T-SQL and Oracle 12c OUTER APPLY clause
• #1070 Add support for SQL Server table-valued functions
• #1506 Allow for inserting empty records through INSERT INTO .. DEFAULT VALUES
• #2093 Add comment functionality from DISQUS to website
• #2246 Add T DSLContext.fetchValue(Select) to support more typesafety when fetching single values
• #2576 Integrate with Travis-CI to run automated builds
• #2657 Add support for ORDER BY .. SEEK .. LIMIT to implement the "seek method" for faster offsets
• #2709 Add Record[N].value1(xx), value2(xx) setter methods
• #2734 Add support for lateral derived tables
• #2744 Emulate INSERT .. RETURNING through SELECT FROM FINAL TABLE (INSERT ...) in DB2
• #2767 Add support for CUBRID 9.2 features
• #2776 Add support for the PostgreSQL ONLY clause
• #2778 Add detailed section to the manual about settings.xml
• #2779 Add support for LEFT(), RIGHT() functions
• #2780 Add PostgresDSL.oid(Table) to produce table.oid references
• #2784 Add DSL.row(Collection) to allow for interacting with collections of values or Fields
• #2790 Add a Context data map scoped to the current subquery
• #2801 Mention licensing options from the manual, add help message to jOOQ-Codegen when OSS users try using commercial databases
• #2805 Add seekAfter() and seekBefore() to allow for paging in both directions
• #2806 Add ResultQuery.fetchSize() to influence the JDBC Statement's fetch size
• #2809 Add support for MySQL's MID() function, which is a synonym for SUBSTRING()
• #2810 Add support for the REVERSE() function, where it is supported
• #2824 Log 500 records on TRACE level, instead of just 5
• #2828 Use a default Database for code generation, in the absence of an explicit database
• #2829 Enhance Loader API to allow for importing JSON data in addition to CSV data
• #2832 Add OracleDSL.toChar()
• #2838 Add more sophisticated CustomField example to the manual
• #2840 Add DSL.date(), DSL.time(), and DSL.timestamp() to extract date, time, timestamp parts from a TIMESTAMP
• #2844 Let JAXB emit more warnings when loading the code generation configuration
• #2848 Add support for infix-notation for bitwise operations
• #2851 Add some documentation to the manual about custom code sections in generated code
• #2853 Add DSLContext.fetchFromJSON()
• #2854 Add a JAX-RS (with Spring) and jOOQ example to the manual
• #2860 Add manual section about using jOOQ with Groovy
• #2876 Add some Javadoc about the fact that some SQLDialects are available in commercial distributions only.
• #2883 Add support for PostgreSQL COUNT(DISTINCT(a, b, ...)) through DSL.countDistinct()
• #2885 Generated enum values contain extra comma
• #2891 Add a jOOQ / Spring-TX example to GitHub under jOOQ-examples
• #2894 Enable automated CI on github
• #2898 Add DSL.generateSeries(int, Field) and (Field, int) overloads
• #2900 Overload MockFileDatabase constructor to allow for Readers, InputStreams, and Strings
• #2909 Improve manual's jOOQ syntax highlighting: Highlight SQL keywords
• #2912 Add convenience methods set(Connection), set(DataSource), derive(Connection), derive(DataSource) to DefaultConfiguration
• #2915 Log JDBC URL in code generator configuration log
• #2921 Add support for ad-hoc table renaming
• #2931 Add DSLContext.fetchCount(Table) and fetchCount(Table, Condition)
• #2932 Retry loading the GenerationTool configuration file with a / prepended if it fails
• #2933 Add {Result.into|ResultQuery.fetch}{Map|Group}({Field|Field[]}, RecordMapper)
• #2944 Add support for GROUP_CONCAT in SQLite
• #2945 Deprecate the code generation flag
• #2946 Add a section to the manual explaining how to programmatically configure the code generator
• #2950 Add Table.getComment() and Field.getComment() to access comment meta information from the schema
• #2969 Add support for SQL Server SOUNDEX() and DIFFERENCE() functions
• #2970 Add DSL.isnull() as a synonym for NVL() for the SQL Server dialect
• #2971 Add DSL.space() to support the SQL Server specific SPACE() function
• #2976 Add bookmarks to the PDF manual
• #2979 Add Maven install scripts (.bat and .sh) to deliverables
• #2981 Add an official Spring / Guice example
• #2984 Add Table table(Result) to allow to fetch from / join / etc in-memory tables
• #2985 Add DSL.values(RowN...)
• #3001 Add VisitContext.clausesLength() and queryPartsLength() to indicate the depth of the currently visited QueryPart tree
• #3002 Add the BindVariableAbbreviator VisitListener example to the manual
• #3009 Add DSL.dateAdd(Field, Field

What is new in version 3.2.3:

• Features and improvements:
• #2780 Add PostgresDSL.oid(Table) to produce table.oid references
• #2979 Add Maven install scripts (.bat and .sh) to deliverables
• #2900 Overload MockFileDatabase constructor to allow for Readers, InputStreams, and Strings
• Bug fixes:
• #2152 Invalid column type: 16, when binding null as java.lang.Boolean onto a NUMBER(..) column in Oracle
• #2887 jooq-codegen-maven should use a target directory relative to the module
• #2910 The new matchers configuration cannot be used with Maven (added documentation)
• #2913 Improve code generator compatibility with PostgreSQL 8.x by removing the selection of INFORMATION_SCHEMA.COLUMNS.IDENTITY_GENERATION
• #2917 Improve code generator compatibility with PostgreSQL 8.x by avoiding casting to enum types
• #2926 Add code-generation support for the MySQL TINYTEXT data type
• #2937 Fix trailing whitespaces in generated code
• #2956 isFalse()/isTrue() result in extra parameters
• #2958 Error when the code-generation database user has insufficient grants to read the "mysql" meta schema
• #2963 Lower log level for warnings about unknown SQL data types from MetaDataFieldProvider (plain SQL)
• #2977 Missing parent pom.xml file in deliverables
• #2982 Variable binding doesn't work in vendor-specific UPDATE t1 JOIN t2 queries, when joined tables are subqueries with bind values
• #2987 Bind values are not debug-logged for standalone stored procedure or function calls

What is new in version 3.2.2:

• Bug fixes:
• #2655 Improve ArrayIndexOutOfBoundsException: -1 error message when unknown field is accessed from a record
• #2835 UpdatableRecord.store() and DSLContext.executeInsert() show different behaviour with respect to NULL value insertion
• #2845 AbstractStoreQuery.prepare() does not apply RenderKeywordStyle when specifying column names for return after INSERT
• #2863 Remove unnecessarily cached Connection in DataSourceConnectionProvider
• #2864 Check if ALL_MVIEW_COMMENTS exists before using it (e.g. against an Oracle 9i database)
• #2866 Wrong implementation for check if ALL_COLUMNS.DEFAULTED exists
• #2868 Disambiguate collisions between enum literals and package names
• #2869 DefaultRecordMapper should attach resulting records according to Settings.attachRecords, if target type implements Attachable
• #2872 Possible StackOverflowError when using plain SQL tables with inlined QueryParts
• #2876 Added a Javadoc remark about certain SQL dialects being available in commercial distributions only
• #2879 An exception in the check constraint loader can cause all constraint loading to fail
• #2798 Inconsistent logic executed between Record.setValue(Field, T) and BookRecord.setId(Integer) (generated)

What is new in version 3.2.0:

• Features and improvements:
• #674 Add code generation flag to let generated setters return this
• #996 Add support for various Postgres ARRAY operations
• #1079 Add support for Oracle's FLASHBACK QUERY clause
• #1171 Add a MatcherStrategy GeneratorStrategy to allow for configurative regex pattern matching and replacement
• #1644 Add DSL.dual() to explicitly create a DUAL table that works with any dialect
• #1903 Duplicate Query construction API between DSLContext and DSL
• #2010 Add listener API to Record / UpdatableRecord
• #2352 Enhance to allow for forcing a type upon all columns / parameters / attributes of a given data type
• #2542 Add a Keyword type and DSL.keyword(String) to construct it
• #2593 Add Meta.getPrimaryKeys()
• #2594 Add primary key and foreign key navigation support in JDBCDatabase
• #2595 Add implicit conversions from Scala functions to RecordMapper
• #2603 Add flag to code generation configuration to indicate that and shall also match column names
• #2606 Distinguish ORACLE10G, ORACLE11G, ORACLE12C SQLDialects within the ORACLE family
• #2618 Document the fact that different packages are generated for different schemas
• #2619 Add an example ExecuteListener to the manual, showing how UPDATE and DELETE statements without WHERE clause can be aborted
• #2630 Add DSL.queryPart(String, Object...) and similar methods to create simple plain SQL query parts
• #2652 Change tutorial to use the common AUTHOR table, instead of POSTS
• #2660 Add some documentation about jOOQ not supporting operator precedence
• #2665 Implement SPI for RenderContext listening to allow for custom SQL transformation
• #2666 Pull up RenderContext.sql(QueryPart) and BindContext.bind(QueryPart) to Context.visit(QueryPart)
• #2667 Add org.jooq.Clause and let org.jooq.Context listen on start(Clause) and end(Clause) events
• #2676 Add QueryPartInternal.clause() to allow for QueryParts to return Clause information to org.jooq.Context
• #2689 Expose a DAO's internal RecordMapper through DAO.mapper()
• #2696 Provide default implementation for CustomQueryPart.bind() (for all Custom QueryParts)
• #2699 Generate DEFAULT and NULL metadata information on generated DataTypes
• #2701 Document the fact that jOOQ sets changed flags to true, even if Record.setValue() sets the value already present in the record
• #2702 Add DataType.defaulted() and DataType.nullable()
• #2706 Generate "full" constructors in records, allowing to construct a record with all values set
• #2713 Add support for custom code sections in generated code
• #2722 Add DSLContext.newRecord(Field...) to support the creation of custom record types
• #2723 Add example VisitListener implementation that prevents UPDATE, DELETE statement execution without explicit WHERE clause
• #2724 The default logger should log the number of affected records, if applicable
• #2725 Add ExecuteContext.rows() to indicate the number of affected rows in the last executed statement
• #2726 Add Attachable.detach()
• #2729 Emulate IS DISTINCT FROM through IS / IS NOT in SQLite
• #2733 Add the default log4j.xml configuration file to the maven plugin
• #2745 Generate default constructor and "assignment-constructor" in POJOs
• #2757 Add support for DB2 10.5
• #2764 Let CRUD operations be able to perform UPDATEs on primary keys
• #2765 Add support for a database-agnostic GENERATE_SERIES(FROM, TO) table function
• API changes (backwards-compatible):
• #2581 Deprecate fetchLater() and FutureResult
• #2662 Deprecate the internal method DSLContext.bind(QueryPart, PreparedStatement)
• #2719 Change various method(Collection>)
• Bug fixes:
• #1908 Compilation error in generated code when a MySQL procedure and function share the same name and signature
• #2534 Correctly handle Oracle BLOB and CLOB data types, when fetched through plain SQL
• #2580 Bad SQL rendered when combining DISTINCT with LIMIT .. OFFSET in DB2, SQL Server
• #2584 ORA-00904: "SYS"."ALL_PROCEDURES"."OBJECT_TYPE": invalid identifier when running code generation with Oracle 10gR1
• #2586 Bad SQL dialect referenced from ASE's and CUBRID's package-info.java
• #2591 Result.intoGroups() and similar methods create key Records with changed=true
• #2592 Qualified names created using DSL.name(String...) should not render null or empty string parts
• #2596 Scala tests don't run with Maven
• #2597 f1.concat(f2).toString() seems to render unnecessary cast expression
• #2608 Error in code generator when the sqlite_sequence table is missing
• #2613 The batch INSERT query example in the manual is no longer correct with jOOQ 3.x
• #2624 Wrong SQL Server 2012 detection in jOOQ-Meta
• #2628 Add missing Javadoc to DefaultDSLContext
• #2634 Minor documentation bug: The MockDataProvider uses toLowerCase() but upper-case SQL keywords
• #2643 Routine.execute(Configuration) should restore the original routine state after execution
• #2681 "Type NULL is not supported in dialect MYSQL" when calling Meta.getTables() with MySQL or MariaDB JDBC drivers
• #2690 Inaccurate runtime xsd versions in 3.1 manual
• #2703 SQLDialect.getNameLC() and getNameUC() are not NPE-safe
• #2707 PostgreSQL ENUM ordering is inconsistent with the database
• #2708 Wrong SQL rendered for CAST(x AS DECIMAL(y, z)). Precision and scale are lost.
• #2712 Field.equalIgnoreCase(String) method broken for SQL Server
• #2714 Documentation bug in INSERT statements. Cannot combine Field with String arguments in VALUES() clause
• #2717 DefaultResultSet compile-time depends on Java 1.7 / JDBC 4.1
• #2718 NullPointerException in code generator when a primary key (or foreign key) column is excluded from code generation
• #2720 Fix the manual's claim that accepts comma-separated regular expressions
• #2730 Immutable Pojo+Interface code generation produces uncompilable pojo
• #2736 Improve code generator compatibility with PostgreSQL 8.x by testing if pg_catalog.pg_enum and information_schema.attributes exist
• #2753 DATE_DIFF() with CURRENT_DATE() returns wrong precision in Oracle
• #2755 Incomplete @Support annotations on OrderedAggregateFunction methods
• #2758 Duplicate primary key column references generated for DB2
• #2759 DSLContext.fetchCount() fails when argument SELECT statement does not explicitly provide column names in SQL Server
• #2760 org.jooq.Meta should treat MySQL databases as Schema, not as Catalog
• #2766 Javadoc typo on DSLContext.batchDelete()

What is new in version 3.1.0:

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

What is new in version 3.0.1:

• #2323 NullPointerException when calling Schema.getTables() on a meta schema with SQLite
• #2401 Bad package name generated when contents are not trimmed
• #2413 Suppress warnings in generated code (@SuppressWarnings("all") doesn't suppress "rawtypes" warnings with javac)
• #2418 RenderContext.data() is not passed on to QueryParts when being rendered
• #2424 Integration-test jOOQ with the SQLite xerial driver
• #2432 Manual refers to a package-private DefaultConfiguration constructor
• #2445 JDBCDatabase doesn't recognise Oracle's VARCHAR2 data type (and other vendor-specific data types)
• #2447 Tables collected through DSLContext.meta() return duplicate columns if multi-schema environments contain identical tables
• #2448 DSLContext.meta() returns Table objects for Oracle SYNONYMS, without providing columns
• #2449 JDBCDatabase doesn't use DataType.length(), precision(), and scale()
• #2450 Cannot set precision on TINYINT, SMALLINT, INT, BIGINT data types
• #2464 Bad SQL rendered from DELETE statements with aliased tables
• #2469 NullPointerException in AbstractResultQuery.fetchOneMap()
• #2477 MySQL's unsigned types cannot be used in other dialects
• #2478 IngresDatabase erroneously joins IIINDEXES to get constraint columns, rather than using IIKEYS

What is new in version 3.0.0:

• 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.

Requirements:

• Java 2 Standard Edition Runtime Environment