jOOQ Changelog

What's new in jOOQ 3.6.2

Jun 24, 2015

Bug fixes:
#4162 - Malformed record literal when using PostgreSQL array of user-defined types
#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
#4269 - No columns generated for PostgreSQL SETOF [ scalar type ]
#4287 - Remove unused import org.jooq.Row in generated records
#4292 - Wrong emulation of "grand total" GROUP BY () clause in dialects that do not natively support them
#4300 - DROP SEQUENCE IF EXISTS implemented incorrectly in Sybase SQL Anywhere
#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 for Derby
#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
#4341 - No Results are fetched from SQL Server procedures that contain update counts
#4344 - MockStatement returns wrong update counts
#4349 - The trial / pro license is accidentally delivered with the Open Source Edition

New in jOOQ 3.6.1 (Apr 30, 2015)

New in jOOQ 3.6.0 (Apr 25, 2015)

We've been working hard to add support for our 18th database dialect: SAP HANA,
which is now officially supported by the jOOQ Enterprise Edition. HANA is SAP's
excellent Big Data offering, supporting column stores combined with the power of
SQL standard OLAP functionality, such as window functions. Integrate HANA into
your Java or Scala applications with ease, using jOOQ!
LET'S TALK SCALA:
We're glad to welcome an increasingly big jOOQ-for-Scala community, an
integration where jOOQ really shines thanks to some advanced Scala language
features. In order to help you integrate even better, we've now added the new
ScalaGenerator that generates jOOQ meta data classes in Scala, instead of Java
INTEGRATE YOUR CODE GENERATION WITH JPA OR VERTABELO:
In the previous release, we've implemented a new XMLDatabase that can load
arbitrary XML schema metadata formats (via XSLT). We've taken this a step
further using our new jOOQ-meta-extensions artefact, which hosts alternative
meta data sources, such as your JPA-annotated classes, or Vertabelo exports.
SPEAKING OF XML:
Our XML-in-the-database integration just got better! We're showing you in a
couple of example Bindings how to get the most out of your vendor-specific data
types, such as XML or JSON - which can be integrated into your jOOQ queries
effortlessly!
LET'S TALK SOME MORE DDL:
This release also adds support for a couple of additional DDL statements that
help you standardise your schema migrations for our 18 RDBMS. The newly
supported statements are:
- ALTER TABLE ADD CONSTRAINT (with UNIQUE, PRIMARY KEY, FOREIGN KEY, CHECK)
- ALTER TABLE DROP CONSTRAINT
- CREATE TEMPORARY TABLE
SQL 2 JOOQ PARSER:
One year ago, we've added the GUDU Software SQL 2 jOOQ parser with our
deliverables. While we still believe that this is an excellent product, we have
seen little demand from our users and customers - which is why we no longer ship
the parser. You can still download it from GUDU Software.
MULTISET AND NESTED RECORDS:
While we have published (as promised) some API for nested record support, we're
not quite convinced of its design yet. This is why this API is still marked as
"experimental". Stay tuned for future releases when we'll take these advanced
ORDBMS features one step further.
Tons of new convenience API and bugfixes:
jOOQ wouldn't be jOOQ if it wasn't for the myriad convenience methods that make
your SQL integration lives so much easier. We've listened to our users and
customers and added another bulk of useful fetch(), execute(), map() and many
other convenience methods that make your SQL integration fun and efficient.
FEATURES AND IMPROVEMENTS:
#231 - Add BlobBinding and ClobBinding to use java.sql.Blob and java.sql.Clob on a JDBC level
#584 - Add a XMLasDOMBinding that can be used to bind SQLXML data types to org.w3c.dom.Node
#1363 - Generate a copy constructor for POJOs
#1391 - Add support for the Postgres "every" aggregate function
#1464 - Allow for a plugin architecture in jooq-meta, jooq-codegen, for custom schema-sources and generation-targets
#2221 - The manual's section about "Reusing a Query's PreparedStatement" does not mention what the behaviour is, when the underlying Connection is closed
#2498 - Add support for SQL Standard PERCENTILE_CONT() and PERCENTILE_DISC() inverse distribution functions
#2626 - Add org.jooq.SQL as a plain SQL type (for templating)
#2639 - Add stored procedure OUT values to DEBUG log output
#2664 - Add flag to Loader API to enable batch execution
#2686 - Add Result.fetchParents(ForeignKey) and Result.fetchChildren(ForeignKey) to fetch relations in a single query
#2899 - Support generating code based on JPA annotations
#2905 - Add support for named parameters in BatchBindStep.bind()
#2919 - Distinguish various PostgreSQL versions in the PostgreSQL family: 9.3, 9.4
#2936 - Move .settings, and other Eclipse-related artefacts in a separate place
#3052 - Add a section to the manual explaining table-valued functions
#3188 - Add support for LEAD() / LAG() with Row[N] arguments
#3329 - Support the SQL standard array_agg function
#3336 - Add code generation flag to enable / disable imports in generated code
#3338 - Add support for ALTER TABLE ADD CONSTRAINT .. UNIQUE, PRIMARY KEY statements
#3376 - Add support for PostgreSQL SETOF functions
#3614 - DefaultRecordMapper only sets declared fields of the target type, no inherited fields
#3620 - Add section to the manual explaining how to use jOOQ with Nashorn
#3643 - Ensure that JPA annotations on private members are considered correctly
#3649 - Support DELETE FROM ... RETURNING
#3706 - Add a paragraph to the manual explaining how to manually unmarshal code generation Configuration via JAXB
#3708 - Emit a newline character when performing formatted logging
#3712 - Add Oracle Spatial examples
#3717 - Use try-with-resources in manual and tutorial
#3734 - Implement "$0" as a default expression in matcher strategy rules
#3744 - Add more precise subtypes for InvalidResultException
#3748 - Add public Routine T getValue(Parameter) and setValue(Parameter, T) methods
#3765 - Add support for HANA
#3781 - Add support for DSL.trunc(date, DatePart) for H2
#3784 - Add additional flags to prevent generation of individual reference classes
#3797 - For table-valued functions, generate also a static method in Tables.java
#3800 - jOOQ-Meta should log formatted queries on exception
#3801 - Add Result#intoMap and Result#intoGroups variants that take field index or field name
#3808 - Improve manual's section about batching by making it clear that bind() binds records, not individual values
#3810 - Add fetchOne(RecordMapper) shortcut method to ResultQuery
#3816 - Use char literals instead of single-character String constants where applicable
#3819 - Add Constants.XSD_META and Constants.NS_META to describe the new jooq-meta-x.x.xsd
#3830 - Add support for XSL transformation to XMLDatabase
#3840 - Add a JavaEE example project with EJB and JSF
#3842 - Add DSL.field(Name), DSL.table(Name), DSL.schema(Name), DSL.sequence(Name) methods
#3843 - Deprecate DSL.fieldByName(), DSL.tableByName(), DSL.schemaByName(), DSL.sequenceByName()
#3844 - Add a new SQLDialect.DEFAULT instead of SQL99
#3846 - Let examples work with latest release, not with SNAPSHOTs
#3847 - Document the fact that Collection

