From 3614db1d4894102aaab9cd59df726fc87d8a96a6 Mon Sep 17 00:00:00 2001 From: Lukas Eder Date: Fri, 27 Feb 2015 13:56:19 +0100 Subject: [PATCH] [#4100] Use "<" for "<" and ">" for ">" in javadoc --- jOOQ/src/main/java/org/jooq/Field.java | 64 +++++++++---------- .../org/jooq/InsertOnDuplicateSetStep.java | 2 +- .../main/java/org/jooq/InsertResultStep.java | 2 +- .../java/org/jooq/InsertReturningStep.java | 2 +- .../main/java/org/jooq/InsertSetMoreStep.java | 2 +- .../src/main/java/org/jooq/InsertSetStep.java | 2 +- .../java/org/jooq/MergeMatchedSetStep.java | 2 +- .../java/org/jooq/MergeNotMatchedSetStep.java | 2 +- jOOQ/src/main/java/org/jooq/Row1.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row10.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row11.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row12.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row13.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row14.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row15.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row16.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row17.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row18.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row19.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row2.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row20.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row21.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row22.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row3.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row4.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row5.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row6.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row7.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row8.java | 18 +++--- jOOQ/src/main/java/org/jooq/Row9.java | 18 +++--- jOOQ/src/main/java/org/jooq/RowN.java | 18 +++--- .../main/java/org/jooq/SelectSeekStep1.java | 8 +-- .../main/java/org/jooq/SelectSeekStep10.java | 8 +-- .../main/java/org/jooq/SelectSeekStep11.java | 8 +-- .../main/java/org/jooq/SelectSeekStep12.java | 8 +-- .../main/java/org/jooq/SelectSeekStep13.java | 8 +-- .../main/java/org/jooq/SelectSeekStep14.java | 8 +-- .../main/java/org/jooq/SelectSeekStep15.java | 8 +-- .../main/java/org/jooq/SelectSeekStep16.java | 8 +-- .../main/java/org/jooq/SelectSeekStep17.java | 8 +-- .../main/java/org/jooq/SelectSeekStep18.java | 8 +-- .../main/java/org/jooq/SelectSeekStep19.java | 8 +-- .../main/java/org/jooq/SelectSeekStep2.java | 8 +-- .../main/java/org/jooq/SelectSeekStep20.java | 8 +-- .../main/java/org/jooq/SelectSeekStep21.java | 8 +-- .../main/java/org/jooq/SelectSeekStep22.java | 8 +-- .../main/java/org/jooq/SelectSeekStep3.java | 8 +-- .../main/java/org/jooq/SelectSeekStep4.java | 8 +-- .../main/java/org/jooq/SelectSeekStep5.java | 8 +-- .../main/java/org/jooq/SelectSeekStep6.java | 8 +-- .../main/java/org/jooq/SelectSeekStep7.java | 8 +-- .../main/java/org/jooq/SelectSeekStep8.java | 8 +-- .../main/java/org/jooq/SelectSeekStep9.java | 8 +-- .../main/java/org/jooq/SelectSeekStepN.java | 8 +-- .../main/java/org/jooq/UpdateResultStep.java | 2 +- .../java/org/jooq/UpdateReturningStep.java | 2 +- .../src/main/java/org/jooq/UpdateSetStep.java | 2 +- jOOQ/src/main/java/org/jooq/impl/DSL.java | 4 +- jOOQ/src/main/java/org/jooq/impl/Limit.java | 2 +- .../main/java/org/jooq/tools/StringUtils.java | 4 +- 60 files changed, 346 insertions(+), 346 deletions(-) diff --git a/jOOQ/src/main/java/org/jooq/Field.java b/jOOQ/src/main/java/org/jooq/Field.java index 83aa3e0749..0c85ed4f37 100644 --- a/jOOQ/src/main/java/org/jooq/Field.java +++ b/jOOQ/src/main/java/org/jooq/Field.java @@ -1767,13 +1767,13 @@ public interface Field extends SelectField, GroupField { Condition equal(Field field); /** - * this = (Select ...). + * this = (Select<?> ...). */ @Support Condition equal(Select> query); /** - * this = [quantifier] (Select ...). + * this = [quantifier] (Select<?> ...). * * @see DSL#all(Field) * @see DSL#all(Select) @@ -1802,7 +1802,7 @@ public interface Field extends SelectField, GroupField { Condition eq(Field field); /** - * this = (Select ...). + * this = (Select<?> ...). * * @see #equal(Select) */ @@ -1810,7 +1810,7 @@ public interface Field extends SelectField, GroupField { Condition eq(Select> query); /** - * this = [quantifier] (Select ...). + * this = [quantifier] (Select<?> ...). * * @see DSL#all(Field) * @see DSL#all(Select) @@ -1835,13 +1835,13 @@ public interface Field extends SelectField, GroupField { Condition notEqual(Field field); /** - * this != (Select ...). + * this != (Select<?> ...). */ @Support Condition notEqual(Select> query); /** - * this != [quantifier] (Select ...). + * this != [quantifier] (Select<?> ...). * * @see DSL#all(Field) * @see DSL#all(Select) @@ -1870,7 +1870,7 @@ public interface Field extends SelectField, GroupField { Condition ne(Field field); /** - * this != (Select ...). + * this != (Select<?> ...). * * @see #notEqual(Select) */ @@ -1878,7 +1878,7 @@ public interface Field extends SelectField, GroupField { Condition ne(Select> query); /** - * this != [quantifier] (Select ...). + * this != [quantifier] (Select<?> ...). * * @see DSL#all(Field) * @see DSL#all(Select) @@ -1891,25 +1891,25 @@ public interface Field extends SelectField, GroupField { Condition ne(QuantifiedSelect> query); /** - * this < value. + * this < value. */ @Support Condition lessThan(T value); /** - * this < field. + * this < field. */ @Support Condition lessThan(Field field); /** - * this < (Select ...). + * this < (Select<?> ...). */ @Support Condition lessThan(Select> query); /** - * this < [quantifier] (Select ...). + * this < [quantifier] (Select<?> ...). * * @see DSL#all(Field) * @see DSL#all(Select) @@ -1922,7 +1922,7 @@ public interface Field extends SelectField, GroupField { Condition lessThan(QuantifiedSelect> query); /** - * this < value. + * this < value. * * @see #lessThan(Object) */ @@ -1930,7 +1930,7 @@ public interface Field extends SelectField, GroupField { Condition lt(T value); /** - * this < field. + * this < field. * * @see #lessThan(Field) */ @@ -1938,7 +1938,7 @@ public interface Field extends SelectField, GroupField { Condition lt(Field field); /** - * this < (Select ...). + * this < (Select<?> ...). * * @see #lessThan(Select) */ @@ -1946,7 +1946,7 @@ public interface Field extends SelectField, GroupField { Condition lt(Select> query); /** - * this < [quantifier] (Select ...). + * this < [quantifier] (Select<?> ...). * * @see DSL#all(Field) * @see DSL#all(Select) @@ -1959,25 +1959,25 @@ public interface Field extends SelectField, GroupField { Condition lt(QuantifiedSelect> query); /** - * this <= value. + * this <= value. */ @Support Condition lessOrEqual(T value); /** - * this <= field. + * this <= field. */ @Support Condition lessOrEqual(Field field); /** - * this <= (Select ...). + * this <= (Select<?> ...). */ @Support Condition lessOrEqual(Select> query); /** - * this <= [quantifier] (Select ...). + * this <= [quantifier] (Select<?> ...). * * @see DSL#all(Field) * @see DSL#all(Select) @@ -1990,7 +1990,7 @@ public interface Field extends SelectField, GroupField { Condition lessOrEqual(QuantifiedSelect> query); /** - * this <= value. + * this <= value. * * @see #lessOrEqual(Object) */ @@ -1998,7 +1998,7 @@ public interface Field extends SelectField, GroupField { Condition le(T value); /** - * this <= field. + * this <= field. * * @see #lessOrEqual(Field) */ @@ -2006,7 +2006,7 @@ public interface Field extends SelectField, GroupField { Condition le(Field field); /** - * this <= (Select ...). + * this <= (Select<?> ...). * * @see #lessOrEqual(Select) */ @@ -2014,7 +2014,7 @@ public interface Field extends SelectField, GroupField { Condition le(Select> query); /** - * this <= [quantifier] (Select ...). + * this <= [quantifier] (Select<?> ...). * * @see DSL#all(Field) * @see DSL#all(Select) @@ -2039,13 +2039,13 @@ public interface Field extends SelectField, GroupField { Condition greaterThan(Field field); /** - * this > (Select ...). + * this > (Select<?> ...). */ @Support Condition greaterThan(Select> query); /** - * this > [quantifier] (Select ...). + * this > [quantifier] (Select<?> ...). * * @see DSL#all(Field) * @see DSL#all(Select) @@ -2074,7 +2074,7 @@ public interface Field extends SelectField, GroupField { Condition gt(Field field); /** - * this > (Select ...). + * this > (Select<?> ...). * * @see #greaterThan(Select) */ @@ -2082,7 +2082,7 @@ public interface Field extends SelectField, GroupField { Condition gt(Select> query); /** - * this > [quantifier] (Select ...). + * this > [quantifier] (Select<?> ...). * * @see DSL#all(Field) * @see DSL#all(Select) @@ -2107,13 +2107,13 @@ public interface Field extends SelectField, GroupField { Condition greaterOrEqual(Field field); /** - * this >= (Select ...). + * this >= (Select<?> ...). */ @Support Condition greaterOrEqual(Select> query); /** - * this >= [quantifier] (Select ...). + * this >= [quantifier] (Select<?> ...). * * @see DSL#all(Field) * @see DSL#all(Select) @@ -2142,7 +2142,7 @@ public interface Field extends SelectField, GroupField { Condition ge(Field field); /** - * this >= (Select ...). + * this >= (Select<?> ...). * * @see #greaterOrEqual(Select) */ @@ -2150,7 +2150,7 @@ public interface Field extends SelectField, GroupField { Condition ge(Select> query); /** - * this >= [quantifier] (Select ...). + * this >= [quantifier] (Select<?> ...). * * @see DSL#all(Field) * @see DSL#all(Select) diff --git a/jOOQ/src/main/java/org/jooq/InsertOnDuplicateSetStep.java b/jOOQ/src/main/java/org/jooq/InsertOnDuplicateSetStep.java index 1d2ce6297b..c43b820d24 100644 --- a/jOOQ/src/main/java/org/jooq/InsertOnDuplicateSetStep.java +++ b/jOOQ/src/main/java/org/jooq/InsertOnDuplicateSetStep.java @@ -107,7 +107,7 @@ public interface InsertOnDuplicateSetStep { * statement's ON DUPLICATE KEY UPDATE clause. *

* This is the same as calling {@link #set(Map)} with the argument record - * treated as a Map, Object>. + * treated as a Map<Field<?>, Object>. * * @see #set(Map) */ diff --git a/jOOQ/src/main/java/org/jooq/InsertResultStep.java b/jOOQ/src/main/java/org/jooq/InsertResultStep.java index 919249b8e5..0b3c15e276 100644 --- a/jOOQ/src/main/java/org/jooq/InsertResultStep.java +++ b/jOOQ/src/main/java/org/jooq/InsertResultStep.java @@ -48,7 +48,7 @@ import org.jooq.exception.DataAccessException; * Example: 

  * DSLContext create = DSL.using(configuration);
  *
- * TableRecord record =
+ * TableRecord<?> record =
  * create.insertInto(table, field1, field2)
  *       .values(value1, value2)
  *       .returning(field1)
diff --git a/jOOQ/src/main/java/org/jooq/InsertReturningStep.java b/jOOQ/src/main/java/org/jooq/InsertReturningStep.java
index db9ef40db3..26cdefc9da 100644
--- a/jOOQ/src/main/java/org/jooq/InsertReturningStep.java
+++ b/jOOQ/src/main/java/org/jooq/InsertReturningStep.java
@@ -48,7 +48,7 @@ import java.util.Collection;
  * Example: 
  * DSLContext create = DSL.using(configuration);
  *
- * TableRecord record =
+ * TableRecord<?> record =
  * create.insertInto(table, field1, field2)
  *       .values(value1, value2)
  *       .returning(field1)
diff --git a/jOOQ/src/main/java/org/jooq/InsertSetMoreStep.java b/jOOQ/src/main/java/org/jooq/InsertSetMoreStep.java
index fe08e336c2..e0524fac23 100644
--- a/jOOQ/src/main/java/org/jooq/InsertSetMoreStep.java
+++ b/jOOQ/src/main/java/org/jooq/InsertSetMoreStep.java
@@ -96,7 +96,7 @@ public interface InsertSetMoreStep extends InsertOnDuplicateSt
      * Set values in the INSERT statement.
      * 

      * This is the same as calling {@link #set(Map)} with the argument record
-     * treated as a Map, Object>.
+     * treated as a Map<Field<?>, Object>.
      *
      * @see #set(Map)
      */
diff --git a/jOOQ/src/main/java/org/jooq/InsertSetStep.java b/jOOQ/src/main/java/org/jooq/InsertSetStep.java
index 59a3d9ffd9..509190e32c 100644
--- a/jOOQ/src/main/java/org/jooq/InsertSetStep.java
+++ b/jOOQ/src/main/java/org/jooq/InsertSetStep.java
@@ -113,7 +113,7 @@ public interface InsertSetStep {
      * Set values in the INSERT statement.
      * 

      * This is the same as calling {@link #set(Map)} with the argument record
-     * treated as a Map, Object>.
+     * treated as a Map<Field<?>, Object>.
      *
      * @see #set(Map)
      */
diff --git a/jOOQ/src/main/java/org/jooq/MergeMatchedSetStep.java b/jOOQ/src/main/java/org/jooq/MergeMatchedSetStep.java
index f272386cb7..8b84737f05 100644
--- a/jOOQ/src/main/java/org/jooq/MergeMatchedSetStep.java
+++ b/jOOQ/src/main/java/org/jooq/MergeMatchedSetStep.java
@@ -107,7 +107,7 @@ public interface MergeMatchedSetStep {
      * statement's WHEN MATCHED clause.
      * 

      * This is the same as calling {@link #set(Map)} with the argument record
-     * treated as a Map, Object>.
+     * treated as a Map<Field<?>, Object>.
      *
      * @see #set(Map)
      */
diff --git a/jOOQ/src/main/java/org/jooq/MergeNotMatchedSetStep.java b/jOOQ/src/main/java/org/jooq/MergeNotMatchedSetStep.java
index 94c17b25db..29ead841ce 100644
--- a/jOOQ/src/main/java/org/jooq/MergeNotMatchedSetStep.java
+++ b/jOOQ/src/main/java/org/jooq/MergeNotMatchedSetStep.java
@@ -107,7 +107,7 @@ public interface MergeNotMatchedSetStep {
      * statement's WHEN NOT MATCHED clause.
      * 

      * This is the same as calling {@link #set(Map)} with the argument record
-     * treated as a Map, Object>.
+     * treated as a Map<Field<?>, Object>.
      *
      * @see #set(Map)
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row1.java b/jOOQ/src/main/java/org/jooq/Row1.java
index b932fad9ce..cc167b6b13 100644
--- a/jOOQ/src/main/java/org/jooq/Row1.java
+++ b/jOOQ/src/main/java/org/jooq/Row1.java
@@ -314,7 +314,7 @@ public interface Row1 extends Row {
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -433,8 +433,8 @@ public interface Row1 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row1 row);
@@ -548,8 +548,8 @@ public interface Row1 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row1 row);
@@ -933,7 +933,7 @@ public interface Row1 extends Row {
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -995,7 +995,7 @@ public interface Row1 extends Row {
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1057,7 +1057,7 @@ public interface Row1 extends Row {
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1119,7 +1119,7 @@ public interface Row1 extends Row {
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row10.java b/jOOQ/src/main/java/org/jooq/Row10.java
index aebc333cb0..3338040839 100644
--- a/jOOQ/src/main/java/org/jooq/Row10.java
+++ b/jOOQ/src/main/java/org/jooq/Row10.java
@@ -359,7 +359,7 @@ public interface Row10 extends Row {
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -478,8 +478,8 @@ public interface Row10 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row10 row);
@@ -593,8 +593,8 @@ public interface Row10 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row10 row);
@@ -978,7 +978,7 @@ public interface Row10 extends Row {
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1040,7 +1040,7 @@ public interface Row10 extends Row {
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1102,7 +1102,7 @@ public interface Row10 extends Row {
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1164,7 +1164,7 @@ public interface Row10 extends Row {
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row11.java b/jOOQ/src/main/java/org/jooq/Row11.java
index b03c1a7a7d..a03a28edbc 100644
--- a/jOOQ/src/main/java/org/jooq/Row11.java
+++ b/jOOQ/src/main/java/org/jooq/Row11.java
@@ -364,7 +364,7 @@ public interface Row11 extends Row
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -483,8 +483,8 @@ public interface Row11 extends Row
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row11 row);
@@ -598,8 +598,8 @@ public interface Row11 extends Row
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row11 row);
@@ -983,7 +983,7 @@ public interface Row11 extends Row
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1045,7 +1045,7 @@ public interface Row11 extends Row
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1107,7 +1107,7 @@ public interface Row11 extends Row
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1169,7 +1169,7 @@ public interface Row11 extends Row
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row12.java b/jOOQ/src/main/java/org/jooq/Row12.java
index 85a096388a..469ff8b9ce 100644
--- a/jOOQ/src/main/java/org/jooq/Row12.java
+++ b/jOOQ/src/main/java/org/jooq/Row12.java
@@ -369,7 +369,7 @@ public interface Row12 extend
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -488,8 +488,8 @@ public interface Row12 extend
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row12 row);
@@ -603,8 +603,8 @@ public interface Row12 extend
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row12 row);
@@ -988,7 +988,7 @@ public interface Row12 extend
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1050,7 +1050,7 @@ public interface Row12 extend
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1112,7 +1112,7 @@ public interface Row12 extend
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1174,7 +1174,7 @@ public interface Row12 extend
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row13.java b/jOOQ/src/main/java/org/jooq/Row13.java
index 6cb9942acb..b02d0f72a6 100644
--- a/jOOQ/src/main/java/org/jooq/Row13.java
+++ b/jOOQ/src/main/java/org/jooq/Row13.java
@@ -374,7 +374,7 @@ public interface Row13 e
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -493,8 +493,8 @@ public interface Row13 e
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row13 row);
@@ -608,8 +608,8 @@ public interface Row13 e
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row13 row);
@@ -993,7 +993,7 @@ public interface Row13 e
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1055,7 +1055,7 @@ public interface Row13 e
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1117,7 +1117,7 @@ public interface Row13 e
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1179,7 +1179,7 @@ public interface Row13 e
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row14.java b/jOOQ/src/main/java/org/jooq/Row14.java
index b265aa220c..5c3a7489a9 100644
--- a/jOOQ/src/main/java/org/jooq/Row14.java
+++ b/jOOQ/src/main/java/org/jooq/Row14.java
@@ -379,7 +379,7 @@ public interface Row14
      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -498,8 +498,8 @@ public interface Row14
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row14 row);
@@ -613,8 +613,8 @@ public interface Row14
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row14 row);
@@ -998,7 +998,7 @@ public interface Row14between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1060,7 +1060,7 @@ public interface Row14betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1122,7 +1122,7 @@ public interface Row14notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1184,7 +1184,7 @@ public interface Row14notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row15.java b/jOOQ/src/main/java/org/jooq/Row15.java
index 7a56689373..f42b34d505 100644
--- a/jOOQ/src/main/java/org/jooq/Row15.java
+++ b/jOOQ/src/main/java/org/jooq/Row15.java
@@ -384,7 +384,7 @@ public interface Row15
      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -503,8 +503,8 @@ public interface Row15
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row15 row);
@@ -618,8 +618,8 @@ public interface Row15
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row15 row);
@@ -1003,7 +1003,7 @@ public interface Row15between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1065,7 +1065,7 @@ public interface Row15betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1127,7 +1127,7 @@ public interface Row15notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1189,7 +1189,7 @@ public interface Row15notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row16.java b/jOOQ/src/main/java/org/jooq/Row16.java
index cf14feac09..68737f2e89 100644
--- a/jOOQ/src/main/java/org/jooq/Row16.java
+++ b/jOOQ/src/main/java/org/jooq/Row16.java
@@ -389,7 +389,7 @@ public interface Row16
      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -508,8 +508,8 @@ public interface Row16
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row16 row);
@@ -623,8 +623,8 @@ public interface Row16
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row16 row);
@@ -1008,7 +1008,7 @@ public interface Row16between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1070,7 +1070,7 @@ public interface Row16betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1132,7 +1132,7 @@ public interface Row16notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1194,7 +1194,7 @@ public interface Row16notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row17.java b/jOOQ/src/main/java/org/jooq/Row17.java
index b2711cd5d5..0c96f5e20d 100644
--- a/jOOQ/src/main/java/org/jooq/Row17.java
+++ b/jOOQ/src/main/java/org/jooq/Row17.java
@@ -394,7 +394,7 @@ public interface Row17
      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -513,8 +513,8 @@ public interface Row17
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row17 row);
@@ -628,8 +628,8 @@ public interface Row17
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row17 row);
@@ -1013,7 +1013,7 @@ public interface Row17between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1075,7 +1075,7 @@ public interface Row17betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1137,7 +1137,7 @@ public interface Row17notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1199,7 +1199,7 @@ public interface Row17notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row18.java b/jOOQ/src/main/java/org/jooq/Row18.java
index 1980471ba2..a2fffbefdc 100644
--- a/jOOQ/src/main/java/org/jooq/Row18.java
+++ b/jOOQ/src/main/java/org/jooq/Row18.java
@@ -399,7 +399,7 @@ public interface Row18
      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -518,8 +518,8 @@ public interface Row18
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row18 row);
@@ -633,8 +633,8 @@ public interface Row18
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row18 row);
@@ -1018,7 +1018,7 @@ public interface Row18between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1080,7 +1080,7 @@ public interface Row18betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1142,7 +1142,7 @@ public interface Row18notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1204,7 +1204,7 @@ public interface Row18notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row19.java b/jOOQ/src/main/java/org/jooq/Row19.java
index cf27cf1883..a0898df827 100644
--- a/jOOQ/src/main/java/org/jooq/Row19.java
+++ b/jOOQ/src/main/java/org/jooq/Row19.java
@@ -404,7 +404,7 @@ public interface Row19
      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -523,8 +523,8 @@ public interface Row19
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row19 row);
@@ -638,8 +638,8 @@ public interface Row19
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row19 row);
@@ -1023,7 +1023,7 @@ public interface Row19between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1085,7 +1085,7 @@ public interface Row19betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1147,7 +1147,7 @@ public interface Row19notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1209,7 +1209,7 @@ public interface Row19notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row2.java b/jOOQ/src/main/java/org/jooq/Row2.java
index f4d11bce41..7edc25fcb6 100644
--- a/jOOQ/src/main/java/org/jooq/Row2.java
+++ b/jOOQ/src/main/java/org/jooq/Row2.java
@@ -319,7 +319,7 @@ public interface Row2 extends Row {
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -438,8 +438,8 @@ public interface Row2 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row2 row);
@@ -553,8 +553,8 @@ public interface Row2 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row2 row);
@@ -938,7 +938,7 @@ public interface Row2 extends Row {
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1000,7 +1000,7 @@ public interface Row2 extends Row {
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1062,7 +1062,7 @@ public interface Row2 extends Row {
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1124,7 +1124,7 @@ public interface Row2 extends Row {
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row20.java b/jOOQ/src/main/java/org/jooq/Row20.java
index c78fb205c9..9b02ee4fd2 100644
--- a/jOOQ/src/main/java/org/jooq/Row20.java
+++ b/jOOQ/src/main/java/org/jooq/Row20.java
@@ -409,7 +409,7 @@ public interface Row20
      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -528,8 +528,8 @@ public interface Row20
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row20 row);
@@ -643,8 +643,8 @@ public interface Row20
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row20 row);
@@ -1028,7 +1028,7 @@ public interface Row20between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1090,7 +1090,7 @@ public interface Row20betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1152,7 +1152,7 @@ public interface Row20notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1214,7 +1214,7 @@ public interface Row20notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row21.java b/jOOQ/src/main/java/org/jooq/Row21.java
index 50018f7e23..23c8fe26dc 100644
--- a/jOOQ/src/main/java/org/jooq/Row21.java
+++ b/jOOQ/src/main/java/org/jooq/Row21.java
@@ -414,7 +414,7 @@ public interface Row21
      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -533,8 +533,8 @@ public interface Row21
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row21 row);
@@ -648,8 +648,8 @@ public interface Row21
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row21 row);
@@ -1033,7 +1033,7 @@ public interface Row21between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1095,7 +1095,7 @@ public interface Row21betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1157,7 +1157,7 @@ public interface Row21notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1219,7 +1219,7 @@ public interface Row21notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row22.java b/jOOQ/src/main/java/org/jooq/Row22.java
index bafbe1cc2b..888ad8e25b 100644
--- a/jOOQ/src/main/java/org/jooq/Row22.java
+++ b/jOOQ/src/main/java/org/jooq/Row22.java
@@ -419,7 +419,7 @@ public interface Row22
      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -538,8 +538,8 @@ public interface Row22
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row22 row);
@@ -653,8 +653,8 @@ public interface Row22
      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row22 row);
