Professional Documents
Culture Documents
==================
For an interactive overview, see also
http://github.com/jOOQ/jOOQ/issues
For a formatted text version, see
http://www.jooq.org/notes.php
For a text version, see
http://www.jooq.org/inc/RELEASENOTES.txt
Version 3.4.2 - August 08, 2014
================================================================================
This is a patch release with some useful fixes for the 3.4 branch
Bug fixes
--------#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
#3430 - JDBC escape syntax is not correctly rendered from plain SQL
#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<Object>.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)
Version 3.4.1 - July 11, 2014
================================================================================
This is a patch release with some useful fixes for the 3.4 branch
Bug fixes
--------#3347 - Field.in(T...) should defend against Collection arguments
#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
#3081 - Let generated POJOs reference generated UDT POJOs instead of UDT Records
#3084 - SQL Server unique indexes are not loaded by jOOQ-meta
#3093 - Add code-generation configuration to treat UNIQUE keys as primary keys
to generate UpdatableTables
#3094 - Add Relations.getUniqueKeys(SchemaDefinition), getUniqueKeys()
#3095 - Add SchemaDefinition.getTables()
#3096 - Add Constants.XSD_RUNTIME, NS_RUNTIME, XSD_CODEGEN, NS_CODEGEN
#3111 - Support multiple Converters for the same <U> type in the code generator
#3115 - Support hypothetical set function syntax (for CUME_DIST, RANK,
DENSE_RANK, PERCENT_RANK)
#3116 - The jOOQ Scala manual examples use T_BOOK instead of BOOK
#3125 - Generate default ArrayRecord constructors that don't need a
Configuration
#3130 - Generated UDTRecords should be more similar to generated TableRecords
#3139 - Add <T1, ..., T[N]> Result<Record[N]<T1, ..., T[N]>>
DSLContext.newResult(Field<T1>, ..., Field<T[N]>)
#3153 - Add a paragraph to the manual explaining classpath behaviour of the
standalone code generator
#3154 - Add code-generation configuration to generate synthetic primary keys for
updatable views
#3169 - Add more ResultQuery.fetchAnyXXX() convenience methods
#3180 - Add a Java 8 example to the documentation
#3181 - Update external manual links to point to the JavaSE 8 Javadoc
#3189 - Add DSL.sequenceByName(String...)
#3199 - Add some Javadoc to Result.attach() and Result.detach() to explain the
semantics
#3202 - Allow for Pattern.COMMENTS in code generation configuration's regexes
#3203 - Add DSL.not(Field<Boolean>) as a convenience for DSL.not(Condition)
and condition(Field<Boolean>)
#3204 - Clarify what "fully qualified" means in the context of <include/> and
<exclude/> in the code generator configuration
#3205 - Add DSL.condition(Boolean) as a convenience for
condition(Field<Boolean>)
#3212 - Add support for value types in DefaultRecordMapper, when mapping
Record1 types
#3229 - Add DSLContext.transaction() to implement nested transaction semantics
through functional interfaces
#3230 - Implement TransactionProvider for use with DataSourceConnectionProvider
#3232 - Add optional <type/> configuration to <customType/> in order to specify
different converters for the same Java type
#3233 - Add DataTypeDefinition.getConverter()
#3240 - Add DSL.sequence() methods for plain SQL sequence construction
#3252 - Relax bounds on <R> for DSLContext.batchInsert()
#3253 - Pull up TableRecord.insert()
#3264 - Use try-with-resources statements in the manual
#3265 - Add manual examples for include / exclude that explicitly use schemas
(and other fully qualified object names)
#3275 - Use maven-plugin-annotations in jOOQ-codegen-maven instead of Javadoc
tags
#3286 - Add MySQLDSL.encode(byte[]) and decode(byte[])
#3288 - Add DSL.date(String), DSL.time(String), and DSL.timestamp(String), as
shortcuts for respective valueOf() methods
#3305 - Add SQLDialect.families() to access all SQLDialect families
#3307 - Change internal representation of AbstractRecord to use Object[] and
BitSet instead of Value[]
#3319 - Update the jOOQ LIMIT .. OFFSET manual page
#3316 - Add RecordContext.recordType() to allow for introspecting record types
when implementing RecordListeners
#3321 - Add support for Oracle's (+) JOIN syntax
#3322 - Add UpdatableRecord.store(Field<?>...), insert(Field<?>...),
update(Field<?>...)
API changes (backwards-compatible)
---------------------------------#3126 - Deprecate generated ArrayRecord constructors that take a Configuration
argument
#3127 - Deprecate ArrayRecord.set(Array)
#3128 - Change ArrayRecord.setList(List<? extends E>) into
ArrayRecord.set(Collection<? extends E>)
API changes (backwards-incompatible)
-----------------------------------#3247 - InsertSetMoreStep must not extend InsertSetStep
Behavioural changes (backwards-incompatible)
-------------------------------------------#3131 - Query.getBindValues() should not return inlined bind values
#3132 - Quoting identifiers that contain "special characters" may lead to
unexpected results when using RenderNameStyle.AS_IS
#3306 - Let Record.key() return a "copy record", instead of a view to the
original record
Bug fixes
--------#2335 - SQL syntax error when projecting two columns of the same name along with
a LIMIT clause in Oracle
#2700 - DAO.insert() and other DAO operations do not respect DEFAULT values
#2973 - Field.in(Collection) should accept wildcard instead of T
#3011 - Routines do not propagate errors raised from T-SQL with sqljdbc_4.0
#3018 - Add <outputSchemaToDefault/> to support "default schemas" during code
generation
#3055 - Add missing MariaDB and MS Access support to the manual
#3057 - Wrong paths in maven-install.sh and maven-install.bat
#3060 - Conversion fails for Oracle VARRAY / TABLE types, nested in UDTs
#3069 - jOOQ calls Clob.free(), which is available only in JDBC 4.0 / Java 1.6
#3090 - Bad predicates generated from nullable keys on refresh(), update(),
delete()
#3099 - UpdatableRecord.store() executes INSERT instead of UPDATE when used
with nullable composite primary keys
#3101 - MutablePOJOMapper doesn't work with annotated boolean getters
#3108 - Local Fields' Converters should be preferred over globally registered
Converters
#3117 - jOOQ illegally generates covariant setters on UDTRecords and UDT Pojos
when <pojos/> and <interfaces/> are activated
#3119 - Upgrade to JUnit 4.11 and omit using deprecated junit.framework.Assert
in tests
#3120 - Outdated link to Spring TX in the manual
#3122 - Runtime Schema mapping doesn't work for UDT
#3131 - Query.getBindValues() should not return inlined bind values
#3133 - Code generation marks all PostgreSQL Fields as having a default value
#3143 - Bad Javadoc in the org.jooq.tools.json package: JSON tools are not
"JSONAware"
#3147 - Field.sortAsc() and sortDesc() should generate inlined values for sort
indirection
#3155 - Improve documentation of <forcedType>'s <types/> element
#3156 - "Column ambiguously defined" when emulating derived column lists with
duplicate column names
#3159 - Replace BoneCP with Apache DBCP in examples and manual
#3161 - Bad XSD version number referenced from jOOQ 3.3 manual
#3162 - NullPointerException when referencing window name that was not declared
#3164 - Missing formatting when rendering formatted MERGE statement's SET clause
#3168 - Bad download link in documentation
#3176 - Don't generate "assignment-constructors" for POJOs and Records with more
than 255 columns
#3179 - PDF manual's white-on-black code sections are hard to read with Kindle
#3183 - Add some clarification to the manual's section about the H2 MERGE
statement
#3186 - Bad SQL rendered for FOR UPDATE clause in Firebird
#3187 - Manual section about Groovy has a couple of Scala references in them
#3191 - ResultQuery.keepStatement(true) doesn't work correctly with
DataSourceConnectionProvider
#3194 - Avoid using deprecated Maven mojo descriptor @parameter
expression="${property}"
#3195 - IN predicate with subquery cannot have LIMIT .. OFFSET clause in Oracle
#3200 - Converter does not work when loading CSV files
#3211 - Dead codegen example POM link in manual
#3214 - Error when inserting PostgreSQL enum array
#3217 - Manual was not updated after fixing #2910
#3218 - Fix the manual and suggest using DSL.field() instead of
DSL.fieldByName()
#3226 - DefaultConnectionProvider shouldn't use DSL class for DEBUG logging
#3234 - Connection Leak With BatchCRUD operations
#3237 - UpdatableRecord.store() executes INSERT instead of UPDATE when nullable
primary keys are NULL
#3241 - Cursor.iterator() does not correctly implement Iterator.next() contract
with respect to NoSuchElementException
#3244 - InsertQuery.setDefaultValues() is not supported by the ACCESS dialect
#3249 - DSL.selectZero() and DSL.selectOne() should alias column names
#3267 - Misleading DSLContext.batch() Javadoc. It should be clear that an
additional call to execute() is needed.
#3277 - SQLite DECIMAL(p, s) types are not correctly recognised
#3282 - inputSchema / outputSchema codegen configuration has no effect in
Oracle, if inputSchema is lower-cased
#3293 - Bad composite foreign key references generated for H2
#3294 - DSLContext.renderNamedParameters() doesn't replace ?, ? by :1, :2 in
plain SQL QueryParts
#3297 - Bind variables are erroneously inlined into quoted identifiers, if
identifiers contain question marks
#3300 - UpdatableRecord.store() executes INSERT instead of UPDATE when nullable
primary keys are NULL, and the updatablePrimaryKeys setting is active
#3309 - Don't use "deploy" as Maven <defaultGoal/>
#3328 - Re-create old DefaultConfiguration constructors for backwardscompatibility
#3333 - maven-compiler-plugin configuration in jooq-parent pom file uses the
deprecated compilerArguments parameter
#3342 - Cannot INSERT into tables with Firebird BLOB types
Version 3.3.0 - February 14, 2014
================================================================================
Finally, a new awesome jOOQ release is ready for you to download! The most
important feature first:
The SEEK method
--------------We've been blogging about keyset paging before:
- http://blog.jooq.org/2013/10/26/faster-sql-paging-with-jooq-using-the-seek-met
hod/
- http://blog.jooq.org/2013/11/18/faster-sql-pagination-with-keysets-continued/
Every SQL developer should have this tool in their toolchain. And now, with
jOOQ 3.3, we natively support a synthetic SQL clause for you to express keyset
paging very easily. jOOQ is the only database software out there to do so!
Gudu Software's SQL 2 jOOQ Parser
--------------------------------We're very happy to announce our collaboration with Gudu Software Ltd who have
implemented a very powerful SQL parser and transformer for enterprise databases.
Together with Gudu Software, we have created an Open Source SQL 2 jOOQ parser
that takes native SQL statements as input and generates jOOQ code as output.
The source code can be found here:
- https://github.com/sqlparser/sql2jooq
And our manual features a tutorial here:
- http://www.jooq.org/doc/latest/manual/tools/sql2jooq/
We will ship, test and maintain this awesome new addition with our own
deliverables. So far, SQL 2 jOOQ supports the MySQL and PostgreSQL dialects and
it is in an alpha stadium. Please, community, provide as much feedback as possib
le
to make this great tool rock even more!
Please take note of the fact that the sql2jooq library is Open Source, but it de
pends
on the commercial gsp.jar parser, whose trial licensing terms can be seen here:
- https://github.com/sqlparser/sql2jooq/blob/master/sql2jooq/LICENSE-GSQLPARSER.
txt
Great new SQL Feature Support
----------------------------We've been looking around for SQL standard and vendor-specific features, such as
the WINDOW clause (standard!), CROSS APPLY, OUTER APPLY, LATERAL join, DEFAULTs
for inserts, and nice datetime arithmetic functions and emulations thereof.
As always, we've also blogged about all these features. See the following links
for more details:
- http://blog.jooq.org/2013/11/03/probably-the-coolest-sql-feature-window-functi
ons/
- http://blog.jooq.org/2013/12/18/add-lateral-joins-or-cross-apply-to-your-sql-t
ool-chain/
- http://blog.jooq.org/2014/01/08/lesser-known-sql-features-default-values/
- http://blog.jooq.org/2014/02/06/youre-very-likely-to-have-gotten-sql-date-time
-arithmetic-wrong/
Formal Spring integration support
--------------------------------Spring is one of the most popular frameworks to handle transactions, and it does
so very well. With the help of our community, we've established new standards an
d
examples of how to get started very quickly with jOOQ and Spring. See the follow
ing
resources for details:
- http://www.jooq.org/doc/latest/manual/getting-started/tutorials/jooq-with-spri
ng/
- https://github.com/jOOQ/jOOQ/tree/master/jOOQ-examples/jOOQ-spring-example
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
#1018 - Add support for PostgreSQL and SQL Server non-standard UPDATE .. FROM
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> T DSLContext.fetchValue(Select<Record1<T>>) 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
artefacts. This is extremely useful to generate table, record, pojo class name
prefixes, suffixes in particular, or to just completely redesign the way the
jOOQ code generator generates things.
Features and improvements
------------------------#674 - Add <fluentSetters/> 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 <ForcedType/> 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 <includeExcludeColumns/> flag to code generation configuration to
indicate that <includes/> and <excludes/> 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
#2729
#2733
#2745
#2757
#2761
Add Attachable.detach()
Emulate IS DISTINCT FROM through IS / IS NOT in SQLite
Add the default log4j.xml configuration file to the maven plugin
Generate default constructor and "assignment-constructor" in POJOs
Add support for DB2 10.5
Add some documentation to the manual showing how GeneratorStrategy SPI
is used by jOOQ-codegen
#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<R>
#2662 - Deprecate the internal method
DSLContext.bind(QueryPart, PreparedStatement)
#2719 - Change various method(Collection<SortField<?>>) into
method(Collection<? extends SortField<?>>)
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 <includes/> accepts comma-separated regular
expressions
Record1<T1>
Record2<T1, T2>
Record3<T1, T2, T3>
...
Record22<T1, T2, T3, .., T22>
The highest degree of typesafety was chosen to be 22, to match Scala's Tuple22,
Product22 and Function22 types. Higher degree records are still supported by
jOOQ, just without the additional typesafety.
This Record typesafety is applied to
- SELECT statements
- INSERT and MERGE statements: the VALUES() clause
- UPDATE statements: SET A = (SELECT...)
Apart from this major improvement, there had been many minor changes throughout
the jOOQ API. Here are some important ones:
- Factory has been split into DSL (static QueryPart construction) and
DSLContext (Query execution, "attached" QueryPart construction). This greatly
improves the overall DSL experience while allowing for more fine-grained
Executor lifecycle control.
- A ConnectionProvider has been introduced as an abstraction of the JDBC
Connection lifecycle. The standalone Connection and pooled DataSource modes
are still supported, but you can now inject your own ConnectionProvider for
more control.
- A lot of performance improvements have been implemented within the jOOQ API
removing most of the overhead caused by jOOQ when fetching data from JDBC
- A JDBC Mock API has been added to help you create simple unit tests for your
application built on top of jOOQ.
- A VALUES() constructor is now supported, and derived column lists to alias
tables and columns in one go.
- The data type API has been greatly simplified. This allowed for the
introduction of runtime precision, scale, and length information.
- CRUD has been improved through many more CRUD batch operations, explicit
INSERT and UPDATE (in addition to store()), and explicit handling of jOOQ's
internal changed flags.
As this is a major release, some backwards-incompatibilities were inevitable.
For those users among you, migrating from jOOQ 2.x to 3.0, here are a couple of
useful hints:
http://www.jooq.org/doc/3.0/manual/reference/migrating-to-3.0/
Note, that for technical reasons, jOOQ 3.0.0 could not yet be integration
tested with DB2, Ingres, and Sybase ASE. Consider using jOOQ 2.6, instead
Note, that further code generation and model API improvements were postponed to
a later release
Note, previous release candidates contained more features, improvements and bug
fixes. See their respective sections for details.
Features and improvements
------------------------#2410 - Add some more API usage examples to the section about ResultSet fetching
#2415 - Add Constants.MINOR_VERSION and Constants.FULL_VERSION for internal and
external reuse
Bug fixes
--------#1998 - Wrong screenshots in the manual's section about code generation.
jooq-meta.jar is missing
#2407 - Fix bad references to pre-3.0 Factory in Javadoc
Version 3.0.0 (RC3) - April 12, 2013
================================================================================
UpdatableRecords
#1801 - Add Table.as(String, String...) to allow for creating a table aliases
(correlation names) with derived column lists
#1874 - Add Record1, Record2, ... Record[N] similar to Row1, Row2, ... Row[N] to
support record type-safety
#1897 - Add a section to the manual about the migration to jOOQ 3.0
#1899 - Make some JDBC-related utility methods publicly available in
org.jooq.tools.jdbc.JDBCUtils
#1902 - Duplicate SELECT API between Executor and Factory
#1904 - Add Executor.fetch(ResultQuery), Executor.execute(Query), and similar
methods
#1905 - Add Row[N].equal(Select<? extends Record[N]>) and similar methods
#1906 - Use Xtend to generate Row[N], Record[N] and other [N]-related API code
artefacts
#1914 - Document the fact that SELECT * is performed by leaving the SELECT list
empty
#1917 - Add support for CUBRID 9.0's window functions and MERGE statement
#1918 - Let generated Records implement Record[N] if applicable
#1919 - Support higher degrees of Row[N] and Record[N] types. Match Scala's max
degree of 22
#1920 - Add more implicit defs in order to treat Record[N] as Scala's Tuple[N]
#1923 - Add Record.intoResultSet() to create a single-record JDBC ResultSet from
a Record
#1924 - Add support for CUBRID 9.0's ENUM data type
#1932 - Generate Javadocs for Table constructors
#1934 - Improve generated Record Javadoc
#1951 - Add support for the SQL Server WITH (...) table hints
#1966 - Add Row[N].equal(Record[N]) and similar convenience methods
#1967 - Document using MySQL's SQL_CALC_FOUND_ROWS as an Oracle hint
#1968 - Add org.jooq.Meta returned from Executor.meta() to return a wrapped JDBC
DatabaseMetaData object
#1972 - Move MySQLFactory.md5() to Factory and simulate it for Oracle
#1973 - Add Executor.fetchOne(ResultSet)
#1975 - Add Result.sort{Asc|Desc}(int) and (String) to order by field index /
name
#1981 - Add support for DB2 CGTT and MQT
#1983 - Improve the Javadoc on Table.as() and Field.as() to hint at
case-sensitivity and RenderNameStyle
#1984 - Add ResultQuery.fetchOneInto()
#1986 - Add Record.fromMap() as the inverse operation of Record.intoMap()
#1987 - Allow for reading data from arrays, Maps through Record.from()
#1988 - Add Record.fromArray() as the inverse operation of Record.intoArray()
#1989 - Add Record.changed(Field<?>), changed(int), changed(String) to check
whether a single field's value has changed
#1990 - Add <T> T Record.original(Field<T>), original(int), original(String) to
get a Field's original value
#1991 - Reflect changed flag in Result.toString() (and thus also
Record.toString())
#1999 - Add Record.changed(boolean) changed(Field<?>, boolean)
changed(int, boolean) changed(String, boolean) as setters for the
changed flag
#2000 - Add Record.reset(), reset(Field<?>), reset(int), reset(String) to
restore original values in a record
#2008 - Add elementFormDefault="qualified" to XSD specifications to allow for
XML validation of jOOQ configuration files
#2020 - Let org.jooq.ExecuteListener extend java.util.EventListener
#2021 - Add UpdatableRecord.refresh(Field<?>...) to allow for refreshing a
subset of the Record's values
#2027 - Document semantic versioning rules as understood by jOOQ
#2028 - Add Batch.size() to indicate the number of queries that will be executed
by a batch operation
#2030 - Add reusable wrapper types for JDBC Connection, Statement, ResultSet,
etc.
#2044 - Add various TableRecord.fetchParent(...), fetchChild(...) and
fetchChildren(...) methods to follow foreign key relationships
#2049 - Add gt() / ge() / lt() / le() to Row[N] types
#2052 - Add [not]Between[Symmetric]() to Row[N] types
#2053 - Add is[Not]Null() to Row[N] types
#2066 - Add Executor.extractBindValues(QueryPart), extractParams(QueryPart) to
extract bind values in the context of an Executor (i.e. Configuration)
#2072 - Let UDTRecordImpl and ArrayRecordImpl.toString() return a valid
constructor expression
#2078 - Add Postgres to @Support annotation of SelectForUpdateWaitStep.wait()
#2079 - Support generation of bean validation annotations on records and
interfaces
#2089 - Generate an "empty" DefaultSchema for those databases that do not have
any schema (CUBRID, Firebird, SQLite)
#2094 - Add unit tests for org.jooq.tools.Convert
#2107 - Let Record implement Comparable
#2111 - Improve org.jooq.Record Javadoc, to explain the various Record subtypes
#2112 - Add Row.types() and Row.dataTypes() as a convenience
#2113 - Document Record.hashCode() and equals() through Javadoc
#2133 - Allow for mapping <outputSchema/> to "" (empty) in order to avoid the
generation of a schema
#2156 - Add Row.type(int), type(String), dataType(int), dataType(String) for
convenience
#2158 - Add Executor.fetchLazy(Table) and fetchLazy(Table, Condition) for
convenience
#2159 - Let ExecuteListener extend Serializable
#2160 - Add Executor.batchUpdate(UpdatableRecord<?>...) to mass-update a set of
UpdatableRecords
#2161 - Add Executor.batchInsert(UpdatableRecord<?>...) to mass-insert a set of
UpdatableRecords
#2162 - Add some more Javadoc to JooqLogger
#2170 - Add 0.0 and 1.0 to Convert.FALSE_VALUES and Convert.TRUE_VALUES
#2171 - Allow for converting booleans to numbers through org.jooq.tools.Convert:
TRUE => 1, FALSE => 0
#2172 - Add <T> set(Field<T>, Select<? extends Record1<T>>) methods to UPDATE,
MERGE and INSERT statements
#2176 - Add hint in code generation, when an unsupported, old database version
is being used (e.g. MS SQL Server 2000)
#2177 - Add ResultQuery.intern() and Result.intern() for string interning in
result sets
#2179 - Add Javadoc to QueryPart.hashCode() and equals()
#2199 - Allow for INSERT and UPDATE of pre-existing records through
SET [ Record ] clauses
#2202 - Add Mock JDBC objects for unit testing with jOOQ
#2203 - Add Executor.map(Schema) and Executor.map(Table) as a convenience to
apply runtime schema mapping
#2204 - Add BatchBindStep.bind(Object[][]) to bind lots of bind values at a time
#2205 - Add <R> Result<R> Executor.newResult(Table<R>) to generate custom
results
API changes (backwards-compatible)
---------------------------------#1309 - Let Factory.val() return Param<T> instead of Field<T>
#2031 - Change union(Select<R>) and similar methods to
union(Select<? extends R>)
#2157 - Change the bounds of various <H extends RecordHandler<R>> H
fetchInto(H handler) methods to RecordHandler<? super R>
and Sybase
#1974 - Optimise various Executor.fetchOne() methods, which consume the whole
ResultSet before throwing an InvalidResultException
#1979 - Thread safety issue in org.jooq.impl.FieldList
#1982 - Change RenderNameStyle.UPPER, LOWER, AS_IS to quote literals if needed
#1992 - Bad reference to org.jooq.debug.[impl].DebugListener in the manual
#1993 - Bad code generated when the same table name exists in multiple schemas
in SQL Server
#1995 - Record.original() values aren't updated after a Record.store() operation
#1997 - Review the manual's tutorial for integrity
#2001 - Named Params are treated as null literals on right sides of comparisons
#2007 - Bad type coercion on the right hand side of a comparison predicate, when
the left hand side is Field<Object>
#2011 - Implement some micro-optimisations in DefaultRenderContext
#2025 - Correctly handle multiple foreign keys defined on the same column
#2045 - Bad hashCode calculation when Records contain arrays or byte[]
#2055 - MySQL's UPDATE [t1] JOIN [t2] syntax can cause syntax errors as column
references are not fully qualified
#2057 - Cannot properly extract bind values for LIMIT .. OFFSET clause from a
SELECT statement
#2063 - jOOQ-meta loads Firebird composite unique key columns in wrong order
#2073 - The code generator's <dateAsTimestamp/> flag doesn't affect Oracle
VARRAY and TABLE types
#2082 - Oracle PIVOT expression doesn't bind any variables of a derived table
being pivoted
#2085 - java.lang.NoSuchMethodError: org.apache.log4j.Logger.isTraceEnabled()Z
when logger dependency is missing
#2086 - SQL syntax error when aliasing outcome of a relational division
#2091 - CUBRID doesn't really have a NVARCHAR data type
#2098 - NullPointerException when org.jooq.impl.EnumConverter converts null
#2104 - SQLite code generation treats multi-column primary keys like multiple
single-column unique keys
#2108 - SQLite returns NULL for val(new Date(0)).add(-1) and some other date
time arithmetic expressions
#2128 - Misleading Javadoc in Factory / Executor.selectCount()
#2137 - Failure to assign a value to a record pojo for a column with a
composite type when using select into.
#2139 - batchStore with Postgres composite types incorrectly reuses values from
the first record.
#2140 - No table java mapping generated using maven plugin - missing inputSchema
in postgres
#2143 - UnsupportedOperationException when binding UDTRecord in batchStore() for
Oracle
#2144 - Improve AbstractField.equals() and AbstractTable.equals() and similar,
as these two are called very often
#2145 - Improve QueryPartList.removeNulls() as this is called very often
#2154 - Generated Records should access values by index, not by field, for
performance reasons
#2165 - Add H2 database definitions to the jOOQ-scala module (to prevent
compilation errors)
#2167 - Convert.convert("xx", boolean.class) returns null, instead of false
#2178 - Improve FieldList. Avoid creating excessive array lists, where simple
(immutable) Field<?>[] are sufficient
#2180 - Optimise DAOImpl by using the new ReflectionMapper instead of calling
Record.into() all the time
#2187 - Change all Javadoc <h3/> tags to <h5/> (To fix Java 7 standard Javadoc
style layout issues)
#2210 - Executor.fetchFromCSV() shouldn't mark resulting records as "changed"
#2215 - Improve example in the "jOOQ for CRUD" section. Use only columns from
the sample database
Result.intoMap(Field<T>, Class<E>)
#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<T>) to allow for dynamic
comparisons
#1844 - Add Table<Record> 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
Version 2.5.0 - August 26, 2012
================================================================================
Welcome to another great database integration in jOOQ: Firebird! This is one of
the more popular open source SQL databases out there, with a rich feature set,
including the SQL standard MERGE statement.
Apart from this, the main new features are:
- Optimistic locking. jOOQ's UpdatableRecord API transparently implements
optimistic locking on its store() and delete() methods. By default, the
in-memory record is compared with the one in the database at write time. But
you can also let jOOQ handle incremented VERSION or TIMESTAMP columns for you.
- Oracle feature increment. Many nice Oracle features are now supported:
user-defined aggregates, regular expressions, Oracle Text, CONNECT_BY_ROOT and
ORDER SIBLINGS BY clausess, partitioned outer joins and more
- jOOQ's convenience API has been greatly enhanced. This includes many improved
fetch methods and new short forms for equal=eq, notEqual=ne, greaterThan=gt,
etc. to better align jOOQ with JPA, XSL, QueryDSL and many other tools that
abbreviate these keywords
- Many types and methods have been deprecated to help you foresee the upcoming
changes in jOOQ 3.0
Please consider also the updated manual with its new, more user-friendly
structure
Features and improvements
------------------------#430 - Add support for the Firebird database
#457 - Add support for Oracle user-defined AGGREGATE functions
#620 - Add support for the SQL:2008 standard LIKE_REGEX operator
#722 - Remove casting of bind values in Ingres
#727 - Simulate RPAD and LPAD in SQLite
#816 - Add support for Oracle Text functions
#1339 - Add option to generate immutable pojos
#1547 - Support "optimistic locking" in UpdatableRecord.store() and delete()
#1552 - Generate fetchBy[ColumnName] methods in generated DAO classes
#1553 - Add some Javadoc to document the difference between using a Factory with
a Connection or with a DataSource
#1556 - Add javax.validation API to full deliverable
#1565 - Add Factory.connectByRoot(Field<?>) to support the Oracle
CONNECT_BY_ROOT pseudo column
#1570 - Add Factory.condition(String, QueryPart...) similar to
Factory.field(String, QueryPart...)
#1582 - Add support for Oracle's ORDER SIBLINGS BY clause, in combination with
CONNECT BY
#1586 - Add missing constructors taking DataSource to dialect-specific factories
#1587 - Generate missing constructors taking DataSource in schema-specific
factories
#1595 - Simulate REPEAT() in SQLite
#1596 - Add support for optimistic locking using generated information about
#1627
#1645
#1657
#1664
#1665
#1675
#1680
#1681
#1684 #1685 #1688 #1692 #1696 #1698 #1701 #1704 #1707 #1712
#1713
#1714
#1718
the SQL style of SQL rendered by jOOQ. You can now specify
whether table/column names should be quoted / capitalised /
lower-cased, whether SQL keywords should be capitalised or not,
etc...
- The handling of NULL has been improved in favour of using jOOQ
as a SQL builder library (e.g. along with Spring for execution)
NULL is no longer inlined, but bound as a variable.
- jOOQ now supports simulation of the relational division
operation using an intuitive syntax. Read more about the
relational division here:
http://en.wikipedia.org/wiki/Relational_algebra#Division
Features and improvements
------------------------#161 - Add runtime configuration to pretty print rendered SQL
#349 - Add SQLite relations support
#491 - Add runtime configuration for SQL keyword style (upper
case, lower case)
#521 - Add runtime configuration for SQL reference style (upper
case, lower case, as-is, quoted)
#1150 - Add code generation option to disable generation of
records
#1181 - Add support for SQL Server data types timestamp and
rowversion
#1188 - Load default Settings from the classpath at
/jooq-settings.xml, or from -Dorg.jooq.settings
#1193 - Specify main-class in jOOQ Console's manifest.mf and
include dependency in jar file
#1194 - Add ColumnDefinition.isNullable()
#1202 - Add support for the relational division operation:
A.divideBy(B).on(A.ID.equal(B.A_ID)).returning(A.X, ...)
#1207 - Add Factory.batch(Collection<? extends Query>) for
convenience
#1208 - Render @javax.persistence.Column(nullable = false)
property, if available
#1209 - Render @javax.persistence.Column(length, precision,
scale) properties, if available
#1215 - Add org.jooq.Converter<T, U> for custom type mapping
#1216 - Overload Record, Result.getValue() and .setValue()
methods to accept a Converter
#1217 - Add EnumConverter as a base type for custom enum
converters
#1218 - Add code generation options to generate <customTypes/>
referencing a Java type and a Converter
#1224 - Add DataTypeDefinition.getLength() to jooq-meta's type
system
#1233 - Support custom JDBC properties for jooq-codegen
#1234 - Add Database.getTable(SchemaDefinition, String, boolean)
to fetch tables case-insensitively
#1239 - Add Factory.fetchLazy(String, Object...)
API changes (backwards-compatible)
---------------------------------#1191 - Deprecate ConfigurationRegistry and replace by equivalent
ExecuteListener feature
#1219 - API Bug: Cannot use LIMIT .. OFFSET along with FOR UPDATE
Bug fixes
Javadoc
#1040 - Add Object[][] Result.intoArray() and
Object[] Record.intoArray() for convenience. Let
<E> E Record.into(Class<E>) also support array types.
#1041 - Add <R> Table<R> Factory.table(Select<R>) convenience
method for more fluency
#1042 - Add support for DISTINCT keyword in SUM, AVG, MIN, MAX
aggregate functions
#1046 - Generate Ingres table and column comments in generated
source code (only Ingres 10)
API changes (backwards-compatible)
---------------------------------#1050 - Deprecate usage of SOME quantifier in predicates, such as
equalSome()
API changes (backwards-incompatible)
-----------------------------------#1036 - Fixed API typo in
WindowsRowsStep.rowsBetweenUnboundedFollwing()
#1037 - The fluent API allows for JOIN clauses without FROM
clause
Bug fixes
--------#1010 - The MERGE INTO .. WHEN NOT MATCHED THEN INSERT .. syntax
may cause type-safety issues in some databases. VALUES
should be converted before binding
#1014 - FindBugs: Latent risk of infinite recursion due to typo
in QueryPartList.retainAll();
#1015 - FindBugs: 7 occurrences of "Bad attempt to compute
absolute value of signed 32-bit hashcode". In extreme
cases, this could lead to SQL syntax errors
#1016 - The Oracle CONNECT BY cond1 AND cond2 syntax erroneously
creates a WHERE cond2 CONNECT BY cond1 statement
#1028 - Syntax errors when using untyped param() in HSQLDB (and
other strongly typed dialects)
#1029 - Postgres can't bind NULL values in cases, where bind type
is Object.class and bind value was created with
Factory.param()
#1030 - UnsupportedOperationException when calling
Query.bind(int, Object) on a query containing plain SQL
fields
#1031 - Incorrect debug logging when plain SQL QueryParts like
field("?") bind null values
#1032 - Incorrect debug logging when plain SQL QueryParts contain
String literals, such as 'Hello? Anyobody out there?'
#1047 - Field.notEqualAny() erroneously renders <> ALL()
Test cases
---------#1021 - Add explicit integration tests for
LEFT|RIGHT|FULL OUTER JOIN
Version 2.0.1 - December 23, 2011
================================================================================
This is a maintenance release for jOOQ 2.0. The main improvements
include
Test cases
---------#984 - Detach IDENTITY column tests from UNIQUE KEY tests,
create a dedicated test suite instead
Version 2.0.0 - November 25, 2011
================================================================================
This release is a fresh start in many areas of jOOQ, adressing
issues that have been requested by users for a long time. These
release notes docment the most important changes, a detailed
upgrade guide, as well as the detailed list of improvements.
Most important changes
---------------------- The API became more static. This applies to many Factory
methods, such as val(), literal(), as well as to many Field
methods that have been moved over to the Factory. For example,
when before, you wrote this using "postfix function notation":
<pre>NAME.replace(" ", "_").trim()</pre>
you will now write (just as in SQL):
<pre>trim(replace(NAME, " ", "_"))</pre>
Using static imports of Factory.*, jOOQ makes SQL look even
more like SQL. The current "postfix notation" is maintained for
backwards compatibility.
- By default, jooq-codegen will now generate a "dynamic" meta
model as opposed to the existing static one. Generated tables
covariantly override the as(String) aliasing method, leading
to a much more convenient aliasing style. When before, you
wrote:
<pre>
Table<TRecord> parent = T.as("parent");
Table<TRecord> child = T.as("child");
Condition join =
parent.getField("ID").equal(child.getField("PARENT_ID"))
</pre>
#917 #918 #919 #923 #924 #928 #930 #931 #932 #933 #936 #938 #939 #953 #954 #955 #957 #958 #960 #961 #969 -
Result.into(Table<R>) | ResultQuery.fetchInto(Table<R>) |
Cursor.fetchInto(Table<R>)}
Add various Cursor.fetchOneInto() convenience methods
Add CustomTable, CustomRecord as base classes for more
convenience when used with various into(Table) methods
Allow for accessing non-public constructors of Record
subtypes
Move some utilities to org.jooq.tools
Generate a reference to every table in a new Tables.java
class for improved static access
Add DataTypeException extending DataAccessException in
case something went wrong when converting data types
Support converting date time types to java.util.Calendar.
This applies to various into(Class<?>) methods, as well as
Result.getValue(xx, Class<?>)
Allow for conversion between Long and date/time types, and
vice versa
Let the bound of R in TableRecord extend TableRecord<R>,
in UpdatableRecord to extend UpdatableRecord<R>
Add support for type Character in Record.into(Class<?>)
methods and similar
Accept primitive types, such as int.class for type
conversion
CODEGEN: Add static/instance table field configuration
Include license.txt and readme.txt in .jar files' META-INF
directory
Make DefaultGeneratorStrategy methods non-final to allow
for overriding
Add examples for source code generation of multiple
schemata with Maven
Generate a reference to every type in a new UDTs.java
class
Add <R> R Factory.newRecord(UDT<R>) for constructing
attached UDTRecords
CODEGEN: Add generation-time schema mapping, allowing for
re-writing schemata in jooq-codegen
CODEGEN: Add code generation configuration parameter to
avoid using the new UByte, UShort, UInteger, ULong wrappers
for UNSIGNED number types
Use Oracle's SYS.ALL_SEQUENCES.MAX_VALUE to determine the
type of a sequence.
Add <T> List<T> ResultQuery.fetch(Field<?>,
Class<? extends T>) convenience method
Bug fixes
--------#686 - Reduce the internal API leak by preventing access to
TableFieldImpl, UDTFieldImpl, ParameterImpl
#903 - lag(Field, int, T) erroneously delegates to lead()
#906 - Add more NullPointerException safety to API
#913 - NoClassDefFoundError in JooqUtil.isJPAAvailable()
#920 - Generic type is lost in Cursor.fetchInto(RecordHandler)
#925 - SelectConditionStep should extend SelectConnectByStep, not
SelectGroupByStep
#926 - AbstractRecord.into() fails to convert java.sql.Date into
java.util.Date
#934 - Don't consider static members in reflection utilities when
used with Record.into(Class<?>) and similar methods
#935 - Don't consider final member fields in reflection utilities
when used with Record.into(Class<?>) and similar methods
#937 - In the event of name clash (same name for table and field)
generated code has errors
#945 - Calling UpdatableRecord.setValue() twice with the same
argument causes the changed flag to be reset to false
#948 - Always set the changed flag to true in Record.setValue()
#959 - Compilation errors in generated source code if MySQL enum
values match Java reserved words, such as 'true', 'false',
'new', etc...
#962 - Postgres ordering of generated enum literals is unstable
#967 - Better document type conversion
Version 1.7.0 - November 25, 2011
================================================================================
This is a maintenance release for the 1.x branch. Some important
bug fixes are merged from version 2.0. These include:
Bug fixes
--------#925 - SelectConditionStep should extend SelectConnectByStep, not
SelectGroupByStep
#926 - AbstractRecord.into() fails to convert java.sql.Date into
java.util.Date
#937 - In the event of name clash (same name for table and field)
generated code has errors
#945 - Calling UpdatableRecord.setValue() twice with the same
argument causes the changed flag to be reset to false
#948 - Always set the changed flag to true in Record.setValue()
#951 - Empty Password for jooq-codegen-maven causes NPE
Version 1.6.9 - November 7, 2011
================================================================================
This is a maintenance release for the 1.x branch. Developments
on this branch will stop after version 1.6.9. Only important bug
fixes are merged to this branch. Developments for release 2.0
have started.
The most important functionality in release 1.6.9 is the newly
added support for JDBC batch operations. You can now batch
execute several queries.
See the official blog for more information:
http://blog.jooq.org/2011/10/25/jdbc-batch-operations-with-jooq/
Features and improvements
------------------------#621 - Add support for JDBC batch operations
#794 - Add support for ORDER BY [int value] in order to reference
a column index for sorting
#882 - Optimise Field.isTrue() and isFalse(). Take Field's data
type into consideration.
#885 - Add support for INSERT INTO .. VALUES (..) syntax,
omitting explicit field declarations
#887 - Add <E> List<E> Cursor.fetchInto(Class<E>)
Bug fixes
--------#748 - H2 regression in 1.3.158 regarding stored functions, which
return a ResultSet (this was fixed in H2)
#859 - Derby casting of numeric types to BOOLEAN doesn't work
#886 - Regression in date extract function when used in a
subselect
#888 - Derby casting of VARCHAR to FLOAT (and similar) doesn't
work
Version 1.6.8 - October 22, 2011
================================================================================
The main improvement of this release is the re-design of the
stored procedure / function API. With 12 supported RDBMS, which
all have their own idea about what is a stored procedure and what
is a stored function, it has proven to be a better design, to
unite them in one single type: org.jooq.Routine. A routine can
have a return value as well as OUT parameters. It can be embedded
in SQL and used as a field or a table.
This means, you will need to re-generate your database schema,
when upgrading to jOOQ 1.6.8. After re-generation, you'll need to
fix your client code. These are the package changes:
-
[generated.package].procedures
[generated.package].functions
[generated.package].Procedures
[generated.package].Functions
>
>
>
>
[generated.package].routines
[generated.package].routines
[generated.package].Routines
[generated.package].Routines
and Postgres
#827 - Support Sybase SQL Anywhere's TOP n START AT m clause
instead of simulating it with nested SELECT's
API changes (previous API now deprecated)
----------------------------------------#817 - Deprecate Factory.lastID(Identity)
Bug fixes
--------#815 - SQL Server fetching of IDENTITY value is broken
#821 - Optimise ResultQuery.fetchAny() executing fetchLazy()
internally, and only fetching one record from the cursor
#822 - Let Constant cast to more precise NUMERIC/DECIMAL types
in those RDBMS where casting is necessary
#823 - Cannot bind SQLite BigDecimal, BigInteger types - bind
them as String instead
#824 - BigInteger values cannot be bound in DB2, Derby
#828 - Document inefficient implementation for GREATEST and LEAST
in some RDBMS
Version 1.6.5 - August 28, 2011
================================================================================
This release finally adds a loader for CSV data to jOOQ. You can
now load CSV data using a simple fluent API, configuring error
handling, duplicate behaviour and transaction handling, as well
as various CSV parameters.
This release also changes the way generated keys are retrieved
after INSERT's. Instead of (potentially inconsistently) running
SELECT MAX(pk) immediately after the INSERT, Postgres' INSERT..
RETURNING clause is used (or simulated), in a single statement.
Features and improvements
------------------------#784 - Add Result.exportXML() to retrieve a DOM document similar
to that of .formatXML()
#792 - Add support for loading of CSV data into tables
#795 - Add <T> List<T> fetch(int, Class<T>) and
fetch(String, Class<T>) convenience methods
#803 - Add support for INSERT .. RETURNING or simulate it where
not available
#805 - Add <T> T[] fetchArray(int, Class<T>) and
fetchArray(String, Class<T>) convenience methods
#806 - Add <T> T fetchOne(int, Class<T>) and
fetchOne(String, Class<T>) convenience methods
Bug fixes
--------#798 - Oracle IN (...) clause with more than 1000 arguments does
not work
#802 - Use "INSERT .. RETURNING" instead of "SELECT MAX(pk)"
to retrieve the primary key of a new record
Version 1.6.4 - August 07, 2011
================================================================================
This release ships with a couple of useful concepts inspired by
other frameworks. These are:
Bug fixes
--------#730 - Sybase cannot bind null values in plain SQL
#759 - Omit the TOP 100 PERCENT clause in SQL Server ordered
top-level queries
#767 - An empty Java package is generated for PL/SQL packages
containing underscores
#771 - Some exotic literals are not properly escaped with quotes
yet, e.g. UDT identifiers, VARRAY types, etc.
#775 - Automatic re-attaching after deserialisation does not work
when used with .fetchLazy()
#787 - The UpdatableRecord's internal changed flags are not
updated after INSERTs / UPDATEs
Version 1.6.3 - July 31, 2011
================================================================================
This is mainly a maintenance release with lots of bugfixes,
mostly around code generation, plain SQL tables, and data types.
Please note that generated source code may contain incompatible
changes due to #639 (see below for details)!
Apart from that, project CURSOR is advancing and it is now
possible to unnest arrays into tables. See this article for
details about where jOOQ is heading with project CURSOR:
http://blog.jooq.org/2011/07/24/the-power-of-ref-cursor-types/
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 (previous API now deprecated)
----------------------------------------#731 - Inconsistent API with Field.lessOrEqualToXXX(). Removed
"To" from method name
#757 - Deprecate Factory.constant() methods
Test cases
----------
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
Version 1.6.1 - June 19, 2011
================================================================================
In this release, the PORTABILITY project has been implemented.
Finally, the SQLDialect has been removed from most generated
artefacts (Schema, Table, Field, Sequence, etc). Also, the
constructing Factory is not referenced by its created QueryParts
anymore, unless this is really necessary (Query objects, UDT's,
ARRAY types). This leads to higher compatibility between schemata
of different databases, e.g. if users want to use an HSQLDB
development and Oracle productive database.
Unfortunately, this means that the way stored procedures are
called had to be changed. This is an API break that could not be
avoided. The pre-1.6.1 StoredObject.execute(Connection) method
is deprecated and will be removed in the future. It has been
replaced by StoredObject.execute(Configuration)
In addition to this project, many more window functions are now
supported, as well as the Oracle-specific CONNECT BY clause for
recursive queries.
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 Oraclegenerated 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
Version 1.6.0 - June 05, 2011
================================================================================
Apart from supporting various additional standard and nonstandard JOIN constructs, there is now also full support for the
SQL standard MERGE statement and MySQL's ON DUPLICATE KEY variant
thereof. A great number of API enhancements have been added,
which improve the usability of jOOQ. The Ingres database is now
also supported.
Features
-------#301 - Add support for Oracle execution hints
#409 - Add support for NATURAL JOIN syntax, where RDBMS allows it
#415 - Make fluent API's underlying SelectQuery objects publicly
available
#429 - Add Ingres support
#475 - Document class-level generic types <R> and <T> in Javadoc
#486 - Add support for SQL MERGE clause
#494 - Allow for omitting schema name in generated SQL
#496 - Automatically update IDENTITY values in UpdatableRecord,
after storing them
#520 - Add support for JOIN ... USING syntax
#524 - Upgrade HSQLDB to 2.2
#533 - Add ORDER BY [Map] or BY [List] functionality
#534 - Add Result.isEmpty()
#535 - Call upon ConfigurationRegistry.provideFor() before
throwing a DetachedException
#536 - Simulate CASE [value] WHEN [value] THEN [result] END
syntax in Derby
#538 - Add some logging to ConfigurationProvider
#539 - Add possibility to negate numeric values with Field.neg()
#541 - Add support for MySQL ON DUPLICATE KEY clause
#542 - Allow for Collection arguments in INSERT's DSL API
#543 - Allow for creating FUNCTION() OVER() without PARTITION BY
or ORDER BY clause
#546 - Add Factory.use(Schema)
#548 - Add new internal type FieldMap
#550 - Simulate ON DUPLICATE KEY INSERT clause in dialects other
than MySQL
#551 - Add TableMapping, similar to SchemaMapping for mapping
tables
#553 - Add Factory.plainSQLQuery
#554 - Add Factory.plainSQLField with a DataType parameter
#555 - Add UpdateXXX.set(Map) convenience methods to DSL API
#557 - Enhance INSERT DSL API to allow for adding VALUES clause
with InsertXXX.set() syntax
#570 - Add support for the RAND() function
#567 - Add support for Ingres Sequences
#572 - Add support for the ATAN2() function
#573 - Add possibility for additional select() clauses for
convenience
#575 - Add support for the FULL OUTER JOIN syntax, where RDBMS
supports it
#576 - Add support for the CROSS JOIN syntax, where RDBMS
supports it
#581 - Enhance API and allow Collection<? extends Field<?>>
instead of Collection<Field<?>>
API changes
----------#397 - Purge deprecated API
Bugfixes
-------#481 - Handle case where an empty record is stored
#522 - Misleading Javadoc in generated stored procedures and
function constructors
#532 - Restore Postgres INFORMATION_SCHEMA
#537 - Prevent null from being added to QueryPartList
#540 - Error when TRACE logging Limit
#544 - Aliased elements are not bound correctly when rendered
with toSQLReference()
API changes
----------#428 - Created new Maven artefact jooq-meta to cleanly separate
database meta-data navigation from code generation
#458 - Decreased DSL verbosity for arithmetic operations and for
ordering
Bug fixes
--------#417 - Restored warning when unknown column type is encountered
in source code generation
#419 - Corrected misleading Select.fetchOne(...) Javadoc
#421 - Optimised AbstractRecord's memory consumption
#448 - Corrected some Javadoc @see links
#449 - Changed Field.concatenate() to accept Field<?> parameters
to avoid generic varargs warnings
Version 1.5.7 - April 17, 2011
================================================================================
This is the first release built with support of Maven thanks to
the help of some jOOQ users!
The main new features in this release are the improved support
for serialisation/deserialisation of jOOQ objects through use of
the newly introduced "Attachable" interface.
If using log4j or the newly supported slf4j logging framework
in debug/trace mode, there is the possibility to log query
building/execution time statistics.
Apart from these new features, fixes were mainly done in the
fields of type casting, HSQLDB 2.1 upgrade support, stored
procedures with OUT, IN/OUT parameters. Please upgrade, if you
are using any of those features.
If you extend jOOQ as a base implementation for source code
generation, be aware of the fact, that the jOOQ-codegen is
currently undergoing major changes. Expect the code generation
API to stabilise again in one of the next releases.
Features
-------#104 - Added maven dependency
#248 - Integrate UDT types with ARRAYs
#295 - Allow for attaching/detaching UpdatableRecords to/from
Configurations
#359 - Added statistics measurement to Query execution for debug
log level
#362 - Added deprecation configuration flag
#364 - Document unknown type in generated source code
#373 - Improve exception handling in code generation
#378 - Added support for Oracle stored functions with OUT
parameters
#382 - Added Factory.attach() methods to re-attach deserialised
Attachables
#394 - Add logging support for SLF4J
#398 - Allow to provide a DataType in Factory.constant()
Features
-------#90 - Added possibility for lazy fetching of data
#208 - Added convenience methods for direct invocation of
sequences' currval() and nextval() attributes
#212 - Created one factory per dialect for better separation of
dialect-specific support
#213 - Generate a factory for each schema
#251 - Opened up base implementations for Field<?> and Condition
to allow for custom implementations by client code
#274 - Integrate H2 ARRAY types with stored procedures
#292 - Documented usage of log4j and java.util.logging
#306 - Added support for the NULLIF function
#319 - Added Field.between(Field<T>, Field<T>) method
#320 - Added trace logging for variable binding and SQL
generation methods
#323 - Added Field.in(Field<?>...) method
#325 - Include release version number in delivered .jar files
#328 - Improved configuration setup documentation page
#333 - Let Result implement Serializable
#334 - Added fetchMap() convenience methods
#335 - Added more functions and aggregate functions examples to
documentation
#338 - Visually improve code generation logging
#339 - Removed skipping of unreferenced UDT's, ENUM's and ARRAY's
#342 - Improved generated referential code by using fetch() and
fetchOne() API
#356 - Let UpdatableRecord.store() and delete() return an int
to indicate whether the record was actually modified
API changes
----------#233 - Allow for joining TableLike instead of Table
#337 - Added generic type <R extends TableRecord<R>> to
InsertSelectQuery
#341 - Fixed API flaw where SelectOnConditionStep.and() methods
and similar ones returned SelectConditionStep, instead of
SelectOnConditionStep
Bugfixes
-------#69 - Corrected referential code generation for foreign keys
that reference non-primary unique keys
#85 - Corrected referential code generation for multi-field
foreign keys
#121 - Covered more Factory.executeXXX() methods with integration
tests
#318 - Fixed NullPointerException when executing SELECT * from
aliased tables
#321 - BetweenCondition does not bind left hand side Field
correctly
#322 - InCondition does not bind left hand side Field correctly
#326 - Avoid method overloading where binding <T> to Object
may lead to compile-time ambiguities (with javac)
#343 - Add more foreign key navigation method integration tests
#347 - Add explicit integration tests for schema artefacts
excluded from code generation
#350 - Disambiguate navigation methods if several foreign keys
reference the same entity
#352 - Disambiguate navigation methods if a table ending on S
references itself
#353 - Added integration test for compilation of generated
artefacts with javac (as opposed to the Eclipse compiler)
#355 - Error when storing an UpdatableRecord that has no changed
values
Version 1.5.5.2 - March 15, 2011
================================================================================
A critical bug was reported from the 1.5 release stream where
stored functions did not render their parameters in correct order
Features
-------#302 - Map Oracle's NUMBER data type to java.lang.Number in
stored procedures, stored functions
Bugfixes
-------#317 - StoredFunctionImpl.asField() renders parameters in wrong
order
Version 1.5.5.1 - March 13, 2011
================================================================================
In version 1.5.5, there was a fatal bug breaking Derby source code generation.
Only the Derby dialect is affected. Please update immediately, if you are using
jOOQ's Derby integration
Bugfixes
-------#315 - Generated master data records are not sorted by PK
#316 - Derby code generation fatally broken
Version 1.5.5 - March 12, 2011
================================================================================
This version is released early as there are some important bugfixes. Additional
improvements include:
- Improved DSL related to conditions in HAVING and JOIN clauses
- Support for Oracle-style functions, such as NVL, NVL2, COALESCE
DECODE, etc
Features
-------#304 - Add
#305 - Add
#308 - Add
#311 - Add
support
support
support
support
for
for
for
for
API changes
----------#223 - Enhance DSL to accept and(), or() and similar methods in JOIN steps
#224 - Enhance DSL to accept and(), or() and similar methods in HAVING steps
Bugfixes
-------#297 - Fixed Factory.concatenate() function
#298 - Added integration tests for nested selects in HAVING clause
#300
#303
#307
#309
generation
#269 - Add H2 support for ARRAY types
#290 - If log4j is not on the classpath, use java.util.logging instead, as
fallback
API Changes
----------#156 - Allow for results to be accessed by index, not by field
#218 - Corrected bad method signature: Record.getValueAsLong(Field<?>, Integer)
#219 - Extended Result and Select API's to be more similar to that of Record
#232 - Add more convenience plain SQL support to the API
#235 - Add convenience methods to Record, Result and Select for access of data
via field name
#243 - Refactor DataType implementations in order to allow for the use of
generics
#259 - Add field type to database meta data (ColumnDefinition)
#260 - Add field type to database meta data (Field<?>)
#262 - Add default behaviour for Record.getValue(Field<?>)
#276 - Add Javadoc as a ZIP file to the jOOQ distribution
Bugfixes
-------#125 - Add more plain SQL integration tests
#191 - Add more integration tests for nested unions
#205 - Implemented workaround for handling Postgres stored functions with UDT
OUT parameters
#214 - Fixed NPE when generating a stored function with an unknown parameter
type
#216 - Fixed some cases where binding of BigInteger is not done correctly
#220 - Syntax error when using select statement in a CASE clause
#221 - Corrected integration tests for combined update and select statements
#222 - Added integration test for INSERT statements having nested SELECT
statements for their fields
#225 - Correctly cast array types in Postgres
#230 - Potential misuse of Blob and Clob in H2's JDBC types
#239 - Factory.fetchAny() is not implemented for SQLite
#244 - Fixed peculiar MySQL casting support where cast types do not match any
data types
#245 - Fixed NPE when reading null dates in SQLite
#249 - Added ARRAY type integration tests
#255 - Stored procedure bind variables get mixed up when any argument is null
#263 - Correctly handle Postgres function overloading
#264 - Ambiguous funciton calls when calling overloaded functions with null
parameter
#281 - Handle compilation errors when generating stored procedures with > 254
parameters
#283 - Fixed compilation errors in generated source code for Oracle's UDT table
type
#284 - Fixed compilation errors in generated source code for Oracle procedures
in packages, when they have no parameters
#285 - Fixed compilation errors in generated source code for Oracle tables with
the same name in different schemata
#286 - Fixed name collisions in generated objects with the java.lang.* package
#288 - Prevent the creation of UNION queries with bad syntax in MySQL
#289 - Correctly alias fields within UNION queries for some dialects, which then
only require the "AS" keyword
#291 - Cannot create an aliased field called "year" in Postgres
Version 1.5.3 - January 13, 2011
================================================================================
Features
-------#36 - Added stored procedure / stored function support for HSQLDB
#140 - Added support for Oracle sequences
#147 - Added support for H2 stored functions
#162 - Correctly integrate UDTs with stored procedures
#170 - Added support for Postgres stored functions
#186 - Added support for more Oracle PL/SQL simple data types
#193 - Simulate support for H2 "stored procedures"
#195 - Simulate support for Postgres "stored procedures"
#206 - Added support for Postgres sequences
API changes
----------#180 - Improved DSL for constant values
#181 - Allow for referencing Field<?> in function argument list
#189 - Renamed convenience methods in org.jooq.Record
#207 - Add fetchOne(Field) method to org.jooq.Select API
Bugfixes
-------#182 - Protected generated Record classes against clashes with inherited methods
#183 - Fixed NullPointerException, when generating master data tables with
NULL fields
#184 - Fixed IllegalArgumentException, when a data type is present in the
schema, but unavailable in code generation logic
#185 - Code generation should not fail when single elements cannot be generated
#188 - Improved integration tests for stored procedures / functions / packages
#196 - Increase RDMBS version compatibility by avoiding "SELECT *" in code
generation logic
#199 - Added integration tests for stored procedures in RDBMS that do not
support OUT parameters
#201 - Fixed issue in DB2 where stored procedures without parameters were not
generated.
#202 - Added integration tests for stored procedures / functions without
parameters
Version 1.5.2 - December 27, 2010
================================================================================
- Improved support for stored procedures, also in packages
- A minor API change was inevitable to implement #173. The API change only
concerns the INTERNAL API. Deprecation marks are added and deprecated items
will be removed in 1.6.0
- Experimental SQLite database support
- Some important bug fixes
Features
-------#25 - Added support for Oracle packages
#114 - Added support for Oracle UDTs
#145 - Added support for the SQLite database
#150 - Generate static convenience methods for stored procedures / functions
#151 - Generate static convenience methods for stored function fields
H2 database support
stored procedure / stored function support for Oracle
stored procedure support for DB2
support for DB2 functions
API changes
----------#143 - Added convenience methods to Record
Bugfixes
-------#84 - Implemented referential code generation for foreign keys that do not
match their primary keys' types
#141 - Encoding problem in generated master data classes
Version 1.5.0 - November 22, 2010
================================================================================
-
Features
-------#1 - Create support for UDTs (so far only for PostgreSQL)
#15 - Added DB2 support
#60 - Added support for nested selects in INSERT and UPDATE statements
The main new feature is the Oracle support. Wait for Version 1.1.1 for that
support to be stabilised, as there are no Oracle unit tests running against an
Oracle database yet.
Features
-------#2
#3
#4
#6
#9
#17
Bugfixes
-------#11 - Code generation does not remove files
Version 1.0.1 - August 14, 2010
================================================================================
Features
-------#5 - Prevent code regeneration, if no changes were made
#7 - Implement ant task for code generation
Version 1.0.0 - August 14, 2010
================================================================================
Initial Release