New in jOOQ 3.5.4 (Apr 2, 2015)

New in jOOQ 3.5.3 (Feb 24, 2015)

New in jOOQ 3.5.2 (Feb 11, 2015)

Features and improvements:
#4019 - Add system property to remove the logo from the log output
Bug fixes:
#3745 - NullPointerException when is not provided and isn't provided either
#3778 - PostgreSQL enum array types have to be cast with their fully qualified name
#3909 - Inefficient number to number conversion in org.jooq.tools.Convert
#3915 - Calls to Configuration.derive() create a Configuration that indirectly references the previous Configuration instance
#3919 - Bad caching of JPA-annotated getters leads to wrong mapping into POJOs that have @ConstructorProperties
#3924 - Four octects are sent to Postgres for each negative byte in a byte[]
#3932 - jooq-runtime-3.5.0.xsd declares wrong namespace
#3936 - AbstractQuery unnecessarily creates two DefaultRenderContext instances
#3946 - Replace ArrayList by ExecuteListener[] in ExecuteListeners to avoid excessive Iterator creation
#3947 - Avoid creating unnecessary Iterators and ArrayLists in AbstractStore.getAttachables()
#3957 - java.lang.NoSuchMethodException: createARRAY when using Oracle arrays with BoneCP
#3962 - The H2 emulation of SHR might produce rounding errors
#3966 - Inefficient BIT_COUNT() function for those dialects that do not natively support SHR()
#3976 - Code generator does not apply binding to Routines
#3977 - Meta.getTables() also returns entries for indexes for PostgreSQL
#3993 - ResultQuery.fetchAny() methods Javadoc erroneously claims throwing of InvalidResultException
#3998 - Cache internal BindingGetResultSetContext instance across a single Cursor
#4000 - Avoid {ResultSet | CallableStatement | SQLInput).wasNull() calls if not necessary, as they're somewhat expensive on some JDBC drivers
#4017 - jooq-meta-3.5.0.xsd is not valid XSD 1.0
#4022 - NullPointerException when generating SQLite table with composite primary key
#4028 - Loader API's "onDuplicateKeyIgnore()" executes inefficient SELECT
#4036 - Obsolete remark in RecordListener Javadoc about batch semantics
#4041 - Bad unnesting of UDT arrays in PostgreSQL
#4052 - NullPointerException when generating source code for PostgreSQL table-valued function that returns nested arrays