@@ -1038,7 +1038,7 @@ public interface Row22between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1100,7 +1100,7 @@ public interface Row22betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1162,7 +1162,7 @@ public interface Row22notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1224,7 +1224,7 @@ public interface Row22notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row3.java b/jOOQ/src/main/java/org/jooq/Row3.java
index 8b83b41729..873e93d280 100644
--- a/jOOQ/src/main/java/org/jooq/Row3.java
+++ b/jOOQ/src/main/java/org/jooq/Row3.java
@@ -324,7 +324,7 @@ public interface Row3 extends Row {
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -443,8 +443,8 @@ public interface Row3 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row3 row);
@@ -558,8 +558,8 @@ public interface Row3 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row3 row);
@@ -943,7 +943,7 @@ public interface Row3 extends Row {
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1005,7 +1005,7 @@ public interface Row3 extends Row {
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1067,7 +1067,7 @@ public interface Row3 extends Row {
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1129,7 +1129,7 @@ public interface Row3 extends Row {
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row4.java b/jOOQ/src/main/java/org/jooq/Row4.java
index 57f50f6dc1..0e74ce7e28 100644
--- a/jOOQ/src/main/java/org/jooq/Row4.java
+++ b/jOOQ/src/main/java/org/jooq/Row4.java
@@ -329,7 +329,7 @@ public interface Row4 extends Row {
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -448,8 +448,8 @@ public interface Row4 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row4 row);
@@ -563,8 +563,8 @@ public interface Row4 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row4 row);
@@ -948,7 +948,7 @@ public interface Row4 extends Row {
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1010,7 +1010,7 @@ public interface Row4 extends Row {
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1072,7 +1072,7 @@ public interface Row4 extends Row {
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1134,7 +1134,7 @@ public interface Row4 extends Row {
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row5.java b/jOOQ/src/main/java/org/jooq/Row5.java
index 4f4dce9125..352005b291 100644
--- a/jOOQ/src/main/java/org/jooq/Row5.java
+++ b/jOOQ/src/main/java/org/jooq/Row5.java
@@ -334,7 +334,7 @@ public interface Row5 extends Row {
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -453,8 +453,8 @@ public interface Row5 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row5 row);
@@ -568,8 +568,8 @@ public interface Row5 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row5 row);
@@ -953,7 +953,7 @@ public interface Row5 extends Row {
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1015,7 +1015,7 @@ public interface Row5 extends Row {
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1077,7 +1077,7 @@ public interface Row5 extends Row {
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1139,7 +1139,7 @@ public interface Row5 extends Row {
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row6.java b/jOOQ/src/main/java/org/jooq/Row6.java
index 01be4d853b..87b5c7abda 100644
--- a/jOOQ/src/main/java/org/jooq/Row6.java
+++ b/jOOQ/src/main/java/org/jooq/Row6.java
@@ -339,7 +339,7 @@ public interface Row6 extends Row {
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -458,8 +458,8 @@ public interface Row6 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row6 row);
@@ -573,8 +573,8 @@ public interface Row6 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row6 row);
@@ -958,7 +958,7 @@ public interface Row6 extends Row {
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1020,7 +1020,7 @@ public interface Row6 extends Row {
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1082,7 +1082,7 @@ public interface Row6 extends Row {
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1144,7 +1144,7 @@ public interface Row6 extends Row {
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row7.java b/jOOQ/src/main/java/org/jooq/Row7.java
index c5f12f2e9d..fdc4eb3ca0 100644
--- a/jOOQ/src/main/java/org/jooq/Row7.java
+++ b/jOOQ/src/main/java/org/jooq/Row7.java
@@ -344,7 +344,7 @@ public interface Row7 extends Row {
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -463,8 +463,8 @@ public interface Row7 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row7 row);
@@ -578,8 +578,8 @@ public interface Row7 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row7 row);
@@ -963,7 +963,7 @@ public interface Row7 extends Row {
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1025,7 +1025,7 @@ public interface Row7 extends Row {
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1087,7 +1087,7 @@ public interface Row7 extends Row {
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1149,7 +1149,7 @@ public interface Row7 extends Row {
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row8.java b/jOOQ/src/main/java/org/jooq/Row8.java
index 756e9ac039..f5877cefce 100644
--- a/jOOQ/src/main/java/org/jooq/Row8.java
+++ b/jOOQ/src/main/java/org/jooq/Row8.java
@@ -349,7 +349,7 @@ public interface Row8 extends Row {
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -468,8 +468,8 @@ public interface Row8 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row8 row);
@@ -583,8 +583,8 @@ public interface Row8 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row8 row);
@@ -968,7 +968,7 @@ public interface Row8 extends Row {
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1030,7 +1030,7 @@ public interface Row8 extends Row {
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1092,7 +1092,7 @@ public interface Row8 extends Row {
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1154,7 +1154,7 @@ public interface Row8 extends Row {
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/Row9.java b/jOOQ/src/main/java/org/jooq/Row9.java
index 48124d516a..6269f0a868 100644
--- a/jOOQ/src/main/java/org/jooq/Row9.java
+++ b/jOOQ/src/main/java/org/jooq/Row9.java
@@ -354,7 +354,7 @@ public interface Row9 extends Row {
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -473,8 +473,8 @@ public interface Row9 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(Row9 row);
@@ -588,8 +588,8 @@ public interface Row9 extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(Row9 row);
@@ -973,7 +973,7 @@ public interface Row9 extends Row {
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1035,7 +1035,7 @@ public interface Row9 extends Row {
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1097,7 +1097,7 @@ public interface Row9 extends Row {
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1159,7 +1159,7 @@ public interface Row9 extends Row {
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/RowN.java b/jOOQ/src/main/java/org/jooq/RowN.java
index a02dfc2754..f46c1e18e4 100644
--- a/jOOQ/src/main/java/org/jooq/RowN.java
+++ b/jOOQ/src/main/java/org/jooq/RowN.java
@@ -305,7 +305,7 @@ public interface RowN extends Row {
      * 

      * Row non-equality comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <> (1, 2) is equivalent to
+     * (A, B) <> (1, 2) is equivalent to
      * NOT(A = 1 AND B = 2)
      */
     @Support
@@ -424,8 +424,8 @@ public interface RowN extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B, C) < (1, 2, 3) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
+     * (A, B, C) < (1, 2, 3) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2 AND C < 3)
      */
     @Support
     Condition lessThan(RowN row);
@@ -539,8 +539,8 @@ public interface RowN extends Row {
      * 

      * Row order comparison predicates can be emulated in those
      * databases that do not support such predicates natively:
-     * (A, B) <= (1, 2) is equivalent to
-     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
+     * (A, B) <= (1, 2) is equivalent to
+     * A < 1 OR (A = 1 AND B < 2) OR (A = 1 AND B = 2)
      */
     @Support
     Condition lessOrEqual(RowN row);
@@ -924,7 +924,7 @@ public interface RowN extends Row {
      * This is the same as calling between(minValue).and(maxValue)
      * 

      * The expression A BETWEEN B AND C is equivalent to the
-     * expression A >= B AND A <= C for those SQL dialects that do
+     * expression A >= B AND A <= C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -986,7 +986,7 @@ public interface RowN extends Row {
      * This is the same as calling betweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A BETWEEN SYMMETRIC B AND C is equivalent to
-     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
+     * the expression (A >= B AND A <= C) OR (A >= C AND A <= B)
      * for those SQL dialects that do not properly support the
      * BETWEEN predicate for row value expressions
      */
@@ -1048,7 +1048,7 @@ public interface RowN extends Row {
      * This is the same as calling notBetween(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN B AND C is equivalent to the
-     * expression A < B OR A > C for those SQL dialects that do
+     * expression A < B OR A > C for those SQL dialects that do
      * not properly support the BETWEEN predicate for row value
      * expressions
      */
@@ -1110,7 +1110,7 @@ public interface RowN extends Row {
      * This is the same as calling notBetweenSymmetric(minValue).and(maxValue)
      * 

      * The expression A NOT BETWEEN SYMMETRIC B AND C is equivalent
-     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
+     * to the expression (A < B OR A > C) AND (A < C OR A > B) for
      * those SQL dialects that do not properly support the BETWEEN
      * predicate for row value expressions
      */
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep1.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep1.java
index 2612118767..cd5fbde5b9 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep1.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep1.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep1 extends SelectLimitStep
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep1 extends SelectLimitStep
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep1 extends SelectLimitStep
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep1 extends SelectLimitStep
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep10.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep10.java
index 79c3f595ae..3117e0c429 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep10.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep10.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep10
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep10
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep10
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep10
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep11.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep11.java
index cf8504e9d8..eb12fa8fb2 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep11.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep11.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep11
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep11
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep11
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep11
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep12.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep12.java
index 943f60c70e..8de295c184 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep12.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep12.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep12
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep12
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep12
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep12
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep13.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep13.java
index 5fa984614c..4be651529e 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep13.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep13.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep13
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep13
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep13
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep13
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep14.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep14.java
index e65612aeac..8a12c93c68 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep14.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep14.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep14
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep14
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep14
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep14
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep15.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep15.java
index 371830eddc..50adc904cc 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep15.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep15.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep15
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep15
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep15
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep15
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep16.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep16.java
index dd153c93d3..d5b230ec12 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep16.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep16.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep16
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep16
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep16
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep16
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep17.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep17.java
index 0b8999f180..ce2b4c2a10 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep17.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep17.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep17
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep17
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep17
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep17
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep18.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep18.java
index 2dddf04fe7..81ef0c1074 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep18.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep18.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep18
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep18
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep18
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep18
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep19.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep19.java
index 0b4e3c5158..b905a63e47 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep19.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep19.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep19
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep19
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep19
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep19
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep2.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep2.java
index 589571c533..0f3f2b393e 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep2.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep2.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep2 extends SelectLimitSt
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep2 extends SelectLimitSt
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep2 extends SelectLimitSt
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep2 extends SelectLimitSt
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep20.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep20.java
index fa1a7b86c6..fb052ee4e5 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep20.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep20.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep20
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep20
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep20
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep20
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep21.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep21.java
index c9799f135c..474d8ca468 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep21.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep21.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep21
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep21
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep21
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep21
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep22.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep22.java
index 24e95851ca..6c0f964667 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep22.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep22.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep22
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep22
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep22
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep22
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep3.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep3.java
index 5f365d5b24..666895b1fe 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep3.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep3.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep3 extends SelectLim
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep3 extends SelectLim
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep3 extends SelectLim
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep3 extends SelectLim
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep4.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep4.java
index 0849a222f4..55f72c00ad 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep4.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep4.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep4 extends Selec
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep4 extends Selec
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep4 extends Selec
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep4 extends Selec
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep5.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep5.java
index cfd5f6e60c..c7c42a80fb 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep5.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep5.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep5 extends S
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep5 extends S
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep5 extends S
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep5 extends S
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep6.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep6.java
index 4234ddc9de..e9a168fa93 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep6.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep6.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep6 exten
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep6 exten
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep6 exten
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep6 exten
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep7.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep7.java
index 011fac8fa1..31cd7b4c61 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep7.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep7.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep7 e
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep7 e
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep7 e
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep7 e
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep8.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep8.java
index d6d2268670..6680e599af 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep8.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep8.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep8
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep8
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep8
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep8
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStep9.java b/jOOQ/src/main/java/org/jooq/SelectSeekStep9.java
index 335d8d3fcb..43b14e0c13 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStep9.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStep9.java
@@ -319,7 +319,7 @@ public interface SelectSeekStep9
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -327,7 +327,7 @@ public interface SelectSeekStep9
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -369,7 +369,7 @@ public interface SelectSeekStep9
      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -377,7 +377,7 @@ public interface SelectSeekStep9
      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/SelectSeekStepN.java b/jOOQ/src/main/java/org/jooq/SelectSeekStepN.java
index 15905a16cf..7a8a03cfd5 100644
--- a/jOOQ/src/main/java/org/jooq/SelectSeekStepN.java
+++ b/jOOQ/src/main/java/org/jooq/SelectSeekStepN.java
@@ -317,7 +317,7 @@ public interface SelectSeekStepN extends SelectLimitStep {
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -325,7 +325,7 @@ public interface SelectSeekStepN extends SelectLimitStep {
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
@@ -367,7 +367,7 @@ public interface SelectSeekStepN extends SelectLimitStep {
      * 

      * 
      * SELECT * FROM table
-     * WHERE (id, code) < (3, 'abc')
+     * WHERE (id, code) < (3, 'abc')
      * ORDER BY id ASC, code ASC
      * 

      * 

@@ -375,7 +375,7 @@ public interface SelectSeekStepN extends SelectLimitStep {
      * equivalent predicate:
      * 

      * 
-     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
+     * WHERE (id < 3) OR (id = 3 AND code < 'abc')
      * 

      * 

      * The SEEK BEFORE method currently does not support seeking
diff --git a/jOOQ/src/main/java/org/jooq/UpdateResultStep.java b/jOOQ/src/main/java/org/jooq/UpdateResultStep.java
index cbf7e89cd8..c43b320181 100644
--- a/jOOQ/src/main/java/org/jooq/UpdateResultStep.java
+++ b/jOOQ/src/main/java/org/jooq/UpdateResultStep.java
@@ -51,7 +51,7 @@ import org.jooq.exception.DataAccessException;
  * Example: 
  * DSLContext create = DSL.using(configuration);
  *
- * TableRecord record =
+ * TableRecord<?> record =
  * create.update(table)
  *       .set(field1, value1)
  *       .set(field2, value2)
diff --git a/jOOQ/src/main/java/org/jooq/UpdateReturningStep.java b/jOOQ/src/main/java/org/jooq/UpdateReturningStep.java
index 410df11059..4ac3c98842 100644
--- a/jOOQ/src/main/java/org/jooq/UpdateReturningStep.java
+++ b/jOOQ/src/main/java/org/jooq/UpdateReturningStep.java
@@ -52,7 +52,7 @@ import java.util.Collection;
  * Example: 
  * DSLContext create = DSL.using(configuration);
  *
- * TableRecord record =
+ * TableRecord<?> record =
  * create.update(table)
  *       .set(field1, value1)
  *       .set(field2, value2)
diff --git a/jOOQ/src/main/java/org/jooq/UpdateSetStep.java b/jOOQ/src/main/java/org/jooq/UpdateSetStep.java
index 5afe5e233a..878db16586 100644
--- a/jOOQ/src/main/java/org/jooq/UpdateSetStep.java
+++ b/jOOQ/src/main/java/org/jooq/UpdateSetStep.java
@@ -91,7 +91,7 @@ public interface UpdateSetStep {
      * Set a value for a field in the UPDATE statement.
      * 

      * This is the same as calling {@link #set(Map)} with the argument record
-     * treated as a Map, Object>.
+     * treated as a Map<Field<?>, Object>.
      *
      * @see #set(Map)
      */
diff --git a/jOOQ/src/main/java/org/jooq/impl/DSL.java b/jOOQ/src/main/java/org/jooq/impl/DSL.java
index 0b7c8a5f84..47c6f0bb23 100644
--- a/jOOQ/src/main/java/org/jooq/impl/DSL.java
+++ b/jOOQ/src/main/java/org/jooq/impl/DSL.java
@@ -9744,7 +9744,7 @@ public class DSL {
     /**
      * The bitwise left shift operator.
      * 

-     * Some dialects natively support this using [field1] << [field2].
+     * Some dialects natively support this using [field1] << [field2].
      * jOOQ simulates this operator in some dialects using
      * [field1] * power(2, [field2]), where power might also be simulated.
      *
@@ -9892,7 +9892,7 @@ public class DSL {
      * ... or simulates it elsewhere (without bind variables on values -1, 0, 1):
      * 
      * CASE WHEN [this] > 0 THEN 1
-     *      WHEN [this] < 0 THEN -1
+     *      WHEN [this] < 0 THEN -1
      *      ELSE 0
      * END
      */
diff --git a/jOOQ/src/main/java/org/jooq/impl/Limit.java b/jOOQ/src/main/java/org/jooq/impl/Limit.java
index 374698ad9d..37661a3ef9 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Limit.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Limit.java
@@ -274,7 +274,7 @@ class Limit extends AbstractQueryPart {
     }
 
     /**
-     * The upper bound, such that ROW_NUMBER() <= getUpperRownum()
+     * The upper bound, such that ROW_NUMBER() <= getUpperRownum()
      */
     final Field getUpperRownum() {
         return offsetOrZero.add(numberOfRows);
diff --git a/jOOQ/src/main/java/org/jooq/tools/StringUtils.java b/jOOQ/src/main/java/org/jooq/tools/StringUtils.java
index 2f332bcfdf..5eb4fcf2e6 100644
--- a/jOOQ/src/main/java/org/jooq/tools/StringUtils.java
+++ b/jOOQ/src/main/java/org/jooq/tools/StringUtils.java
@@ -426,7 +426,7 @@ public final class StringUtils {
     /**
      * 
Left pad a String with spaces (' ').

      *
-     * 
The String is padded to the size of size.

+     * 
The String is padded to the size of size.

      *
      * 
      * StringUtils.leftPad(null, *)   = null
@@ -867,7 +867,7 @@ public final class StringUtils {
      * @param replacementList
      *            the Strings to replace them with, no-op if null
      * @param repeat if true, then replace repeatedly
-     *       until there are no more possible replacements or timeToLive < 0
+     *       until there are no more possible replacements or timeToLive < 0
      * @param timeToLive
      *            if less than 0 then there is a circular reference and endless
      *            loop