From 423d9ceefbbe27240b62e24127909c4f62159e5c Mon Sep 17 00:00:00 2001
From: Lukas Eder <lukas.eder@gmail.com>
Date: Mon, 18 Nov 2013 12:27:40 +0100
Subject: [PATCH] =?UTF-8?q?[#2829]=20Integrated=20Johanes=20B=C3=BChler's?=
 =?UTF-8?q?=20pull=20request,=20fixing=20formatting,=20license=20headers,?=
 =?UTF-8?q?=20etc.=20[#2853]=20Add=20DSLContext.fetchFromJSON()?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../test/_/testcases/AbstractLoaderTests.java |   93 +-
 .../jooq/test/_/testcases/CsvLoaderTests.java |   57 +-
 .../jooq/test/_/testcases/FormatTests.java    |   40 +-
 .../test/_/testcases/InsertUpdateTests.java   |   66 +-
 .../test/_/testcases/JsonLoaderTests.java     |   40 +-
 .../src/org/jooq/test/jOOQAbstractTest.java   |   29 +-
 jOOQ/src/main/java/org/jooq/DSLContext.java   | 1003 +++++++----------
 .../java/org/jooq/impl/DefaultDSLContext.java |   75 +-
 .../jooq/{tools/json => impl}/JSONReader.java |   75 +-
 .../main/java/org/jooq/impl/LoaderImpl.java   |   74 +-
 .../java/org/jooq/tools/csv/CSVReader.java    |    7 +-
 .../java/org/jooq/tools/json/JSONParser.java  |    2 +-
 12 files changed, 789 insertions(+), 772 deletions(-)
 rename jOOQ/src/main/java/org/jooq/{tools/json => impl}/JSONReader.java (50%)

diff --git a/jOOQ-test/src/org/jooq/test/_/testcases/AbstractLoaderTests.java b/jOOQ-test/src/org/jooq/test/_/testcases/AbstractLoaderTests.java
index 4a058bc23b..4252d66b6d 100644
--- a/jOOQ-test/src/org/jooq/test/_/testcases/AbstractLoaderTests.java
+++ b/jOOQ-test/src/org/jooq/test/_/testcases/AbstractLoaderTests.java
@@ -1,5 +1,50 @@
+/**
+ * Copyright (c) 2009-2013, Data Geekery GmbH (http://www.datageekery.com)
+ * All rights reserved.
+ *
+ * This work is dual-licensed
+ * - under the Apache Software License 2.0 (the "ASL")
+ * - under the jOOQ License and Maintenance Agreement (the "jOOQ License")
+ * =============================================================================
+ * You may choose which license applies to you:
+ *
+ * - If you're using this work with Open Source databases, you may choose
+ *   either ASL or jOOQ License.
+ * - If you're using this work with at least one commercial database, you must
+ *   choose jOOQ License
+ *
+ * For more information, please visit http://www.jooq.org/licenses
+ *
+ * Apache Software License 2.0:
+ * -----------------------------------------------------------------------------
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * jOOQ License and Maintenance Agreement:
+ * -----------------------------------------------------------------------------
+ * Data Geekery grants the Customer the non-exclusive, timely limited and
+ * non-transferable license to install and use the Software under the terms of
+ * the jOOQ License and Maintenance Agreement.
+ *
+ * This library is distributed with a LIMITED WARRANTY. See the jOOQ License
+ * and Maintenance Agreement for more details: http://www.jooq.org/licensing
+ */
 package org.jooq.test._.testcases;
 
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertNotNull;
+import static junit.framework.Assert.assertNull;
+import static org.jooq.impl.DSL.count;
+
 import java.sql.Date;
 import java.sql.SQLException;
 import java.util.Arrays;
@@ -18,34 +63,32 @@ import org.jooq.test.jOOQAbstractTest;
 
 import org.junit.Test;
 
-import static junit.framework.Assert.assertEquals;
-import static junit.framework.Assert.assertNotNull;
-import static junit.framework.Assert.assertNull;
-import static org.jooq.impl.DSL.count;
-
 /**
- *
+ * @author Johannes Buehler
+ * @author Lukas Eder
  */
 public abstract class AbstractLoaderTests<
-        A extends UpdatableRecord<A> & Record6<Integer, String, String, Date, Integer, ?>,
-        AP,
-        B extends UpdatableRecord<B>,
-        S extends UpdatableRecord<S> & Record1<String>,
-        B2S extends UpdatableRecord<B2S> & Record3<String, Integer, Integer>,
-        BS extends UpdatableRecord<BS>,
-        L extends TableRecord<L> & Record2<String, String>,
-        X extends TableRecord<X>,
-        DATE extends UpdatableRecord<DATE>,
-        BOOL extends UpdatableRecord<BOOL>,
-        D extends UpdatableRecord<D>,
-        T extends UpdatableRecord<T>,
-        U extends TableRecord<U>,
-        UU extends UpdatableRecord<UU>,
-        I extends TableRecord<I>,
-        IPK extends UpdatableRecord<IPK>,
-        T725 extends UpdatableRecord<T725>,
-        T639 extends UpdatableRecord<T639>,
-        T785 extends TableRecord<T785>> extends BaseTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, UU, I, IPK, T725, T639, T785> {
+    A    extends UpdatableRecord<A> & Record6<Integer, String, String, Date, Integer, ?>,
+    AP,
+    B    extends UpdatableRecord<B>,
+    S    extends UpdatableRecord<S> & Record1<String>,
+    B2S  extends UpdatableRecord<B2S> & Record3<String, Integer, Integer>,
+    BS   extends UpdatableRecord<BS>,
+    L    extends TableRecord<L> & Record2<String, String>,
+    X    extends TableRecord<X>,
+    DATE extends UpdatableRecord<DATE>,
+    BOOL extends UpdatableRecord<BOOL>,
+    D    extends UpdatableRecord<D>,
+    T    extends UpdatableRecord<T>,
+    U    extends TableRecord<U>,
+    UU   extends UpdatableRecord<UU>,
+    I    extends TableRecord<I>,
+    IPK  extends UpdatableRecord<IPK>,
+    T725 extends UpdatableRecord<T725>,
+    T639 extends UpdatableRecord<T639>,
+    T785 extends TableRecord<T785>>
+extends BaseTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, UU, I, IPK, T725, T639, T785> {
+
     public AbstractLoaderTests(jOOQAbstractTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, UU, I, IPK, T725, T639, T785> delegate) {
         super(delegate);
     }
diff --git a/jOOQ-test/src/org/jooq/test/_/testcases/CsvLoaderTests.java b/jOOQ-test/src/org/jooq/test/_/testcases/CsvLoaderTests.java
index 4c21fa9a10..b61b81a817 100644
--- a/jOOQ-test/src/org/jooq/test/_/testcases/CsvLoaderTests.java
+++ b/jOOQ-test/src/org/jooq/test/_/testcases/CsvLoaderTests.java
@@ -40,34 +40,42 @@
  */
 package org.jooq.test._.testcases;
 
-import org.jooq.*;
-import org.jooq.test.jOOQAbstractTest;
-
 import java.sql.Date;
 
-// ...
+import org.jooq.Loader;
+import org.jooq.Record1;
+import org.jooq.Record2;
+import org.jooq.Record3;
+import org.jooq.Record6;
+import org.jooq.TableRecord;
+import org.jooq.UpdatableRecord;
+import org.jooq.test.jOOQAbstractTest;
 
+/**
+ * @author Johannes Buehler
+ * @author Lukas Eder
+ */
 public class CsvLoaderTests<
-        A extends UpdatableRecord<A> & Record6<Integer, String, String, Date, Integer, ?>,
-        AP,
-        B extends UpdatableRecord<B>,
-        S extends UpdatableRecord<S> & Record1<String>,
-        B2S extends UpdatableRecord<B2S> & Record3<String, Integer, Integer>,
-        BS extends UpdatableRecord<BS>,
-        L extends TableRecord<L> & Record2<String, String>,
-        X extends TableRecord<X>,
-        DATE extends UpdatableRecord<DATE>,
-        BOOL extends UpdatableRecord<BOOL>,
-        D extends UpdatableRecord<D>,
-        T extends UpdatableRecord<T>,
-        U extends TableRecord<U>,
-        UU extends UpdatableRecord<UU>,
-        I extends TableRecord<I>,
-        IPK extends UpdatableRecord<IPK>,
-        T725 extends UpdatableRecord<T725>,
-        T639 extends UpdatableRecord<T639>,
-        T785 extends TableRecord<T785>>
-        extends AbstractLoaderTests {
+    A extends UpdatableRecord<A> & Record6<Integer, String, String, Date, Integer, ?>,
+    AP,
+    B extends UpdatableRecord<B>,
+    S extends UpdatableRecord<S> & Record1<String>,
+    B2S extends UpdatableRecord<B2S> & Record3<String, Integer, Integer>,
+    BS extends UpdatableRecord<BS>,
+    L extends TableRecord<L> & Record2<String, String>,
+    X extends TableRecord<X>,
+    DATE extends UpdatableRecord<DATE>,
+    BOOL extends UpdatableRecord<BOOL>,
+    D extends UpdatableRecord<D>,
+    T extends UpdatableRecord<T>,
+    U extends TableRecord<U>,
+    UU extends UpdatableRecord<UU>,
+    I extends TableRecord<I>,
+    IPK extends UpdatableRecord<IPK>,
+    T725 extends UpdatableRecord<T725>,
+    T639 extends UpdatableRecord<T639>,
+    T785 extends TableRecord<T785>>
+extends AbstractLoaderTests<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, UU, I, IPK, T725, T639, T785> {
 
     public CsvLoaderTests(jOOQAbstractTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, UU, I, IPK, T725, T639, T785> delegate) {
         super(delegate);
@@ -237,5 +245,4 @@ public class CsvLoaderTests<
                 .fields(TAuthor_ID())
                 .execute();
     }
-
 }
diff --git a/jOOQ-test/src/org/jooq/test/_/testcases/FormatTests.java b/jOOQ-test/src/org/jooq/test/_/testcases/FormatTests.java
index 07f0304483..79f95da9a8 100644
--- a/jOOQ-test/src/org/jooq/test/_/testcases/FormatTests.java
+++ b/jOOQ-test/src/org/jooq/test/_/testcases/FormatTests.java
@@ -40,18 +40,10 @@
  */
 package org.jooq.test._.testcases;
 
-import org.jooq.*;
-import org.jooq.test.BaseTest;
-import org.jooq.test._.tools.DOMBuilder;
-import org.jooq.test.jOOQAbstractTest;
-import org.junit.Test;
-import org.w3c.dom.Document;
+import static java.util.Arrays.asList;
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertTrue;
 
-import javax.xml.parsers.DocumentBuilder;
-import javax.xml.parsers.DocumentBuilderFactory;
-import javax.xml.xpath.XPath;
-import javax.xml.xpath.XPathExpressionException;
-import javax.xml.xpath.XPathFactory;
 import java.io.ByteArrayInputStream;
 import java.io.InputStream;
 import java.math.BigDecimal;
@@ -61,13 +53,33 @@ import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import static java.util.Arrays.asList;
-import static junit.framework.Assert.assertEquals;
-import static junit.framework.Assert.assertTrue;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+
+import org.jooq.Field;
+import org.jooq.Record;
+import org.jooq.Record1;
+import org.jooq.Record2;
+import org.jooq.Record3;
+import org.jooq.Record6;
+import org.jooq.Result;
+import org.jooq.Row;
+import org.jooq.TableRecord;
+import org.jooq.UpdatableRecord;
+import org.jooq.test.BaseTest;
+import org.jooq.test.jOOQAbstractTest;
+import org.jooq.test._.tools.DOMBuilder;
+
+import org.junit.Test;
+import org.w3c.dom.Document;
 
 /**
  * @author Lukas Eder
  * @author Ivan Dugic
+ * @author Johannes Buehler
  */
 public class FormatTests<
     A    extends UpdatableRecord<A> & Record6<Integer, String, String, Date, Integer, ?>,
diff --git a/jOOQ-test/src/org/jooq/test/_/testcases/InsertUpdateTests.java b/jOOQ-test/src/org/jooq/test/_/testcases/InsertUpdateTests.java
index 1b5718f3ae..296921e257 100644
--- a/jOOQ-test/src/org/jooq/test/_/testcases/InsertUpdateTests.java
+++ b/jOOQ-test/src/org/jooq/test/_/testcases/InsertUpdateTests.java
@@ -40,26 +40,62 @@
  */
 package org.jooq.test._.testcases;
 
-import org.jooq.*;
-import org.jooq.test.BaseTest;
-import org.jooq.test.jOOQAbstractTest;
-import org.junit.Test;
+import static java.util.Arrays.asList;
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertNotNull;
+import static junit.framework.Assert.assertNull;
+// ...
+import static org.jooq.SQLDialect.CUBRID;
+// ...
+import static org.jooq.SQLDialect.DERBY;
+import static org.jooq.SQLDialect.FIREBIRD;
+import static org.jooq.SQLDialect.H2;
+// ...
+import static org.jooq.SQLDialect.MARIADB;
+import static org.jooq.SQLDialect.MYSQL;
+import static org.jooq.SQLDialect.POSTGRES;
+import static org.jooq.SQLDialect.SQLITE;
+// ...
+// ...
+import static org.jooq.impl.DSL.cast;
+import static org.jooq.impl.DSL.castNull;
+import static org.jooq.impl.DSL.count;
+import static org.jooq.impl.DSL.decode;
+import static org.jooq.impl.DSL.falseCondition;
+import static org.jooq.impl.DSL.fieldByName;
+import static org.jooq.impl.DSL.inline;
+import static org.jooq.impl.DSL.max;
+import static org.jooq.impl.DSL.row;
+import static org.jooq.impl.DSL.select;
+import static org.jooq.impl.DSL.selectOne;
+import static org.jooq.impl.DSL.tableByName;
+import static org.jooq.impl.DSL.trueCondition;
+import static org.jooq.impl.DSL.val;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.sql.Date;
 import java.util.Arrays;
 
-import static java.util.Arrays.asList;
-import static junit.framework.Assert.*;
-import static org.jooq.SQLDialect.*;
-import static org.jooq.impl.DSL.*;
+import org.jooq.Field;
+import org.jooq.Insert;
+import org.jooq.InsertQuery;
+import org.jooq.MergeFinalStep;
+import org.jooq.Record;
+import org.jooq.Record1;
+import org.jooq.Record2;
+import org.jooq.Record3;
+import org.jooq.Record6;
+import org.jooq.Result;
+import org.jooq.Table;
+import org.jooq.TableField;
+import org.jooq.TableRecord;
+import org.jooq.UpdatableRecord;
+import org.jooq.UpdateQuery;
+import org.jooq.test.BaseTest;
+import org.jooq.test.jOOQAbstractTest;
 
-// ...
-// ...
-// ...
-// ...
-// ...
+import org.junit.Test;
 
 public class InsertUpdateTests<
     A    extends UpdatableRecord<A> & Record6<Integer, String, String, Date, Integer, ?>,
@@ -556,7 +592,7 @@ extends BaseTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, UU, I, IPK, T7
         // Returning all fields
         InsertQuery<T> query;
         query = create().insertQuery(TTriggers());
-        query.addValue(TTriggers_COUNTER(), (Field)null);
+        query.addValue(TTriggers_COUNTER(), null);
         query.addValue(TTriggers_COUNTER(), 0);
         query.setReturning();
         assertEquals(1, query.execute());
@@ -674,7 +710,7 @@ extends BaseTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, UU, I, IPK, T7
 
         // Without RETURNING clause
         query = create().insertQuery(TTriggers());
-        query.addValue(TTriggers_ID(), (Field)null);
+        query.addValue(TTriggers_ID(), null);
         query.addValue(TTriggers_COUNTER(), 0);
         assertEquals(1, query.execute());
         assertNull(query.getReturnedRecord());
diff --git a/jOOQ-test/src/org/jooq/test/_/testcases/JsonLoaderTests.java b/jOOQ-test/src/org/jooq/test/_/testcases/JsonLoaderTests.java
index 823b3b1f2b..b79370813c 100644
--- a/jOOQ-test/src/org/jooq/test/_/testcases/JsonLoaderTests.java
+++ b/jOOQ-test/src/org/jooq/test/_/testcases/JsonLoaderTests.java
@@ -54,26 +54,26 @@ import org.jooq.test.jOOQAbstractTest;
 // ...
 
 public class JsonLoaderTests<
-        A extends UpdatableRecord<A> & Record6<Integer, String, String, Date, Integer, ?>,
-        AP,
-        B extends UpdatableRecord<B>,
-        S extends UpdatableRecord<S> & Record1<String>,
-        B2S extends UpdatableRecord<B2S> & Record3<String, Integer, Integer>,
-        BS extends UpdatableRecord<BS>,
-        L extends TableRecord<L> & Record2<String, String>,
-        X extends TableRecord<X>,
-        DATE extends UpdatableRecord<DATE>,
-        BOOL extends UpdatableRecord<BOOL>,
-        D extends UpdatableRecord<D>,
-        T extends UpdatableRecord<T>,
-        U extends TableRecord<U>,
-        UU extends UpdatableRecord<UU>,
-        I extends TableRecord<I>,
-        IPK extends UpdatableRecord<IPK>,
-        T725 extends UpdatableRecord<T725>,
-        T639 extends UpdatableRecord<T639>,
-        T785 extends TableRecord<T785>>
-        extends AbstractLoaderTests {
+    A extends UpdatableRecord<A> & Record6<Integer, String, String, Date, Integer, ?>,
+    AP,
+    B extends UpdatableRecord<B>,
+    S extends UpdatableRecord<S> & Record1<String>,
+    B2S extends UpdatableRecord<B2S> & Record3<String, Integer, Integer>,
+    BS extends UpdatableRecord<BS>,
+    L extends TableRecord<L> & Record2<String, String>,
+    X extends TableRecord<X>,
+    DATE extends UpdatableRecord<DATE>,
+    BOOL extends UpdatableRecord<BOOL>,
+    D extends UpdatableRecord<D>,
+    T extends UpdatableRecord<T>,
+    U extends TableRecord<U>,
+    UU extends UpdatableRecord<UU>,
+    I extends TableRecord<I>,
+    IPK extends UpdatableRecord<IPK>,
+    T725 extends UpdatableRecord<T725>,
+    T639 extends UpdatableRecord<T639>,
+    T785 extends TableRecord<T785>>
+extends AbstractLoaderTests<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, UU, I, IPK, T725, T639, T785> {
 
     public JsonLoaderTests(jOOQAbstractTest<A, AP, B, S, B2S, BS, L, X, DATE, BOOL, D, T, U, UU, I, IPK, T725, T639, T785> delegate) {
         super(delegate);
diff --git a/jOOQ-test/src/org/jooq/test/jOOQAbstractTest.java b/jOOQ-test/src/org/jooq/test/jOOQAbstractTest.java
index ee7b896c2d..3b1a837a1c 100644
--- a/jOOQ-test/src/org/jooq/test/jOOQAbstractTest.java
+++ b/jOOQ-test/src/org/jooq/test/jOOQAbstractTest.java
@@ -40,6 +40,17 @@
  */
 package org.jooq.test;
 
+import static java.util.Arrays.asList;
+import static org.jooq.SQLDialect.CUBRID;
+import static org.jooq.SQLDialect.FIREBIRD;
+import static org.jooq.test._.listeners.JDBCLifecycleListener.RS_CLOSE_COUNT;
+import static org.jooq.test._.listeners.JDBCLifecycleListener.RS_START_COUNT;
+import static org.jooq.test._.listeners.JDBCLifecycleListener.STMT_CLOSE_COUNT;
+import static org.jooq.test._.listeners.JDBCLifecycleListener.STMT_START_COUNT;
+import static org.jooq.test._.listeners.LifecycleWatcherListener.LISTENER_END_COUNT;
+import static org.jooq.test._.listeners.LifecycleWatcherListener.LISTENER_START_COUNT;
+import static org.jooq.tools.reflect.Reflect.on;
+
 import java.io.File;
 import java.io.InputStream;
 import java.lang.reflect.Method;
@@ -61,6 +72,7 @@ import java.util.Map;
 import java.util.Properties;
 import java.util.UUID;
 
+// ...
 import org.jooq.DAO;
 import org.jooq.DSLContext;
 import org.jooq.DataType;
@@ -160,23 +172,9 @@ import org.junit.After;
 import org.junit.AfterClass;
 import org.junit.Before;
 import org.junit.BeforeClass;
-import org.junit.Ignore;
 import org.junit.Test;
 import org.postgresql.util.PSQLException;
 
-import static java.util.Arrays.asList;
-import static org.jooq.SQLDialect.CUBRID;
-import static org.jooq.SQLDialect.FIREBIRD;
-import static org.jooq.test._.listeners.JDBCLifecycleListener.RS_CLOSE_COUNT;
-import static org.jooq.test._.listeners.JDBCLifecycleListener.RS_START_COUNT;
-import static org.jooq.test._.listeners.JDBCLifecycleListener.STMT_CLOSE_COUNT;
-import static org.jooq.test._.listeners.JDBCLifecycleListener.STMT_START_COUNT;
-import static org.jooq.test._.listeners.LifecycleWatcherListener.LISTENER_END_COUNT;
-import static org.jooq.test._.listeners.LifecycleWatcherListener.LISTENER_START_COUNT;
-import static org.jooq.tools.reflect.Reflect.on;
-
-// ...
-
 // ...
 
 /**
@@ -1550,7 +1548,6 @@ public abstract class jOOQAbstractTest<
     }
 
     @Test
-    @Ignore // ist currently failing for other reasons than any change from my side
     public void testRecordListenerBatchStore() throws Exception {
         new RecordListenerTests(this).testRecordListenerBatchStore();
     }
@@ -1871,7 +1868,6 @@ public abstract class jOOQAbstractTest<
     }
 
     @Test
-    @Ignore
     public void testLimitDistinct() throws Exception {
         new OrderByTests(this).testLimitDistinct();
     }
@@ -2400,6 +2396,7 @@ public abstract class jOOQAbstractTest<
     public void testCsvLoader() throws Exception {
         new CsvLoaderTests(this).testLoader();
     }
+
     @Test
     public void testJsonLoader() throws Exception {
         new JsonLoaderTests(this).testLoader();
diff --git a/jOOQ/src/main/java/org/jooq/DSLContext.java b/jOOQ/src/main/java/org/jooq/DSLContext.java
index 641930fa1f..37531636a3 100644
--- a/jOOQ/src/main/java/org/jooq/DSLContext.java
+++ b/jOOQ/src/main/java/org/jooq/DSLContext.java
@@ -82,12 +82,13 @@ import org.jooq.impl.DSL;
  * A contextual DSL providing "attached" implementations to the
  * <code>org.jooq</code> interfaces.
  * <p>
- * Apart from the {@link DSL}, this contextual DSL is the main entry point for
- * client code, to access jOOQ classes and functionality that are related to
- * {@link Query} execution. Unlike objects created through the <code>DSL</code>
- * type, objects created from a <code>DSLContext</code> will be "attached" to
- * the <code>DSLContext</code>'s {@link #configuration()}, such that they can be
- * executed immediately in a fluent style. An example is given here:
+ * Apart from the {@link DSL}, this contextual DSL is the main entry point
+ * for client code, to access jOOQ classes and functionality that are related to
+ * {@link Query} execution. Unlike objects created through the
+ * <code>DSL</code> type, objects created from a <code>DSLContext</code> will be
+ * "attached" to the <code>DSLContext</code>'s {@link #configuration()}, such
+ * that they can be executed immediately in a fluent style. An example is given
+ * here:
  * <p>
  * <code><pre>
  * DSLContext create = DSL.using(connection, dialect);
@@ -140,8 +141,8 @@ public interface DSLContext {
      * Map a table to another one.
      * <p>
      * This will map a table onto another one, depending on configured table
-     * mapping in this <code>DSLContext</code>. If no applicable table mapping
-     * can be found, the table itself is returned.
+     * mapping in this <code>DSLContext</code>. If no applicable table mapping can
+     * be found, the table itself is returned.
      *
      * @param table A table
      * @return The mapped table
@@ -165,8 +166,7 @@ public interface DSLContext {
     // -------------------------------------------------------------------------
 
     /**
-     * Get a new {@link RenderContext} for the context of this
-     * <code>DSLContext</code>.
+     * Get a new {@link RenderContext} for the context of this <code>DSLContext</code>.
      * <p>
      * This will return an initialised render context as such:
      * <ul>
@@ -176,9 +176,7 @@ public interface DSLContext {
      * <li> <code>{@link RenderContext#declareFields()} == false</code></li>
      * <li> <code>{@link RenderContext#declareTables()} == false</code></li>
      * <li> <code>{@link RenderContext#format()} == false</code></li>
-     * <li>
-     * <code>{@link RenderContext#paramType()} == {@link ParamType#INDEXED}</code>
-     * </li>
+     * <li> <code>{@link RenderContext#paramType()} == {@link ParamType#INDEXED}</code></li>
      * <li> <code>{@link RenderContext#qualify()} == true</code></li>
      * <li> <code>{@link RenderContext#subquery()} == false</code></li>
      * </ul>
@@ -196,8 +194,8 @@ public interface DSLContext {
     String render(QueryPart part);
 
     /**
-     * Render a QueryPart in the context of this <code>DSLContext</code>,
-     * rendering bind variables as named parameters.
+     * Render a QueryPart in the context of this <code>DSLContext</code>, rendering bind
+     * variables as named parameters.
      * <p>
      * This is the same as calling
      * <code>renderContext().namedParams(true).render(part)</code>
@@ -208,8 +206,8 @@ public interface DSLContext {
     String renderNamedParams(QueryPart part);
 
     /**
-     * Render a QueryPart in the context of this <code>DSLContext</code>,
-     * inlining all bind variables.
+     * Render a QueryPart in the context of this <code>DSLContext</code>, inlining all bind
+     * variables.
      * <p>
      * This is the same as calling
      * <code>renderContext().inline(true).render(part)</code>
@@ -255,8 +253,7 @@ public interface DSLContext {
     Param<?> extractParam(QueryPart part, String name);
 
     /**
-     * Get a new {@link BindContext} for the context of this
-     * <code>DSLContext</code>.
+     * Get a new {@link BindContext} for the context of this <code>DSLContext</code>.
      * <p>
      * This will return an initialised bind context as such:
      * <ul>
@@ -819,8 +816,7 @@ public interface DSLContext {
      * @return The results from the executed query. This may be
      *         <code>null</code> if the database returned no records
      * @throws DataAccessException if something went wrong executing the query
-     * @throws InvalidResultException if the query returned more than one record
-     *             or a record with more than one value.
+     * @throws InvalidResultException if the query returned more than one record or a record with more than one value.
      */
     @Support
     Object fetchValue(String sql, QueryPart... parts) throws DataAccessException, InvalidResultException;
@@ -1440,6 +1436,29 @@ public interface DSLContext {
     @Support
     Result<Record> fetchFromCSV(String string, char delimiter) throws DataAccessException;
 
+    /**
+     * Fetch all data from a JSON string.
+     * <p>
+     * This is the inverse of calling {@link Result#formatJSON()}. Use the
+     * various conversion methods to retrieve other data types from the
+     * <code>Result</code>:
+     * <ul>
+     * <li> {@link Result#getValues(Field, Class)}</li>
+     * <li> {@link Result#getValues(int, Class)}</li>
+     * <li> {@link Result#getValues(String, Class)}</li>
+     * <li> {@link Result#getValues(Field, Converter)}</li>
+     * <li> {@link Result#getValues(int, Converter)}</li>
+     * <li> {@link Result#getValues(String, Converter)}</li>
+     * </ul>
+     * <p>
+     * Missing values result in <code>null</code>. Empty values result in empty
+     * <code>Strings</code>
+     *
+     * @param string The JSON string
+     * @return The transformed result
+     * @throws DataAccessException If anything went wrong parsing the JSON file
+     */
+    @Support
     Result<Record> fetchFromJSON(String string);
 
     /**
@@ -1549,16 +1568,16 @@ public interface DSLContext {
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Field#in(Select)}, {@link Field#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
      * This creates an attached, renderable and executable <code>SELECT</code>
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
-     * create a subselect), consider using the static {@link DSL#select(Field)}
-     * instead.
+     * create a subselect), consider using the static
+     * {@link DSL#select(Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -1574,14 +1593,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
     <T1> SelectSelectStep<Record1<T1>> select(Field<T1> field1);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row2#in(Select)}, {@link Row2#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1605,14 +1627,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
     <T1, T2> SelectSelectStep<Record2<T1, T2>> select(Field<T1> field1, Field<T2> field2);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row3#in(Select)}, {@link Row3#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1636,14 +1661,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
     <T1, T2, T3> SelectSelectStep<Record3<T1, T2, T3>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row4#in(Select)}, {@link Row4#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1667,15 +1695,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4> SelectSelectStep<Record4<T1, T2, T3, T4>> select(Field<T1> field1, Field<T2> field2,
-        Field<T3> field3, Field<T4> field4);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4> SelectSelectStep<Record4<T1, T2, T3, T4>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row5#in(Select)}, {@link Row5#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1699,15 +1729,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5> SelectSelectStep<Record5<T1, T2, T3, T4, T5>> select(Field<T1> field1, Field<T2> field2,
-        Field<T3> field3, Field<T4> field4, Field<T5> field5);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5> SelectSelectStep<Record5<T1, T2, T3, T4, T5>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row6#in(Select)}, {@link Row6#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1731,15 +1763,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6> SelectSelectStep<Record6<T1, T2, T3, T4, T5, T6>> select(Field<T1> field1,
-        Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6> SelectSelectStep<Record6<T1, T2, T3, T4, T5, T6>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row7#in(Select)}, {@link Row7#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1747,8 +1781,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -1764,15 +1797,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7> SelectSelectStep<Record7<T1, T2, T3, T4, T5, T6, T7>> select(Field<T1> field1,
-        Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7> SelectSelectStep<Record7<T1, T2, T3, T4, T5, T6, T7>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row8#in(Select)}, {@link Row8#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1780,8 +1815,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -1797,16 +1831,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8> SelectSelectStep<Record8<T1, T2, T3, T4, T5, T6, T7, T8>> select(Field<T1> field1,
-        Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7,
-        Field<T8> field8);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8> SelectSelectStep<Record8<T1, T2, T3, T4, T5, T6, T7, T8>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row9#in(Select)}, {@link Row9#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1814,8 +1849,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -1831,16 +1865,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9> SelectSelectStep<Record9<T1, T2, T3, T4, T5, T6, T7, T8, T9>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9> SelectSelectStep<Record9<T1, T2, T3, T4, T5, T6, T7, T8, T9>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row10#in(Select)}, {@link Row10#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1848,8 +1883,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -1865,16 +1899,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> SelectSelectStep<Record10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> SelectSelectStep<Record10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row11#in(Select)}, {@link Row11#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1882,8 +1917,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -1899,16 +1933,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> SelectSelectStep<Record11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> SelectSelectStep<Record11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row12#in(Select)}, {@link Row12#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1916,8 +1951,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -1933,16 +1967,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> SelectSelectStep<Record12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> SelectSelectStep<Record12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row13#in(Select)}, {@link Row13#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1950,8 +1985,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -1967,17 +2001,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> SelectSelectStep<Record13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> SelectSelectStep<Record13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row14#in(Select)}, {@link Row14#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -1985,8 +2019,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2002,17 +2035,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> SelectSelectStep<Record14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> SelectSelectStep<Record14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row15#in(Select)}, {@link Row15#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -2020,8 +2053,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2037,17 +2069,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> SelectSelectStep<Record15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> SelectSelectStep<Record15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row16#in(Select)}, {@link Row16#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -2055,8 +2087,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2072,17 +2103,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> SelectSelectStep<Record16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> SelectSelectStep<Record16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row17#in(Select)}, {@link Row17#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -2090,8 +2121,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2107,18 +2137,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> SelectSelectStep<Record17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> SelectSelectStep<Record17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row18#in(Select)}, {@link Row18#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -2126,8 +2155,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2143,18 +2171,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> SelectSelectStep<Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> SelectSelectStep<Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row19#in(Select)}, {@link Row19#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -2162,8 +2189,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2179,18 +2205,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> SelectSelectStep<Record19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> SelectSelectStep<Record19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row20#in(Select)}, {@link Row20#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -2198,8 +2223,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2215,18 +2239,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> SelectSelectStep<Record20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> SelectSelectStep<Record20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row21#in(Select)}, {@link Row21#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -2234,8 +2257,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2251,18 +2273,17 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> SelectSelectStep<Record21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> SelectSelectStep<Record21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21);
 
     /**
      * Create a new DSL select statement.
      * <p>
-     * This is the same as {@link #select(Field...)}, except that it declares
-     * additional record-level typesafety, which is needed by
+     * This is the same as {@link #select(Field...)}, except that it
+     * declares additional record-level typesafety, which is needed by
      * {@link Row22#in(Select)}, {@link Row22#equal(Select)} and other predicate
      * building methods taking subselect arguments.
      * <p>
@@ -2270,8 +2291,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#select(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2287,15 +2307,13 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> SelectSelectStep<Record22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>> select(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21,
-        Field<T22> field22);
+    @Transition(
+        name = "SELECT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> SelectSelectStep<Record22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>> select(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22);
 
-    // [jooq-tools] END [select]
+// [jooq-tools] END [select]
 
     /**
      * Create a new DSL select statement.
@@ -2375,7 +2393,10 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
     <T1> SelectSelectStep<Record1<T1>> selectDistinct(Field<T1> field1);
 
     /**
@@ -2406,7 +2427,10 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
     <T1, T2> SelectSelectStep<Record2<T1, T2>> selectDistinct(Field<T1> field1, Field<T2> field2);
 
     /**
@@ -2437,9 +2461,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3> SelectSelectStep<Record3<T1, T2, T3>> selectDistinct(Field<T1> field1, Field<T2> field2,
-        Field<T3> field3);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3> SelectSelectStep<Record3<T1, T2, T3>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3);
 
     /**
      * Create a new DSL select statement.
@@ -2469,9 +2495,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4> SelectSelectStep<Record4<T1, T2, T3, T4>> selectDistinct(Field<T1> field1, Field<T2> field2,
-        Field<T3> field3, Field<T4> field4);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4> SelectSelectStep<Record4<T1, T2, T3, T4>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4);
 
     /**
      * Create a new DSL select statement.
@@ -2501,9 +2529,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5> SelectSelectStep<Record5<T1, T2, T3, T4, T5>> selectDistinct(Field<T1> field1,
-        Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5> SelectSelectStep<Record5<T1, T2, T3, T4, T5>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5);
 
     /**
      * Create a new DSL select statement.
@@ -2517,8 +2547,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2534,9 +2563,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6> SelectSelectStep<Record6<T1, T2, T3, T4, T5, T6>> selectDistinct(Field<T1> field1,
-        Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6> SelectSelectStep<Record6<T1, T2, T3, T4, T5, T6>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6);
 
     /**
      * Create a new DSL select statement.
@@ -2550,8 +2581,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2567,9 +2597,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7> SelectSelectStep<Record7<T1, T2, T3, T4, T5, T6, T7>> selectDistinct(Field<T1> field1,
-        Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7> SelectSelectStep<Record7<T1, T2, T3, T4, T5, T6, T7>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7);
 
     /**
      * Create a new DSL select statement.
@@ -2583,8 +2615,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2600,10 +2631,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8> SelectSelectStep<Record8<T1, T2, T3, T4, T5, T6, T7, T8>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8> SelectSelectStep<Record8<T1, T2, T3, T4, T5, T6, T7, T8>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8);
 
     /**
      * Create a new DSL select statement.
@@ -2617,8 +2649,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2634,10 +2665,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9> SelectSelectStep<Record9<T1, T2, T3, T4, T5, T6, T7, T8, T9>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9> SelectSelectStep<Record9<T1, T2, T3, T4, T5, T6, T7, T8, T9>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9);
 
     /**
      * Create a new DSL select statement.
@@ -2651,8 +2683,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2668,10 +2699,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> SelectSelectStep<Record10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> SelectSelectStep<Record10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10);
 
     /**
      * Create a new DSL select statement.
@@ -2685,8 +2717,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2702,10 +2733,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> SelectSelectStep<Record11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> SelectSelectStep<Record11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11);
 
     /**
      * Create a new DSL select statement.
@@ -2719,8 +2751,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2736,10 +2767,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> SelectSelectStep<Record12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> SelectSelectStep<Record12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12);
 
     /**
      * Create a new DSL select statement.
@@ -2753,8 +2785,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2770,11 +2801,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> SelectSelectStep<Record13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> SelectSelectStep<Record13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13);
 
     /**
      * Create a new DSL select statement.
@@ -2788,8 +2819,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2805,11 +2835,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> SelectSelectStep<Record14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> SelectSelectStep<Record14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14);
 
     /**
      * Create a new DSL select statement.
@@ -2823,8 +2853,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2840,11 +2869,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> SelectSelectStep<Record15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> SelectSelectStep<Record15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15);
 
     /**
      * Create a new DSL select statement.
@@ -2858,8 +2887,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2875,11 +2903,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> SelectSelectStep<Record16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> SelectSelectStep<Record16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16);
 
     /**
      * Create a new DSL select statement.
@@ -2893,8 +2921,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2910,12 +2937,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> SelectSelectStep<Record17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> SelectSelectStep<Record17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17);
 
     /**
      * Create a new DSL select statement.
@@ -2929,8 +2955,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2946,12 +2971,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> SelectSelectStep<Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> SelectSelectStep<Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18);
 
     /**
      * Create a new DSL select statement.
@@ -2965,8 +2989,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -2982,12 +3005,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> SelectSelectStep<Record19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> SelectSelectStep<Record19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19);
 
     /**
      * Create a new DSL select statement.
@@ -3001,8 +3023,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -3018,12 +3039,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> SelectSelectStep<Record20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> SelectSelectStep<Record20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20);
 
     /**
      * Create a new DSL select statement.
@@ -3037,8 +3057,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -3054,12 +3073,11 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> SelectSelectStep<Record21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> SelectSelectStep<Record21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21);
 
     /**
      * Create a new DSL select statement.
@@ -3073,8 +3091,7 @@ public interface DSLContext {
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
      * create a subselect), consider using the static
-     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)}
-     * instead.
+     * {@link DSL#selectDistinct(Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field)} instead.
      * <p>
      * Example: <code><pre>
      * using(configuration)
@@ -3090,15 +3107,13 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    @Transition(name = "SELECT DISTINCT", args = "Field+")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> SelectSelectStep<Record22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>> selectDistinct(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21,
-        Field<T22> field22);
+    @Transition(
+        name = "SELECT DISTINCT",
+        args = "Field+"
+    )
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> SelectSelectStep<Record22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>> selectDistinct(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22);
 
-    // [jooq-tools] END [selectDistinct]
+// [jooq-tools] END [selectDistinct]
 
     /**
      * Create a new DSL select statement for a constant <code>0</code> literal.
@@ -3106,8 +3121,8 @@ public interface DSLContext {
      * This creates an attached, renderable and executable <code>SELECT</code>
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
-     * create a subselect), consider using the static {@link DSL#selectZero()}
-     * instead.
+     * create a subselect), consider using the static
+     * {@link DSL#selectZero()} instead.
      * <p>
      * Example: <code><pre>
      * DSLContext create = DSL.using(configuration);
@@ -3123,7 +3138,9 @@ public interface DSLContext {
      * @see DSL#selectZero()
      */
     @Support
-    @Transition(name = "SELECT ZERO")
+    @Transition(
+        name = "SELECT ZERO"
+    )
     SelectSelectStep<Record1<Integer>> selectZero();
 
     /**
@@ -3132,8 +3149,8 @@ public interface DSLContext {
      * This creates an attached, renderable and executable <code>SELECT</code>
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
-     * create a subselect), consider using the static {@link DSL#selectOne()}
-     * instead.
+     * create a subselect), consider using the static
+     * {@link DSL#selectOne()} instead.
      * <p>
      * Example: <code><pre>
      * DSLContext create = DSL.using(configuration);
@@ -3149,7 +3166,9 @@ public interface DSLContext {
      * @see DSL#selectOne()
      */
     @Support
-    @Transition(name = "SELECT ONE")
+    @Transition(
+        name = "SELECT ONE"
+    )
     SelectSelectStep<Record1<Integer>> selectOne();
 
     /**
@@ -3158,8 +3177,8 @@ public interface DSLContext {
      * This creates an attached, renderable and executable <code>SELECT</code>
      * statement from this {@link DSLContext}. If you don't need to render or
      * execute this <code>SELECT</code> statement (e.g. because you want to
-     * create a subselect), consider using the static {@link DSL#selectCount()}
-     * instead.
+     * create a subselect), consider using the static
+     * {@link DSL#selectCount()} instead.
      * <p>
      * Example: <code><pre>
      * DSLContext create = DSL.using(configuration);
@@ -3174,7 +3193,9 @@ public interface DSLContext {
      * @see DSL#selectCount()
      */
     @Support
-    @Transition(name = "SELECT COUNT")
+    @Transition(
+        name = "SELECT COUNT"
+    )
     SelectSelectStep<Record1<Integer>> selectCount();
 
     /**
@@ -3279,8 +3300,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3> InsertValuesStep3<R, T1, T2, T3> insertInto(Table<R> into, Field<T1> field1,
-        Field<T2> field2, Field<T3> field3);
+    <R extends Record, T1, T2, T3> InsertValuesStep3<R, T1, T2, T3> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3);
 
     /**
      * Create a new DSL insert statement.
@@ -3298,8 +3318,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4> InsertValuesStep4<R, T1, T2, T3, T4> insertInto(Table<R> into, Field<T1> field1,
-        Field<T2> field2, Field<T3> field3, Field<T4> field4);
+    <R extends Record, T1, T2, T3, T4> InsertValuesStep4<R, T1, T2, T3, T4> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4);
 
     /**
      * Create a new DSL insert statement.
@@ -3317,8 +3336,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5> InsertValuesStep5<R, T1, T2, T3, T4, T5> insertInto(Table<R> into,
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5);
+    <R extends Record, T1, T2, T3, T4, T5> InsertValuesStep5<R, T1, T2, T3, T4, T5> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5);
 
     /**
      * Create a new DSL insert statement.
@@ -3336,8 +3354,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6> InsertValuesStep6<R, T1, T2, T3, T4, T5, T6> insertInto(Table<R> into,
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6);
+    <R extends Record, T1, T2, T3, T4, T5, T6> InsertValuesStep6<R, T1, T2, T3, T4, T5, T6> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6);
 
     /**
      * Create a new DSL insert statement.
@@ -3355,9 +3372,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7> InsertValuesStep7<R, T1, T2, T3, T4, T5, T6, T7> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7> InsertValuesStep7<R, T1, T2, T3, T4, T5, T6, T7> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7);
 
     /**
      * Create a new DSL insert statement.
@@ -3375,9 +3390,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8> InsertValuesStep8<R, T1, T2, T3, T4, T5, T6, T7, T8> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8> InsertValuesStep8<R, T1, T2, T3, T4, T5, T6, T7, T8> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8);
 
     /**
      * Create a new DSL insert statement.
@@ -3395,9 +3408,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9> InsertValuesStep9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9> InsertValuesStep9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9);
 
     /**
      * Create a new DSL insert statement.
@@ -3415,9 +3426,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> InsertValuesStep10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> InsertValuesStep10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10);
 
     /**
      * Create a new DSL insert statement.
@@ -3435,9 +3444,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> InsertValuesStep11<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> InsertValuesStep11<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11);
 
     /**
      * Create a new DSL insert statement.
@@ -3455,10 +3462,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> InsertValuesStep12<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> InsertValuesStep12<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12);
 
     /**
      * Create a new DSL insert statement.
@@ -3476,10 +3480,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> InsertValuesStep13<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> InsertValuesStep13<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13);
 
     /**
      * Create a new DSL insert statement.
@@ -3497,10 +3498,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> InsertValuesStep14<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> InsertValuesStep14<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14);
 
     /**
      * Create a new DSL insert statement.
@@ -3518,10 +3516,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> InsertValuesStep15<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> InsertValuesStep15<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15);
 
     /**
      * Create a new DSL insert statement.
@@ -3539,10 +3534,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> InsertValuesStep16<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> InsertValuesStep16<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16);
 
     /**
      * Create a new DSL insert statement.
@@ -3560,11 +3552,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> InsertValuesStep17<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> InsertValuesStep17<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17);
 
     /**
      * Create a new DSL insert statement.
@@ -3582,11 +3570,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> InsertValuesStep18<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> InsertValuesStep18<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18);
 
     /**
      * Create a new DSL insert statement.
@@ -3604,11 +3588,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> InsertValuesStep19<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> InsertValuesStep19<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19);
 
     /**
      * Create a new DSL insert statement.
@@ -3626,11 +3606,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> InsertValuesStep20<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> InsertValuesStep20<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20);
 
     /**
      * Create a new DSL insert statement.
@@ -3648,11 +3624,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> InsertValuesStep21<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> InsertValuesStep21<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21);
 
     /**
      * Create a new DSL insert statement.
@@ -3670,14 +3642,9 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> InsertValuesStep22<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> insertInto(
-        Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21,
-        Field<T22> field22);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> InsertValuesStep22<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22);
 
-    // [jooq-tools] END [insert]
+// [jooq-tools] END [insert]
 
     /**
      * Create a new DSL insert statement.
@@ -3748,7 +3715,10 @@ public interface DSLContext {
      * </pre></code>
      */
     @Support
-    @Transition(name = "UPDATE", args = "Table")
+    @Transition(
+        name = "UPDATE",
+        args = "Table"
+    )
     <R extends Record> UpdateSetFirstStep<R> update(Table<R> table);
 
     /**
@@ -3826,7 +3796,10 @@ public interface DSLContext {
      * {@link #mergeInto(Table, Field...)}
      */
     @Support({ CUBRID, HSQLDB })
-    @Transition(name = "MERGE INTO", args = "Table")
+    @Transition(
+        name = "MERGE INTO",
+        args = "Table"
+    )
     <R extends Record> MergeUsingStep<R> mergeInto(Table<R> table);
 
     // [jooq-tools] START [merge]
@@ -3901,8 +3874,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3> MergeKeyStep3<R, T1, T2, T3> mergeInto(Table<R> table, Field<T1> field1,
-        Field<T2> field2, Field<T3> field3);
+    <R extends Record, T1, T2, T3> MergeKeyStep3<R, T1, T2, T3> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -3926,8 +3898,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4> MergeKeyStep4<R, T1, T2, T3, T4> mergeInto(Table<R> table, Field<T1> field1,
-        Field<T2> field2, Field<T3> field3, Field<T4> field4);
+    <R extends Record, T1, T2, T3, T4> MergeKeyStep4<R, T1, T2, T3, T4> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -3951,8 +3922,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5> MergeKeyStep5<R, T1, T2, T3, T4, T5> mergeInto(Table<R> table,
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5);
+    <R extends Record, T1, T2, T3, T4, T5> MergeKeyStep5<R, T1, T2, T3, T4, T5> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -3976,8 +3946,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6> MergeKeyStep6<R, T1, T2, T3, T4, T5, T6> mergeInto(Table<R> table,
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6);
+    <R extends Record, T1, T2, T3, T4, T5, T6> MergeKeyStep6<R, T1, T2, T3, T4, T5, T6> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4001,9 +3970,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7> MergeKeyStep7<R, T1, T2, T3, T4, T5, T6, T7> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7> MergeKeyStep7<R, T1, T2, T3, T4, T5, T6, T7> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4027,9 +3994,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8> MergeKeyStep8<R, T1, T2, T3, T4, T5, T6, T7, T8> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8> MergeKeyStep8<R, T1, T2, T3, T4, T5, T6, T7, T8> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4053,9 +4018,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9> MergeKeyStep9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9> MergeKeyStep9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4079,9 +4042,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> MergeKeyStep10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> MergeKeyStep10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4105,9 +4066,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> MergeKeyStep11<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> MergeKeyStep11<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4131,10 +4090,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> MergeKeyStep12<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> MergeKeyStep12<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4158,10 +4114,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> MergeKeyStep13<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> MergeKeyStep13<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4185,10 +4138,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> MergeKeyStep14<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> MergeKeyStep14<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4212,10 +4162,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> MergeKeyStep15<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> MergeKeyStep15<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4239,10 +4186,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> MergeKeyStep16<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> MergeKeyStep16<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4266,11 +4210,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> MergeKeyStep17<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> MergeKeyStep17<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4294,11 +4234,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> MergeKeyStep18<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> MergeKeyStep18<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4322,11 +4258,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> MergeKeyStep19<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> MergeKeyStep19<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4350,11 +4282,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> MergeKeyStep20<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> MergeKeyStep20<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4378,11 +4306,7 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> MergeKeyStep21<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> MergeKeyStep21<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21);
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4406,14 +4330,9 @@ public interface DSLContext {
      */
     @Generated("This method was generated using jOOQ-tools")
     @Support({ CUBRID, H2, HSQLDB })
-    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> MergeKeyStep22<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> mergeInto(
-        Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5,
-        Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21,
-        Field<T22> field22);
+    <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> MergeKeyStep22<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22);
 
-    // [jooq-tools] END [merge]
+// [jooq-tools] END [merge]
 
     /**
      * Create a new DSL merge statement (H2-specific syntax).
@@ -4469,7 +4388,9 @@ public interface DSLContext {
      * Some but not all databases support aliased tables in delete statements.
      */
     @Support
-    @Transition(name = "DELETE")
+    @Transition(
+        name = "DELETE"
+    )
     <R extends Record> DeleteWhereStep<R> delete(Table<R> table);
 
     // -------------------------------------------------------------------------
@@ -4788,7 +4709,10 @@ public interface DSLContext {
      * dialects that do not support them natively.
      */
     @Support
-    @Transition(name = "TRUNCATE", args = "Table")
+    @Transition(
+        name = "TRUNCATE",
+        args = "Table"
+    )
     <R extends Record> TruncateIdentityStep<R> truncate(Table<R> table);
 
     // -------------------------------------------------------------------------
@@ -4950,8 +4874,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4> Record4<T1, T2, T3, T4> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3,
-        Field<T4> field4);
+    <T1, T2, T3, T4> Record4<T1, T2, T3, T4> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4);
 
     /**
      * Create a new empty {@link Record}.
@@ -4963,8 +4886,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5> Record5<T1, T2, T3, T4, T5> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3,
-        Field<T4> field4, Field<T5> field5);
+    <T1, T2, T3, T4, T5> Record5<T1, T2, T3, T4, T5> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5);
 
     /**
      * Create a new empty {@link Record}.
@@ -4976,8 +4898,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6> Record6<T1, T2, T3, T4, T5, T6> newRecord(Field<T1> field1, Field<T2> field2,
-        Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6);
+    <T1, T2, T3, T4, T5, T6> Record6<T1, T2, T3, T4, T5, T6> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6);
 
     /**
      * Create a new empty {@link Record}.
@@ -4989,8 +4910,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7> Record7<T1, T2, T3, T4, T5, T6, T7> newRecord(Field<T1> field1, Field<T2> field2,
-        Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7);
+    <T1, T2, T3, T4, T5, T6, T7> Record7<T1, T2, T3, T4, T5, T6, T7> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7);
 
     /**
      * Create a new empty {@link Record}.
@@ -5002,9 +4922,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8> Record8<T1, T2, T3, T4, T5, T6, T7, T8> newRecord(Field<T1> field1,
-        Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7,
-        Field<T8> field8);
+    <T1, T2, T3, T4, T5, T6, T7, T8> Record8<T1, T2, T3, T4, T5, T6, T7, T8> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8);
 
     /**
      * Create a new empty {@link Record}.
@@ -5016,9 +4934,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9> Record9<T1, T2, T3, T4, T5, T6, T7, T8, T9> newRecord(Field<T1> field1,
-        Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7,
-        Field<T8> field8, Field<T9> field9);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9> Record9<T1, T2, T3, T4, T5, T6, T7, T8, T9> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9);
 
     /**
      * Create a new empty {@link Record}.
@@ -5030,9 +4946,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Record10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Record10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10);
 
     /**
      * Create a new empty {@link Record}.
@@ -5044,9 +4958,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Record11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Record11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11);
 
     /**
      * Create a new empty {@link Record}.
@@ -5058,9 +4970,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Record12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Record12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12);
 
     /**
      * Create a new empty {@link Record}.
@@ -5072,10 +4982,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Record13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Record13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13);
 
     /**
      * Create a new empty {@link Record}.
@@ -5087,10 +4994,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Record14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Record14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14);
 
     /**
      * Create a new empty {@link Record}.
@@ -5102,10 +5006,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Record15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> Record15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15);
 
     /**
      * Create a new empty {@link Record}.
@@ -5117,10 +5018,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Record16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> Record16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16);
 
     /**
      * Create a new empty {@link Record}.
@@ -5132,11 +5030,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Record17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> Record17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17);
 
     /**
      * Create a new empty {@link Record}.
@@ -5148,11 +5042,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> Record18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18);
 
     /**
      * Create a new empty {@link Record}.
@@ -5164,11 +5054,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Record19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> Record19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19);
 
     /**
      * Create a new empty {@link Record}.
@@ -5180,11 +5066,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Record20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> Record20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20);
 
     /**
      * Create a new empty {@link Record}.
@@ -5196,11 +5078,7 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Record21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> Record21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21);
 
     /**
      * Create a new empty {@link Record}.
@@ -5212,14 +5090,9 @@ public interface DSLContext {
      * @return The new record
      */
     @Generated("This method was generated using jOOQ-tools")
-    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Record22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> newRecord(
-        Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6,
-        Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11,
-        Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16,
-        Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21,
-        Field<T22> field22);
+    <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> Record22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> newRecord(Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22);
 
-    // [jooq-tools] END [newRecord]
+// [jooq-tools] END [newRecord]
 
     /**
      * Create a new empty {@link Result}.
@@ -5238,8 +5111,8 @@ public interface DSLContext {
     // -------------------------------------------------------------------------
 
     /**
-     * Execute a {@link ResultQuery} in the context of this
-     * <code>DSLContext</code> and return results.
+     * Execute a {@link ResultQuery} in the context of this <code>DSLContext</code> and return
+     * results.
      *
      * @param query The query to execute
      * @return The result
@@ -5249,8 +5122,8 @@ public interface DSLContext {
     <R extends Record> Result<R> fetch(ResultQuery<R> query) throws DataAccessException;
 
     /**
-     * Execute a {@link ResultQuery} in the context of this
-     * <code>DSLContext</code> and return a cursor.
+     * Execute a {@link ResultQuery} in the context of this <code>DSLContext</code> and return
+     * a cursor.
      *
      * @param query The query to execute
      * @return The cursor
@@ -5260,8 +5133,8 @@ public interface DSLContext {
     <R extends Record> Cursor<R> fetchLazy(ResultQuery<R> query) throws DataAccessException;
 
     /**
-     * Execute a {@link ResultQuery} in the context of this
-     * <code>DSLContext</code> and return a cursor.
+     * Execute a {@link ResultQuery} in the context of this <code>DSLContext</code> and return
+     * a cursor.
      *
      * @param query The query to execute
      * @return The results
@@ -5271,8 +5144,8 @@ public interface DSLContext {
     <R extends Record> List<Result<Record>> fetchMany(ResultQuery<R> query) throws DataAccessException;
 
     /**
-     * Execute a {@link ResultQuery} in the context of this
-     * <code>DSLContext</code> and return a record.
+     * Execute a {@link ResultQuery} in the context of this <code>DSLContext</code> and return
+     * a record.
      *
      * @param query The query to execute
      * @return The record
@@ -5295,8 +5168,8 @@ public interface DSLContext {
     <T, R extends Record1<T>> T fetchValue(ResultQuery<R> query) throws DataAccessException, InvalidResultException;
 
     /**
-     * Execute a {@link Select} query in the context of this
-     * <code>DSLContext</code> and return a <code>COUNT(*)</code> value.
+     * Execute a {@link Select} query in the context of this <code>DSLContext</code> and return
+     * a <code>COUNT(*)</code> value.
      * <p>
      * This wraps a pre-existing <code>SELECT</code> query in another one to
      * calculate the <code>COUNT(*)</code> value, without modifying the original
diff --git a/jOOQ/src/main/java/org/jooq/impl/DefaultDSLContext.java b/jOOQ/src/main/java/org/jooq/impl/DefaultDSLContext.java
index ca1f393b1c..bbfbfd53d2 100644
--- a/jOOQ/src/main/java/org/jooq/impl/DefaultDSLContext.java
+++ b/jOOQ/src/main/java/org/jooq/impl/DefaultDSLContext.java
@@ -38,11 +38,17 @@
  * This library is distributed with a LIMITED WARRANTY. See the jOOQ License
  * and Maintenance Agreement for more details: http://www.jooq.org/licensing
  */
-
 package org.jooq.impl;
 
-import javax.annotation.Generated;
-import javax.sql.DataSource;
+import static org.jooq.conf.ParamType.INLINED;
+import static org.jooq.conf.ParamType.NAMED;
+import static org.jooq.impl.DSL.field;
+import static org.jooq.impl.DSL.fieldByName;
+import static org.jooq.impl.DSL.queryPart;
+import static org.jooq.impl.DSL.template;
+import static org.jooq.impl.DSL.trueCondition;
+import static org.jooq.impl.Utils.list;
+
 import java.io.IOException;
 import java.io.Serializable;
 import java.io.StringReader;
@@ -60,6 +66,9 @@ import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 
+import javax.annotation.Generated;
+import javax.sql.DataSource;
+
 import org.jooq.Attachable;
 import org.jooq.Batch;
 import org.jooq.BatchBindStep;
@@ -177,16 +186,6 @@ import org.jooq.exception.InvalidResultException;
 import org.jooq.exception.SQLDialectNotSupportedException;
 import org.jooq.impl.BatchCRUD.Action;
 import org.jooq.tools.csv.CSVReader;
-import org.jooq.tools.json.JSONReader;
-
-import static org.jooq.conf.ParamType.INLINED;
-import static org.jooq.conf.ParamType.NAMED;
-import static org.jooq.impl.DSL.field;
-import static org.jooq.impl.DSL.fieldByName;
-import static org.jooq.impl.DSL.queryPart;
-import static org.jooq.impl.DSL.template;
-import static org.jooq.impl.DSL.trueCondition;
-import static org.jooq.impl.Utils.list;
 
 /**
  * A default implementation for {@link DSLContext}.
@@ -675,22 +674,22 @@ public class DefaultDSLContext implements DSLContext, Serializable {
             String[] fields = reader.getFields();
             data.add(fields);
             data.addAll(records);
-        } catch (IOException e) {
+        }
+        catch (IOException e) {
             throw new DataAccessException("Could not read the JSON string", e);
-        } finally {
-            try  {
+        }
+        finally {
+            try {
                 if (reader != null) {
                     reader.close();
                 }
-            } catch (IOException ignore) {
             }
+            catch (IOException ignore) {}
         }
 
         return fetchFromStringData(data);
     }
 
-
-
     @Override
     public Result<Record> fetchFromStringData(String[]... data) {
         return fetchFromStringData(list(data));
@@ -751,7 +750,7 @@ public class DefaultDSLContext implements DSLContext, Serializable {
         return result;
     }
 
-    // [jooq-tools] START [select]
+// [jooq-tools] START [select]
 
     @Generated("This method was generated using jOOQ-tools")
     @Override
@@ -885,7 +884,7 @@ public class DefaultDSLContext implements DSLContext, Serializable {
         return (SelectSelectStep) select(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 });
     }
 
-    // [jooq-tools] END [select]
+// [jooq-tools] END [select]
 
     @Override
     public SelectSelectStep<Record> selectDistinct(Collection<? extends Field<?>> fields) {
@@ -901,7 +900,7 @@ public class DefaultDSLContext implements DSLContext, Serializable {
         return result;
     }
 
-    // [jooq-tools] START [selectDistinct]
+// [jooq-tools] START [selectDistinct]
 
     @Generated("This method was generated using jOOQ-tools")
     @Override
@@ -1035,7 +1034,7 @@ public class DefaultDSLContext implements DSLContext, Serializable {
         return (SelectSelectStep) selectDistinct(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 });
     }
 
-    // [jooq-tools] END [selectDistinct]
+// [jooq-tools] END [selectDistinct]
 
     @Override
     public SelectSelectStep<Record1<Integer>> selectZero() {
@@ -1078,7 +1077,7 @@ public class DefaultDSLContext implements DSLContext, Serializable {
         return new InsertImpl(configuration, into, Collections.<Field<?>>emptyList());
     }
 
-    // [jooq-tools] START [insert]
+// [jooq-tools] START [insert]
 
     @Generated("This method was generated using jOOQ-tools")
     @Override
@@ -1212,7 +1211,7 @@ public class DefaultDSLContext implements DSLContext, Serializable {
         return new InsertImpl(configuration, into, Arrays.asList(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 }));
     }
 
-    // [jooq-tools] END [insert]
+// [jooq-tools] END [insert]
 
     @Override
     public <R extends Record> InsertValuesStepN<R> insertInto(Table<R> into, Field<?>... fields) {
@@ -1239,7 +1238,7 @@ public class DefaultDSLContext implements DSLContext, Serializable {
         return new MergeImpl(configuration, table);
     }
 
-    // [jooq-tools] START [merge]
+// [jooq-tools] START [merge]
 
     @Generated("This method was generated using jOOQ-tools")
     @Override
@@ -1373,7 +1372,7 @@ public class DefaultDSLContext implements DSLContext, Serializable {
         return new MergeImpl(configuration, table, Arrays.asList(field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22));
     }
 
-    // [jooq-tools] END [merge]
+// [jooq-tools] END [merge]
 
     @Override
     public <R extends Record> MergeKeyStepN<R> mergeInto(Table<R> table, Field<?>... fields) {
@@ -1694,7 +1693,7 @@ public class DefaultDSLContext implements DSLContext, Serializable {
         return (Record22) newRecord(new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22 });
     }
 
-    // [jooq-tools] END [newRecord]
+// [jooq-tools] END [newRecord]
 
     @Override
     public <R extends UDTRecord<R>> R newRecord(UDT<R> type) {
@@ -1709,14 +1708,14 @@ public class DefaultDSLContext implements DSLContext, Serializable {
     @Override
     public <R extends Record> R newRecord(Table<R> table, final Object source) {
         return Utils.newRecord(table, configuration)
-            .operate(new RecordOperation<R, RuntimeException>() {
+                    .operate(new RecordOperation<R, RuntimeException>() {
 
-                @Override
-                public R operate(R record) {
-                    record.from(source);
-                    return record;
-                }
-            });
+            @Override
+            public R operate(R record) {
+                record.from(source);
+                return record;
+            }
+        });
     }
 
     @Override
@@ -1794,13 +1793,11 @@ public class DefaultDSLContext implements DSLContext, Serializable {
     }
 
     private final <T, R extends Record1<T>> T value1(R record) {
-        if (record == null) {
+        if (record == null)
             return null;
-        }
 
-        if (record.size() != 1) {
+        if (record.size() != 1)
             throw new InvalidResultException("Record contains more than one value : " + record);
-        }
 
         return record.value1();
     }
diff --git a/jOOQ/src/main/java/org/jooq/tools/json/JSONReader.java b/jOOQ/src/main/java/org/jooq/impl/JSONReader.java
similarity index 50%
rename from jOOQ/src/main/java/org/jooq/tools/json/JSONReader.java
rename to jOOQ/src/main/java/org/jooq/impl/JSONReader.java
index f97072a8fe..3004a2ccae 100644
--- a/jOOQ/src/main/java/org/jooq/tools/json/JSONReader.java
+++ b/jOOQ/src/main/java/org/jooq/impl/JSONReader.java
@@ -1,29 +1,72 @@
-package org.jooq.tools.json;
+/**
+ * Copyright (c) 2009-2013, Data Geekery GmbH (http://www.datageekery.com)
+ * All rights reserved.
+ *
+ * This work is dual-licensed
+ * - under the Apache Software License 2.0 (the "ASL")
+ * - under the jOOQ License and Maintenance Agreement (the "jOOQ License")
+ * =============================================================================
+ * You may choose which license applies to you:
+ *
+ * - If you're using this work with Open Source databases, you may choose
+ *   either ASL or jOOQ License.
+ * - If you're using this work with at least one commercial database, you must
+ *   choose jOOQ License
+ *
+ * For more information, please visit http://www.jooq.org/licenses
+ *
+ * Apache Software License 2.0:
+ * -----------------------------------------------------------------------------
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * jOOQ License and Maintenance Agreement:
+ * -----------------------------------------------------------------------------
+ * Data Geekery grants the Customer the non-exclusive, timely limited and
+ * non-transferable license to install and use the Software under the terms of
+ * the jOOQ License and Maintenance Agreement.
+ *
+ * This library is distributed with a LIMITED WARRANTY. See the jOOQ License
+ * and Maintenance Agreement for more details: http://www.jooq.org/licensing
+ */
+package org.jooq.impl;
 
 import java.io.BufferedReader;
 import java.io.Closeable;
 import java.io.IOException;
 import java.io.Reader;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+
+import org.jooq.tools.json.ContainerFactory;
+import org.jooq.tools.json.JSONParser;
+import org.jooq.tools.json.ParseException;
 
 /**
  * A very simple JSON reader based on Simple JSON.
  *
  * @author Johannes Bühler
- *
- * @since 3.3.0
  */
-@SuppressWarnings({"rawtypes", "unchecked"})
-public class JSONReader implements Closeable {
-
+@SuppressWarnings({ "rawtypes", "unchecked" })
+class JSONReader implements Closeable {
 
     private final BufferedReader br;
-    private final JSONParser parser;
-    private String[] fieldMetaData;
-    private List<String[]> records;
+    private final JSONParser     parser;
+    private String[]             fieldMetaData;
+    private List<String[]>       records;
 
-
-    public JSONReader(Reader reader) throws IOException {
+    public JSONReader(Reader reader) {
         this.br = new BufferedReader(reader);
         this.parser = new JSONParser();
     }
@@ -36,7 +79,8 @@ public class JSONReader implements Closeable {
             LinkedHashMap jsonRoot = getJsonRoot();
             readFields(jsonRoot);
             records = readRecords(jsonRoot);
-        } catch (ParseException ex) {
+        }
+        catch (ParseException ex) {
             throw new RuntimeException(ex);
         }
         return records;
@@ -52,7 +96,6 @@ public class JSONReader implements Closeable {
     @Override
     public void close() throws IOException {
         br.close();
-
     }
 
     private List<String[]> readRecords(LinkedHashMap jsonRoot) {
@@ -98,7 +141,5 @@ public class JSONReader implements Closeable {
             i++;
         }
     }
-
-
-
 }
+
diff --git a/jOOQ/src/main/java/org/jooq/impl/LoaderImpl.java b/jOOQ/src/main/java/org/jooq/impl/LoaderImpl.java
index 83a86633a9..252e273866 100644
--- a/jOOQ/src/main/java/org/jooq/impl/LoaderImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/LoaderImpl.java
@@ -1,37 +1,42 @@
 /**
- * Copyright (c) 2009-2013, Lukas Eder, lukas.eder@gmail.com
+ * Copyright (c) 2009-2013, Data Geekery GmbH (http://www.datageekery.com)
  * All rights reserved.
  *
- * This software is licensed to you under the Apache License, Version 2.0
- * (the "License"); You may obtain a copy of the License at
+ * This work is dual-licensed
+ * - under the Apache Software License 2.0 (the "ASL")
+ * - under the jOOQ License and Maintenance Agreement (the "jOOQ License")
+ * =============================================================================
+ * You may choose which license applies to you:
  *
- *   http://www.apache.org/licenses/LICENSE-2.0
+ * - If you're using this work with Open Source databases, you may choose
+ *   either ASL or jOOQ License.
+ * - If you're using this work with at least one commercial database, you must
+ *   choose jOOQ License
  *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
+ * For more information, please visit http://www.jooq.org/licenses
  *
- * . Redistributions of source code must retain the above copyright notice, this
- *   list of conditions and the following disclaimer.
+ * Apache Software License 2.0:
+ * -----------------------------------------------------------------------------
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
  *
- * . Redistributions in binary form must reproduce the above copyright notice,
- *   this list of conditions and the following disclaimer in the documentation
- *   and/or other materials provided with the distribution.
+ *  http://www.apache.org/licenses/LICENSE-2.0
  *
- * . Neither the name "jOOQ" nor the names of its contributors may be
- *   used to endorse or promote products derived from this software without
- *   specific prior written permission.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
+ * jOOQ License and Maintenance Agreement:
+ * -----------------------------------------------------------------------------
+ * Data Geekery grants the Customer the non-exclusive, timely limited and
+ * non-transferable license to install and use the Software under the terms of
+ * the jOOQ License and Maintenance Agreement.
+ *
+ * This library is distributed with a LIMITED WARRANTY. See the jOOQ License
+ * and Maintenance Agreement for more details: http://www.jooq.org/licensing
  */
 package org.jooq.impl;
 
@@ -70,7 +75,6 @@ import org.jooq.exception.DataAccessException;
 import org.jooq.tools.StringUtils;
 import org.jooq.tools.csv.CSVParser;
 import org.jooq.tools.csv.CSVReader;
-import org.jooq.tools.json.JSONReader;
 
 import org.xml.sax.InputSource;
 
@@ -81,8 +85,13 @@ import org.xml.sax.InputSource;
 class LoaderImpl<R extends TableRecord<R>> implements
 
     // Cascading interface implementations for Loader behaviour
-    LoaderOptionsStep<R>, LoaderXMLStep<R>, LoaderCSVStep<R>, LoaderCSVOptionsStep<R>, LoaderJSONStep<R>,
-    LoaderJSONOptionsStep<R>, Loader<R> {
+    LoaderOptionsStep<R>,
+    LoaderXMLStep<R>,
+    LoaderCSVStep<R>,
+    LoaderCSVOptionsStep<R>,
+    LoaderJSONStep<R>,
+    LoaderJSONOptionsStep<R>,
+    Loader<R> {
 
     // Configuration constants
     // -----------------------
@@ -149,9 +158,7 @@ class LoaderImpl<R extends TableRecord<R>> implements
     @Override
     public final LoaderImpl<R> onDuplicateKeyIgnore() {
         if (table.getPrimaryKey() == null) {
-            throw new IllegalStateException(
-                "ON DUPLICATE KEY IGNORE only works on tables with explicit primary keys. Table is not updatable : "
-                    + table);
+            throw new IllegalStateException("ON DUPLICATE KEY IGNORE only works on tables with explicit primary keys. Table is not updatable : " + table);
         }
 
         onDuplicate = ON_DUPLICATE_KEY_IGNORE;
@@ -161,9 +168,7 @@ class LoaderImpl<R extends TableRecord<R>> implements
     @Override
     public final LoaderImpl<R> onDuplicateKeyUpdate() {
         if (table.getPrimaryKey() == null) {
-            throw new IllegalStateException(
-                "ON DUPLICATE KEY UPDATE only works on tables with explicit primary keys. Table is not updatable : "
-                    + table);
+            throw new IllegalStateException("ON DUPLICATE KEY UPDATE only works on tables with explicit primary keys. Table is not updatable : " + table);
         }
 
         onDuplicate = ON_DUPLICATE_KEY_UPDATE;
@@ -377,6 +382,7 @@ class LoaderImpl<R extends TableRecord<R>> implements
         JSONReader reader = new JSONReader(data);
 
         try {
+
             // The current json format is not designed for streaming. Thats why
             // all records are loaded at once.
             List<String[]> allRecords = reader.readAll();
diff --git a/jOOQ/src/main/java/org/jooq/tools/csv/CSVReader.java b/jOOQ/src/main/java/org/jooq/tools/csv/CSVReader.java
index cf7b90a73a..967cd564f5 100644
--- a/jOOQ/src/main/java/org/jooq/tools/csv/CSVReader.java
+++ b/jOOQ/src/main/java/org/jooq/tools/csv/CSVReader.java
@@ -237,6 +237,10 @@ public class CSVReader implements Closeable, Iterator<String[]> {
         br.close();
     }
 
+    // ------------------------------------------------------------------------
+    // XXX: Iterator implementation added by Johannes Buehler
+    // ------------------------------------------------------------------------
+
     @Override
     public boolean hasNext() {
         return hasNext;
@@ -246,7 +250,8 @@ public class CSVReader implements Closeable, Iterator<String[]> {
     public String[] next() {
         try {
             return readNext();
-        } catch (IOException e) {
+        }
+        catch (IOException e) {
             throw new RuntimeException(e);
         }
     }
diff --git a/jOOQ/src/main/java/org/jooq/tools/json/JSONParser.java b/jOOQ/src/main/java/org/jooq/tools/json/JSONParser.java
index 4a597f443d..69319eaf23 100644
--- a/jOOQ/src/main/java/org/jooq/tools/json/JSONParser.java
+++ b/jOOQ/src/main/java/org/jooq/tools/json/JSONParser.java
@@ -524,4 +524,4 @@ public class JSONParser {
         status = S_IN_ERROR;
         throw new ParseException(getPosition(), ParseException.ERROR_UNEXPECTED_TOKEN, token);
     }
-}
+}
\ No newline at end of file