New in jOOQ 3.5.1 (Jan 22, 2015)

New in jOOQ 3.3.2 (Apr 29, 2014)

New in jOOQ 3.3.1 (Mar 8, 2014)

New in jOOQ 3.3.0 (Feb 15, 2014)

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

New in jOOQ 3.2.3 (Jan 30, 2014)

New in jOOQ 3.2.2 (Dec 17, 2013)

New in jOOQ 3.2.0 Alpha 1 (Aug 27, 2013)

Features and improvements
#1079 - Add support for Oracle's FLASHBACK QUERY clause
#1903 - Duplicate Query construction API between DSLContext and DSL
#2010 - Add listener API to Record / UpdatableRecord
#2542 - Add an org.jooq.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
#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
API changes (backwards-compatible):
#2581 - Deprecate fetchLater() and FutureResult
#2662 - Deprecate the internal method DSLContext.bind(QueryPart,
PreparedStatement)
Bug fixes:
#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
#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-cases SQL keywords
#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

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):
MergeNotMatchedSetStep.set(Field, Select) returns
MergeMatchedSetMoreStep instead of MergeNotMatchedSetMoreStep
Bug fixes:
Handle Ingres', SQLite, SQL Server's, Sybase ASE's limitations of 1024,
999, 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

New in jOOQ 3.0.1 (May 27, 2013)

New in jOOQ 3.0.0 (Apr 29, 2013)

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

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

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

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)

Features and improvements:
#385 - Allow for keeping open statements in a Query
#600 - Add support for Oracle / SQL Standard linear regression functions
#1058 - Add Factory.row(T1, T2, .. TN) and Factory.row(
Field, Field ... Field) to allow for creating tuples / rows
#1077 - Add support for the SQL standard OVERLAPS predicate
#1245 - Improve formatting for DECIMAL data types in Result.format(). Nicely
align the decimal point and reserve space on both sides
#1484 - Let XJC-generated artefacts implement Cloneable
#1527 - Support for converting String to java.net.URL, java.net.URI, and
java.io.File
#1674 - Export data types with Result.formatXML() and Result.formatJSON()
exports
#1679 - Add Factory.table(String, QueryPart...)
#1708 - Add Map ResultQuery.fetchGroups(Field, Class)
#1709 - Add Map ResultQuery.fetchGroups(Field[])
#1710 - Add Map
ResultQuery.fetchGroups(Field[], Class)
#1719 - Make logic from ResultQuery.fetchArray() available in Result.intoArray()
#1728 - Add support for the MySQL COUNT(DISTINCT expr, expr...) aggregate
function syntax
#1744 - Add support for the CUBRID DECR() function
#1756 - Add RecordMapper, similar to RecordHandler, mapping records to
custom types
#1762 - Add package-info.java to add Javadoc documentation to all packages
#1766 - Simulate row comparisons where they are not supported
#1773 - Add a new jOOQ-Scala project and jooq-scala artefactId, to contain jOOQ
extensions in the Scala language
#1782 - Move JAXB bindings out of XSD, in order to support more advanced
bindings
#1783 - Generate @SuppressWarnings("all") in jOOQ-generated artefacts
#1784 - Enhance the BETWEEN predicate, introducing the AND keyword
#1810 - Add Map ResultQuery.fetchMap(Field, Class) and
Result.intoMap(Field, Class)
#1816 - Add support for materialized views in Oracle's code generator
#1828 - Reduce log level for Factory deserialisation to TRACE
#1837 - Add support for @java.beans.ConstructorProperties when fetching into
immutable POJOs
#1841 - Add SortField Field.sort(SortOrder) to allow for dynamic sorting
#1842 - Add Condition Field.compare(Comparator, Field) to allow for dynamic
comparisons
#1844 - Add Table Table.join(TableLike, JoinType) to allow for
dynamic joining
#1845 - Add Factory.schemaByName(String) for plain SQL schemata
#1848 - Add Record.changed() to indicate whether a Record contains "dirty"
values
#1849 - Add Record.original() to obtain the originally fetched values from a
Record
#1854 - Add ResultQuery.maxRows(int) to limit the number of actually fetched
records
#1855 - Add Query.cancel() to support for interrupting statements prematurely
#1856 - Add Query.queryTimeout(int) to support for JDBC's
Statement.setQueryTimeout()
API changes (backwards-compatible):
#1800 - Deprecate AliasProvider
#1807 - Result.intoArray() declares "throws MappingException", which isn't true
#1839 - Deprecate the various Result.getValuesAs[Type] and
Record.getValueAs[Type] methods
#1840 - Deprecate org.jooq.Store
#1866 - Deprecate [Schema-Name]Factory, remove reference to it from the
tutorials
#1869 - Deprecate org.jooq.NamedQueryPart
#1870 - Deprecate org.jooq.NamedTypeProviderQueryPart
#1872 - Improve jOOQ's RenderContext pretty printing behaviour
#1881 - Deprecate ConditionProvider, OrderProvider, LockProvider types
Bug fixes:
#1593 - Factory.field("{1} + {0} + {0}", val(1), val(2)) doesn't work. Cannot
re-use / re-order placeholders
#1720 - Improve performance by using Record.getValue(int) instead of
Record.getValue(Field) internally, where more than one value is
retrieved from a record
#1751 - Result.intoResultSet() generates wrong ResultSetMetaData if runtime
schema mapping is applied
#1764 - Add missing @Support({ ... FIREBIRD ... }) annotations
#1768 - NullPointerException when DAO.fetchOne() returns no record
#1774 - QueryPart.toString() does not load default settings from classpath
#1786 - Fix SEQUENCE support for Firebird
#1791 - Log a table's input/output names, and PK name when generating code
#1792 - Factory.fieldByName() and tableByName() do not correctly escape quotes
#1797 - SQL syntax errors when plain SQL contains comments with question marks
and SQL is executed as StatementType.STATIC_STATEMENT
#1802 - Result.into(Table) doesn't work correctly, if the same field name
appears twice in Result
#1806 - Let Record.toString() wrap the record in a temporary Result and call
Result.toString() instead
#1819 - MappingException in Record.into(Class), when POJO setters have
applicable names but non-applicable argument types
#1820 - Cannot fetch into non-public POJO classes. Their members / getters /
setters should be made accessible
#1829 - Factory.execute(String) may cause errors when plain SQL returns results
#1830 - Allow for passing null or empty arrays to intoMap(Field[]) and
intoGroups(Field[])
#1850 - Record.equals() returns true as soon as both records hold a "null" value
for a given field
#1860 - Bad Results returned from plain SQL "select *" queries, if several
selected columns share the same name
#1876 - 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)

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

New in jOOQ 2.4.0 (Jul 9, 2012)

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 artifacts
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 recognizable/

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
imulate 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
Upgrade 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 27, 2012)

New in jOOQ 2.0.4 (Feb 13, 2012)

New in jOOQ 2.0.3 (Jan 30, 2012)

New in jOOQ 2.0.2 (Jan 9, 2012)

New in jOOQ 2.0.1 (Dec 27, 2011)

Features and improvements:
#691 - Add support for Oracle CURSOR REF IN / INOUT parameters
#677 - Add type-mapping configuration, enforcing types for
columns
#947 - Add custom type mapping support (experimental)
#968 - Allow for custom enum types, configured in the code
generator (experimental)
#974 - Add Schema.getTable(String), getSequence(String),
getUDT(String) for better runtime Schema meta-navigation
#975 - Add Sequence.getName(), getSchema(), getDataType()
#980 - Add support for named parameters, to better interact with
Spring
#991 - Add Query.bind(String, Object) and bind(int, Object) to
easily modify existing bind values
#992 - Document thrown DataTypeException in Convert methods
#998 - Enhance MERGE statement for Oracle extensions:
WHEN MATCHED THEN UPDATE .. WHERE .. DELETE WHERE ..
WHEN NOT MATCHED THEN INSERT .. WHERE ..
#1000 - Add support for MySQL's INSERT INTO .. SET .. syntax in
MERGE statement's WHEN NOT MATCHED THEN INSERT clause
API changes (backwards-compatible):
#981 - Cannot insertInto(table("my_table")), as plain SQL tables
return Table, not Table. Relax
bound on R
#988 - Change Factory.field(String) to return Field
instead of Field
#999 - Make MERGE's WHEN MATCHED .. and WHEN NOT MATCHED ..
clauses optional
#1001 - 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:
#973 - EnumType renders name() instead of getLiteral() in
formatXXX() methods
#977 - EnumType renders name() instead of getLiteral() in
Convert.convert() method
#979 - Record.from() sets all changed flags to true. That's not
necessarily correct in the event of storing the record
back to the DB
#985 - AbstractRecord.equals() does not correctly compare
arrays. Compare them using Arrays.asList()
#986 - Postgres / DB2 / Sybase ASE foreign-key namespace is
unique-per-table. jOOQ forces all foreign keys from all
tables into the same namespace
#990 - Problems when encoding arbitrary byte[] as String(byte[])
in inlined SQL. This can cause issues when DEBUG-level
logging is activated
#995 - Routines don't respect SchemaMapping - Github issue #8
#1002 - TableRecord.storeUsing() doesn't update IDENTITY column
values, if the column is not part of the main unique key
#1003 - 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
#1005 - The INSERT INTO .. VALUES .. syntax may cause type-safety
issues in some databases. VALUES should be converted
before binding

New in jOOQ 1.7.0 (Nov 26, 2011)

New in jOOQ 1.6.9 (Nov 14, 2011)

New in jOOQ 1.6.8 (Oct 24, 2011)

Features and improvements:
#271 - Don't pre-fetch table meta data when selecting from plain
SQL tables
#489 - Add support for SELECT * (i.e. render SELECT * where
applicable)
#596 - Add support for VARIANCE() and STDDEV() OVER() window
functions
#608 - Add jOOQ version number in generated source code
#670 - Add more Javadoc to Field.xxx() functions
#692 - Add support for ResultSet type returned from HSQLDB
stored functions
#850 - Use http://www.jooq.org as URL for the @Generated
annotation
#854 - Add convenience methods Fields.isTrue(), isFalse() for
conversion of "Y", "YES", "1", "true", "on", etc into a
boolean condition
#870 - Add support for MEDIAN aggregate function
#872 - Add support for STDDEV_POP(), STDDEV_SAMP(), VAR_POP(),
VAR_SAMP() aggregate functions
#874 - Reduce the number of internal classes for dialect-specific
function aliases
#878 - Implement DataType.equals() and hashCode()
API changes (backwards-compatible):
#851 - Change Field.{sortAsc|sortDesc}(List sortList) into
Field.{sortAsc|sortDesc}(Collection sortList)
API changes (backwards-incompatible):
#848 - Purge deprecated API - Prior to 1.6.1
#849 - Replace Cursor.fetchResult() by Cursor.fetch()
#852 - Review stored procedures / functions concept. Merge them
all into a single "Routine" type
Bug fixes:
#756 - Error when aliasing HSQLDB and Postgres unnested tables
#761 - Exception when TRACE logging execution with plain SQL
tables involved
#773 - Execute standalone stored functions as CallableStatement
to prevent issues with transactions
#847 - Query.getSQL() doesn't render dialect-specific SQL when
Query is constructed using the fluent API
#853 - DB2 generated convenience methods for stored functions
have unstable ordering
#857 - Derby casting of numeric types to String / VARCHAR does
not work
#858 - SQLDataType.getSQLDataType() should return itself, instead
of null
#860 - SQLite CEIL function is incorrectly simulated. CEIL(2.0)
returns 3.0 instead of 2.0
#861 - Field.replace(String) generates bad SQL for various RDBMS.
Field.replace(String, String) works, though
#863 - Ingres integration generates illegal SQL when selecting
things like SELECT 1 WHERE 1 = 1
#866 - Sybase ASE Field.replace(String) function incorrectly
removes the argument string
#873 - Error when selecting two times the same aggregate field
#877 - Compilation error in generated source code when a table
without a primary key has an identity column
#879 - Add Google Cloud SQL Example
#880 - Query.getSQL() does not consider SchemaMapping
Test cases:
#811 - Loader integration tests fail for SQLite
#812 - CSV Loader test leaves Postgres JDBC connection in an
inconsistent transactional state on error
#856 - Add integration tests for Field.abs()
#865 - Add integration tests for Field.ascii()
#867 - Add integration tests for Field.sum(), avg(), max(), min()
#881 - Re-design H2 stored functions to be pre-compiled, in order
to speed up integration tests

New in jOOQ 1.6.7 (Sep 26, 2011)

New in jOOQ 1.6.6 (Sep 13, 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:
#679 - Improve H2 NVL2 support as of H2 1.3.156
#680 - Improve H2 ROUND support as of H2 1.3.156
#735 - Add README documentation to GitHub
#736 - Add more info regarding number of generated artefacts in
jooq-codegen logging
#750 - Add DataType.isNumeric(), .isString(), .isTemporal(),
.isBinary()
#754 - Log query as executed by JDBC PreparedStatement when
TRACE logging (without inlining variables)
#752 - CURSOR: Add support for selecting from ARRAY types
#762 - Use H2's native support of NVL, instead of COALESCE
#764 - CURSOR: Add support for selecting from ARRAY types
returned from stored functions
API changes (backwards-incompatible):
#639 - 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 (backwards-compatible):
API changes (previous API now deprecated):
#731 - Inconsistent API with Field.lessOrEqualToXXX(). Removed
"To" from method name
#757 - Deprecate Factory.constant() methods
Test cases:
#731 - Add missing integration tests for equalAll(), equalSome()
and similar methods
#747 - Upgrade H2 to 1.3.158
Bug fixes:
#632 - Sybase error : column @p0 not found in nested SELECT
#700 - Restore HSQLDB ARRAY support with INFORMATION_SCHEMA
change in HSQLDB 2.2.3, and some fixes in 2.2.5
#725 - Cannot insert byte[] data with plain SQL
#733 - H2 changed JDBC type for ResultSet/CURSOR from 0 to -10,
like Oracle
#737 - Compilation errors in generated source code if table
fields contain spaces
#738 - Compilation errors in generated source code if MySQL
procedure parameter type contains two comma-separated
arguments (like DECIMAL(10,2))
#739 - Postgres navigator methods and keys are not re-generated
in the same order
#740 - Formatting is broken on Result.format() with some special
newline characters
#743 - Make SQL Server INFORMATION_SCHEMA independent from
HSQLDB again, to prevent incompatibility issues
#744 - Ingres REAL and FLOAT4 types are generated as FLOAT/FLOAT8
which maps to java.lang.Double, instead of java.lang.Float
#753 - Postgres error when binding array that contains null
values
#755 - NullPointerException when converting an array containing
a null value
#766 - 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:
#61 - EXPORT: Add Result.formatXML()
#166 - CURSOR: Add support for ResultSet type returned from Oracle stored procedures / functions
#411 - Allow for fetching Map (instead of Record) and List (instead of Result)
#549 - Add Factory.function() for plain SQL functions
#611 - Simulate RPAD and LPAD in SQL Server, Sybase
#627 - Add support for Postgres FOR UPDATE OF [table-name] clause
#628 - Add support for REPEAT (SQL Server: REPLICATE) function
#637 - Nicely format time in StopWatch logging output
#640 - Simulate Postgres FOR UPDATE OF [table-name] clause in other dialects
#649 - CURSOR: Add Cursor.fetch(int) .fetchOne() .fetchResult(int) .fetchResult()
#653 - Add support for MySQL encryption and compression functions
#660 - Clarify Javadoc of UpdatableRecord to explain its behaviour when changing the main unique key
#669 - EXPORT: Add Result.formatHTML()
#672 - Add convenience method UpdatableRecord.copy() in order to reset primary key values for a subsequent INSERT
#675 - EXPORT: Add Result.formatCSV()
#683 - Implement ResultImpl.equals() and .hashCode()
#684 - Implement AbstractStore.equals() and .hashCode()
#685 - Add Store.size() to indicate the maximum index of the Store
#687 - EXPORT: Add result.formatJSON()
#689 - Create separate builds: jooq-core.zip and jooq-with-dependencies.zip
#690 - CURSOR: Add support for ResultSet type returned from H2 stored functions
#695 - CURSOR: Add support for ResultSet type returned from Postgres stored functions
#697 - Add Factory.fetch(String) for executing plain SQL queries that return results
#701 - Add ResultQuery.fetchArray() and .fetchOneArray to return Object[][] and Object[]
#704 - Always add top and bottom line in Result.format()
#705 - Right-align numeric values in Result.format()
#716 - Add SUBSTRING function Field.substring(Field, Field) taking fields as arguments
#719 - Document risk of SQL injection in plain SQL and literal factory methods
#726 - Add LENGTH function as a synonym for CHAR_LENGTH
API changes (backwards-compatible):
#698 - Inconsistent API with Factory.fetch(Table [,Condition]) Let method return Result instead of List
#699 - Let Result extend List
API changes (previous API now deprecated):
#656 - Decrease verbosity of plain SQL methods. They will just be called Factory.field() .condition() .table() .query()
Test cases:
#643 - Add integration test for code generation of invalid and incomplete types in Oracle
#654 - Add integration tests for master data tables with PK types other than NUMBER/INT
#655 - Add missing integration tests for TRIM function
Bug fixes:
#450 - Improve plain SQL integrity checks for bind variables
#610 - CODEGEN: Compilation error in generated source code for databases with table named 'system'
#646 - An empty Java package is generated for an empty PL/SQL package. This is unnecessary
#651 - CODEGEN: Avoid importing datatypes in generated source code to prevent collisions
#657 - NullPointerException when creating a Factory with a null SchemaMapping
#658 - Master data table code generation is broken for tables with more or less than 3 columns
#662 - Add support for the missing Postgres data type "bpchar"
#663 - Add support for the missing Sybase data type "int"
#664 - Ingres INTEGER data types are not correctly generated
#665 - HSQLDB Datatype CLOB and BLOB are not supported, when selecting from plain SQL tables
#666 - The evil bug: Ingres TRIM function only executes RTRIM
#673 - UpdatableRecord.store() doesn't work if called after .delete()
#702 - Add support for the missing SQLite data type "NULL"
#706 - 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)
#724 - NullPointerException when passing a single literal null bind value to plain SQL methods without casting to Object
#729 - DB2, Derby, Ingres, Oracle cannot bind null values in plain SQL

New in jOOQ 1.6.1 (Jun 27, 2011)

Features:
#351 - Add support for Oracle ROWID data type
#452 - PORTABILITY: Create a super-set of RDBMS data types
#453 - PORTABILITY: Don't create dialect-specific QueryParts
#455 - Add support for the Oracle CONNECT BY clause
#587 - Add optional OFFSET clause to form LIMIT .. OFFSET constructs
#589 - Add extended FOR UDPATE [OF ...] [{WAIT n | NOWAIT | SKIP LOCKED }] support
#591 - Add support for LEAD() OVER() and LAG() OVER() window functions
#592 - Add support for the CUME_DIST() OVER() window function
#601 - Add Factory.literal() convenience methods
#602 - Add Factory.val() methods to decrease .constant() verbosity
#604 - Add support for RESPECT NULLS clause in some window functions
#605 - Add Factory.use(String) for non-generated schemata
#613 - Add PI function
#616 - Add Factory.two() literal convenience method
#630 - Add support for Oracle CONNECT BY pseudo-columns LEVEL, CONNECT_BY_ISCYCLE, CONNECT_BY_ISLEAF
API changes:
#299 - PORTABILITY: Create a dialect-independent meta-model
#588 - Add OVER() keyword to FIRST_VALUE() and LAST_VALUE() API
Test cases:
#368 - Add integration test for use with schema mapping
#586 - Upgrade H2 to 1.3.155
#607 - Add integration tests for CRUD / SP's / UDT's / ARRAY's with SchemaMapping
#612 - Add integration tests for LPAD and RPAD functions
#624 - Add integration test for code generation of invalid/ incomplete views in Oracle
#631 - PORTABILITY: Add integration tests for using Oracle- generated schema against an HSQLDB database
#638 - Add missing integration test for DECIMAL data type
Bugfixes:
#176 - Stored procedures / functions in EQUIVALENT schemata cannot be called
#493 - Bind variable mismatch when constructing bad SQL
#594 - Confusing Javadoc in SELECT DSL API
#603 - Fix DB2 'IGNORE NULLS' clause
#619 - SUBSTRING() function is broken in DB2, Ingres, SQL Server
#623 - SQL syntax error for some MERGE queries in SQL Server and Sybase
#633 - SchemaMapping is not applied to sequences
#634 - Sequences are not escaped in generated SQL