diff --git a/jOOQ/src/main/java/org/jooq/BetweenAndStepR.java b/jOOQ/src/main/java/org/jooq/BetweenAndStepR.java
new file mode 100644
index 0000000000..abfa9d51f2
--- /dev/null
+++ b/jOOQ/src/main/java/org/jooq/BetweenAndStepR.java
@@ -0,0 +1,79 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Other licenses:
+ * -----------------------------------------------------------------------------
+ * Commercial licenses for this work are available. These replace the above
+ * ASL 2.0 and offer limited warranties, support, maintenance, and commercial
+ * database integrations.
+ *
+ * For more information, please visit: http://www.jooq.org/licenses
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+package org.jooq;
+
+
+/**
+ * An intermediate DSL type for the construction of a <code>BETWEEN</code>
+ * predicate.
+ * <p>
+ * <h3>Referencing <code>XYZ*Step</code> types directly from client code</h3>
+ * <p>
+ * It is usually not recommended to reference any <code>XYZ*Step</code> types
+ * directly from client code, or assign them to local variables. When writing
+ * dynamic SQL, creating a statement's components dynamically, and passing them
+ * to the DSL API statically is usually a better choice. See the manual's
+ * section about dynamic SQL for details: <a href=
+ * "https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql">https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql</a>.
+ * <p>
+ * Drawbacks of referencing the <code>XYZ*Step</code> types directly:
+ * <ul>
+ * <li>They're operating on mutable implementations (as of jOOQ 3.x)</li>
+ * <li>They're less composable and not easy to get right when dynamic SQL gets
+ * complex</li>
+ * <li>They're less readable</li>
+ * <li>They might have binary incompatible changes between minor releases</li>
+ * </ul>
+ *
+ * @author Lukas Eder
+ */
+public interface BetweenAndStepR<R extends Record> {
+
+    /**
+     * Create a condition to check this field against some bounds.
+     */
+    @Support
+    Condition and(R value);
+
+//    TODO: Support this
+//    /**
+//     * Create a condition to check this field against some bounds.
+//     */
+//    @Support
+//    Condition and(Select<? extends R> query);
+}
diff --git a/jOOQ/src/main/java/org/jooq/SelectCorrelatedSubqueryStep.java b/jOOQ/src/main/java/org/jooq/SelectCorrelatedSubqueryStep.java
new file mode 100644
index 0000000000..e29caa262a
--- /dev/null
+++ b/jOOQ/src/main/java/org/jooq/SelectCorrelatedSubqueryStep.java
@@ -0,0 +1,582 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *  http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Other licenses:
+ * -----------------------------------------------------------------------------
+ * Commercial licenses for this work are available. These replace the above
+ * ASL 2.0 and offer limited warranties, support, maintenance, and commercial
+ * database integrations.
+ *
+ * For more information, please visit: http://www.jooq.org/licenses
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ */
+package org.jooq;
+
+import org.jooq.conf.Settings;
+
+/**
+ * This type is used for the {@link Select}'s DSL API when selecting generic
+ * {@link Record} types.
+ * <p>
+ * Example: <code><pre>
+ * -- get all authors' first and last names, and the number
+ * -- of books they've written in German, if they have written
+ * -- more than five books in German in the last three years
+ * -- (from 2011), and sort those authors by last names
+ * -- limiting results to the second and third row
+ *
+ *   SELECT T_AUTHOR.FIRST_NAME, T_AUTHOR.LAST_NAME, COUNT(*)
+ *     FROM T_AUTHOR
+ *     JOIN T_BOOK ON T_AUTHOR.ID = T_BOOK.AUTHOR_ID
+ *    WHERE T_BOOK.LANGUAGE = 'DE'
+ *      AND T_BOOK.PUBLISHED &gt; '2008-01-01'
+ * GROUP BY T_AUTHOR.FIRST_NAME, T_AUTHOR.LAST_NAME
+ *   HAVING COUNT(*) &gt; 5
+ * ORDER BY T_AUTHOR.LAST_NAME ASC NULLS FIRST
+ *    LIMIT 2
+ *   OFFSET 1
+ *      FOR UPDATE
+ *       OF FIRST_NAME, LAST_NAME
+ *       NO WAIT
+ * </pre></code> Its equivalent in jOOQ <code><pre>
+ * create.select(TAuthor.FIRST_NAME, TAuthor.LAST_NAME, create.count())
+ *       .from(T_AUTHOR)
+ *       .join(T_BOOK).on(TBook.AUTHOR_ID.equal(TAuthor.ID))
+ *       .where(TBook.LANGUAGE.equal("DE"))
+ *       .and(TBook.PUBLISHED.greaterThan(parseDate('2008-01-01')))
+ *       .groupBy(TAuthor.FIRST_NAME, TAuthor.LAST_NAME)
+ *       .having(create.count().greaterThan(5))
+ *       .orderBy(TAuthor.LAST_NAME.asc().nullsFirst())
+ *       .limit(2)
+ *       .offset(1)
+ *       .forUpdate()
+ *       .of(TAuthor.FIRST_NAME, TAuthor.LAST_NAME)
+ *       .noWait();
+ * </pre></code> Refer to the manual for more details
+ * <p>
+ * <h3>Referencing <code>XYZ*Step</code> types directly from client code</h3>
+ * <p>
+ * It is usually not recommended to reference any <code>XYZ*Step</code> types
+ * directly from client code, or assign them to local variables. When writing
+ * dynamic SQL, creating a statement's components dynamically, and passing them
+ * to the DSL API statically is usually a better choice. See the manual's
+ * section about dynamic SQL for details: <a href=
+ * "https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql">https://www.jooq.org/doc/latest/manual/sql-building/dynamic-sql</a>.
+ * <p>
+ * Drawbacks of referencing the <code>XYZ*Step</code> types directly:
+ * <ul>
+ * <li>They're operating on mutable implementations (as of jOOQ 3.x)</li>
+ * <li>They're less composable and not easy to get right when dynamic SQL gets
+ * complex</li>
+ * <li>They're less readable</li>
+ * <li>They might have binary incompatible changes between minor releases</li>
+ * </ul>
+ *
+ * @author Lukas Eder
+ */
+public interface SelectCorrelatedSubqueryStep<R extends Record> extends SelectFinalStep<R> {
+
+    /**
+     * Compare this subquery with a record using a dynamic comparator.
+     * <p>
+     * See the explicit comparison methods for details. Note, not all {@link
+     * Comparator} types are supported
+     *
+     * @see #eq(Record)
+     * @see #ne(Record)
+     * @see #lt(Record)
+     * @see #le(Record)
+     * @see #gt(Record)
+     * @see #ge(Record)
+     */
+    @Support
+    Condition compare(Comparator comparator, R record);
+
+    /**
+     * Compare this subquery with a subquery using a dynamic comparator.
+     * <p>
+     * See the explicit comparison methods for details. Note, not all {@link
+     * Comparator} types are supported
+     *
+     * @see #eq(Record)
+     * @see #ne(Record)
+     * @see #lt(Record)
+     * @see #le(Record)
+     * @see #gt(Record)
+     * @see #ge(Record)
+     */
+    @Support
+    Condition compare(Comparator comparator, Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quantified subquery using a dynamic
+     * comparator.
+     * <p>
+     * See the explicit comparison methods for details. Note, not all {@link
+     * Comparator} types are supported
+     *
+     * @see #eq(Record)
+     * @see #ne(Record)
+     * @see #lt(Record)
+     * @see #le(Record)
+     * @see #gt(Record)
+     * @see #ge(Record)
+     */
+    @Support
+    Condition compare(Comparator comparator, QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a record for equality.
+     */
+    @Support
+    Condition eq(R record);
+
+    /**
+     * Compare this subquery with another record for equality.
+     */
+    @Support
+    Condition eq(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quanitified subquery for equality.
+     */
+    @Support
+    Condition eq(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a record for equality.
+     */
+    @Support
+    Condition equal(R record);
+
+    /**
+     * Compare this subquery with another record for equality.
+     */
+    @Support
+    Condition equal(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quanitified subquery for equality.
+     */
+    @Support
+    Condition equal(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a record for non-equality.
+     */
+    @Support
+    Condition ne(R record);
+
+    /**
+     * Compare this subquery with another record for non-equality.
+     */
+    @Support
+    Condition ne(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quanitified subquery for non-equality.
+     */
+    @Support
+    Condition ne(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a record for non-equality.
+     */
+    @Support
+    Condition notEqual(R record);
+
+    /**
+     * Compare this subquery with another record for non-equality.
+     */
+    @Support
+    Condition notEqual(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quanitified subquery for non-equality.
+     */
+    @Support
+    Condition notEqual(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a record for order.
+     */
+    @Support
+    Condition lt(R record);
+
+    /**
+     * Compare this subquery with another record for order.
+     */
+    @Support
+    Condition lt(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quanitified subquery for order.
+     */
+    @Support
+    Condition lt(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a record for order.
+     */
+    @Support
+    Condition lessThan(R record);
+
+    /**
+     * Compare this subquery with another record for order.
+     */
+    @Support
+    Condition lessThan(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quanitified subquery for order.
+     */
+    @Support
+    Condition lessThan(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a record for order.
+     */
+    @Support
+    Condition le(R record);
+
+    /**
+     * Compare this subquery with another record for order.
+     */
+    @Support
+    Condition le(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quanitified subquery for order.
+     */
+    @Support
+    Condition le(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a record for order.
+     */
+    @Support
+    Condition lessOrEqual(R record);
+
+    /**
+     * Compare this subquery with another record for order.
+     */
+    @Support
+    Condition lessOrEqual(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quanitified subquery for order.
+     */
+    @Support
+    Condition lessOrEqual(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a record for order.
+     */
+    @Support
+    Condition gt(R record);
+
+    /**
+     * Compare this subquery with another record for order.
+     */
+    @Support
+    Condition gt(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quanitified subquery for order.
+     */
+    @Support
+    Condition gt(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a record for order.
+     */
+    @Support
+    Condition greaterThan(R record);
+
+    /**
+     * Compare this subquery with another record for order.
+     */
+    @Support
+    Condition greaterThan(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quanitified subquery for order.
+     */
+    @Support
+    Condition greaterThan(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a record for order.
+     */
+    @Support
+    Condition ge(R record);
+
+    /**
+     * Compare this subquery with another record for order.
+     */
+    @Support
+    Condition ge(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quanitified subquery for order.
+     */
+    @Support
+    Condition ge(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a record for order.
+     */
+    @Support
+    Condition greaterOrEqual(R record);
+
+    /**
+     * Compare this subquery with another record for order.
+     */
+    @Support
+    Condition greaterOrEqual(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a quanitified subquery for order.
+     */
+    @Support
+    Condition greaterOrEqual(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with a set of records for equality.
+     * <p>
+     * Note that generating dynamic SQL with arbitrary-length
+     * <code>IN</code> predicates can cause cursor cache contention in some
+     * databases that use unique SQL strings as a statement identifier (e.g.
+     * {@link SQLDialect#ORACLE}). In order to prevent such problems, you could
+     * use {@link Settings#isInListPadding()} to produce less distinct SQL
+     * strings (see also
+     * <a href="https://github.com/jOOQ/jOOQ/issues/5600">[#5600]</a>), or you
+     * could avoid <code>IN</code> lists, and replace them with:
+     * <ul>
+     * <li><code>IN</code> predicates on temporary tables</li>
+     * <li><code>IN</code> predicates on unnested array bind variables</li>
+     * </ul>
+     */
+    @Support
+    Condition in(R... records);
+
+    /**
+     * Compare this subquery with another subquery for equality.
+     */
+    @Support
+    Condition in(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with a set of records for non-equality.
+     * <p>
+     * Note that generating dynamic SQL with arbitrary-length
+     * <code>IN</code> predicates can cause cursor cache contention in some
+     * databases that use unique SQL strings as a statement identifier (e.g.
+     * {@link SQLDialect#ORACLE}). In order to prevent such problems, you could
+     * use {@link Settings#isInListPadding()} to produce less distinct SQL
+     * strings (see also
+     * <a href="https://github.com/jOOQ/jOOQ/issues/5600">[#5600]</a>), or you
+     * could avoid <code>IN</code> lists, and replace them with:
+     * <ul>
+     * <li><code>IN</code> predicates on temporary tables</li>
+     * <li><code>IN</code> predicates on unnested array bind variables</li>
+     * </ul>
+     */
+    @Support
+    Condition notIn(R... records);
+
+    /**
+     * Compare this subquery with another subquery for non-equality.
+     */
+    @Support
+    Condition notIn(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with another record for distinctness.
+     */
+    @Support
+    Condition isDistinctFrom(R record);
+
+    /**
+     * Compare this subquery with another record for distinctness.
+     */
+    @Support
+    Condition isDistinctFrom(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with another record for distinctness.
+     */
+    @Support
+    Condition isDistinctFrom(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Compare this subquery with another record for distinctness.
+     */
+    @Support
+    Condition isNotDistinctFrom(R record);
+
+    /**
+     * Compare this subquery with another record for distinctness.
+     */
+    @Support
+    Condition isNotDistinctFrom(Select<? extends R> select);
+
+    /**
+     * Compare this subquery with another record for distinctness.
+     */
+    @Support
+    Condition isNotDistinctFrom(QuantifiedSelect<? extends R> select);
+
+    /**
+     * Check if this subquery is within a range of two records.
+     * <p>
+     * This is the same as calling <code>between(minValue).and(maxValue)</code>
+     */
+    @Support
+    BetweenAndStep<R> between(R minValue);
+
+    /**
+     * Check if this subquery is within a range of two records.
+     * <p>
+     * This is the same as calling <code>between(minValue).and(maxValue)</code>
+     */
+    @Support
+    Condition between(R minValue, R maxValue);
+
+    /**
+     * Check if this subquery is within a range of two subqueries.
+     * <p>
+     * This is the same as calling <code>between(minValue).and(maxValue)</code>
+     */
+    @Support
+    BetweenAndStep<R> between(Select<? extends R> minValue);
+
+    /**
+     * Check if this subquery is within a range of two subqueries.
+     * <p>
+     * This is the same as calling <code>between(minValue).and(maxValue)</code>
+     */
+    @Support
+    Condition between(Select<? extends R> minValue, Select<? extends R> maxValue);
+
+    /**
+     * Check if this subquery is within a symmetric range of two records.
+     */
+    @Support
+    BetweenAndStepR<R> betweenSymmetric(R minValue);
+
+    /**
+     * Check if this subquery is within a symmetric range of two records.
+     * <p>
+     * This is the same as calling <code>between(minValue).and(maxValue)</code>
+     */
+    @Support
+    Condition betweenSymmetric(R minValue, R maxValue);
+
+    /**
+     * Check if this subquery is within a symmetric range of two subqueries.
+     */
+    @Support
+    BetweenAndStepR<R> betweenSymmetric(Select<? extends R> minValue);
+
+    /**
+     * Check if this subquery is within a symmetric range of two subqueries.
+     * <p>
+     * This is the same as calling <code>between(minValue).and(maxValue)</code>
+     */
+    @Support
+    Condition betweenSymmetric(Select<? extends R> minValue, Select<? extends R> maxValue);
+
+    /**
+     * Check if this subquery is not within a range of two records.
+     */
+    @Support
+    BetweenAndStepR<R> notBetween(R minValue);
+
+    /**
+     * Check if this subquery is not within a range of two records.
+     * <p>
+     * This is the same as calling <code>between(minValue).and(maxValue)</code>
+     */
+    @Support
+    Condition notBetween(R minValue, R maxValue);
+
+    /**
+     * Check if this subquery is not within a range of two subqueries.
+     */
+    @Support
+    BetweenAndStepR<R> notBetween(Select<? extends R> minValue);
+
+    /**
+     * Check if this subquery is not within a range of two subqueries.
+     * <p>
+     * This is the same as calling <code>between(minValue).and(maxValue)</code>
+     */
+    @Support
+    Condition notBetween(Select<? extends R> minValue, Select<? extends R> maxValue);
+
+    /**
+     * Check if this subquery is not within a symmetric range of two records.
+     */
+    @Support
+    BetweenAndStepR<R> notBetweenSymmetric(R minValue);
+
+    /**
+     * Check if this subquery is not within a symmetric range of two records.
+     * <p>
+     * This is the same as calling <code>between(minValue).and(maxValue)</code>
+     */
+    @Support
+    Condition notBetweenSymmetric(R minValue, R maxValue);
+
+    /**
+     * Check if this subquery is not within a symmetric range of two subqueries.
+     */
+    @Support
+    BetweenAndStepR<R> notBetweenSymmetric(Select<? extends R> minValue);
+
+    /**
+     * Check if this subquery is not within a symmetric range of two subqueries.
+     * <p>
+     * This is the same as calling <code>between(minValue).and(maxValue)</code>
+     */
+    @Support
+    Condition notBetweenSymmetric(Select<? extends R> minValue, Select<? extends R> maxValue);
+
+    /**
+     * Check if the result of this subquery <code>IS NULL</code>
+     */
+    @Support
+    Condition isNull();
+
+    /**
+     * Check if the result of this subquery <code>IS NOT NULL</code>
+     */
+    @Support
+    Condition isNotNull();
+}
diff --git a/jOOQ/src/main/java/org/jooq/SelectUnionStep.java b/jOOQ/src/main/java/org/jooq/SelectUnionStep.java
index 77c2046967..fdfae2c64f 100644
--- a/jOOQ/src/main/java/org/jooq/SelectUnionStep.java
+++ b/jOOQ/src/main/java/org/jooq/SelectUnionStep.java
@@ -123,7 +123,7 @@ import static org.jooq.SQLDialect.SQLITE;
  *
  * @author Lukas Eder
  */
-public interface SelectUnionStep<R extends Record> extends SelectFinalStep<R> {
+public interface SelectUnionStep<R extends Record> extends SelectCorrelatedSubqueryStep<R> {
 
     /**
      * Apply the <code>UNION</code> set operation.
diff --git a/jOOQ/src/main/java/org/jooq/impl/RowIsNull.java b/jOOQ/src/main/java/org/jooq/impl/RowIsNull.java
index 0c8e61bdb3..10c4e8a324 100644
--- a/jOOQ/src/main/java/org/jooq/impl/RowIsNull.java
+++ b/jOOQ/src/main/java/org/jooq/impl/RowIsNull.java
@@ -43,6 +43,7 @@ import static org.jooq.Clause.CONDITION_IS_NULL;
 // ...
 // ...
 // ...
+// ...
 import static org.jooq.SQLDialect.CUBRID;
 // ...
 import static org.jooq.SQLDialect.DERBY;
@@ -55,13 +56,18 @@ import static org.jooq.SQLDialect.MARIADB;
 // ...
 import static org.jooq.SQLDialect.MYSQL;
 // ...
+import static org.jooq.SQLDialect.POSTGRES;
+// ...
 // ...
 import static org.jooq.SQLDialect.SQLITE;
 // ...
 // ...
 // ...
+import static org.jooq.impl.DSL.inline;
+import static org.jooq.impl.DSL.selectCount;
 import static org.jooq.impl.Keywords.K_IS_NOT_NULL;
 import static org.jooq.impl.Keywords.K_IS_NULL;
+import static org.jooq.impl.Tools.fieldNameStrings;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -69,12 +75,12 @@ import java.util.Set;
 
 import org.jooq.Clause;
 import org.jooq.Condition;
-import org.jooq.Configuration;
 import org.jooq.Context;
 import org.jooq.Field;
-import org.jooq.QueryPartInternal;
 import org.jooq.Row;
 import org.jooq.SQLDialect;
+import org.jooq.Select;
+import org.jooq.Table;
 
 /**
  * @author Lukas Eder
@@ -84,71 +90,76 @@ final class RowIsNull extends AbstractCondition {
     /**
      * Generated UID
      */
-    private static final long            serialVersionUID = -1806139685201770706L;
-    private static final Clause[]        CLAUSES_NULL     = { CONDITION, CONDITION_IS_NULL };
-    private static final Clause[]        CLAUSES_NOT_NULL = { CONDITION, CONDITION_IS_NOT_NULL };
+    private static final long            serialVersionUID   = -1806139685201770706L;
+    private static final Clause[]        CLAUSES_NULL       = { CONDITION, CONDITION_IS_NULL };
+    private static final Clause[]        CLAUSES_NOT_NULL   = { CONDITION, CONDITION_IS_NOT_NULL };
 
     // Currently not yet supported in SQLite:
     // https://www.sqlite.org/rowvalue.html
-    private static final Set<SQLDialect> EMULATE_NULL     = SQLDialect.supportedBy(CUBRID, DERBY, FIREBIRD, HSQLDB, MARIADB, MYSQL, SQLITE);
+    private static final Set<SQLDialect> EMULATE_NULL_ROW   = SQLDialect.supportedBy(CUBRID, DERBY, FIREBIRD, HSQLDB, MARIADB, MYSQL, SQLITE);
+    private static final Set<SQLDialect> EMULATE_NULL_QUERY = SQLDialect.supportedBy(CUBRID, DERBY, FIREBIRD, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE);
 
     private final Row                    row;
+    private final Select<?>              select;
     private final boolean                isNull;
 
     RowIsNull(Row row, boolean isNull) {
         this.row = row;
+        this.select = null;
+        this.isNull = isNull;
+    }
+
+    RowIsNull(Select<?> select, boolean isNull) {
+        this.row = null;
+        this.select = select;
         this.isNull = isNull;
     }
 
     @Override
     public final void accept(Context<?> ctx) {
-        ctx.visit(delegate(ctx.configuration()));
+
+
+
+
+
+
+        if (row != null && EMULATE_NULL_ROW.contains(ctx.family()))
+            ctx.visit(condition(row.fields()));
+        else if (select != null && EMULATE_NULL_QUERY.contains(ctx.family())) {
+            Table<?> t = select.asTable("t", fieldNameStrings(select.getSelect().size()));
+            ctx.visit(inline(1).eq(selectCount().from(t).where(condition(t.fields()))));
+        }
+        else
+            acceptStandard(ctx);
+    }
+
+    private final Condition condition(Field<?>[] fields) {
+        List<Condition> conditions = new ArrayList<>(fields.length);
+
+        for (Field<?> field : fields)
+            conditions.add(isNull ? field.isNull() : field.isNotNull());
+
+        return DSL.and(conditions);
+    }
+
+    private final void acceptStandard(Context<?> ctx) {
+        if (row != null)
+            ctx.visit(row);
+        else
+            ctx.sql('(')
+               .formatIndentStart().formatNewLine()
+               .subquery(true)
+               .visit(select)
+               .subquery(false)
+               .formatIndentEnd().formatNewLine()
+               .sql(')');
+
+        ctx.sql(' ')
+           .visit(isNull ? K_IS_NULL : K_IS_NOT_NULL);
     }
 
     @Override // Avoid AbstractCondition implementation
     public final Clause[] clauses(Context<?> ctx) {
         return null;
     }
-
-    private final QueryPartInternal delegate(Configuration configuration) {
-
-
-
-
-
-
-        if (EMULATE_NULL.contains(configuration.family())) {
-            Field<?>[] fields = row.fields();
-            List<Condition> conditions = new ArrayList<>(fields.length);
-
-            for (Field<?> field : fields)
-                conditions.add(isNull ? field.isNull() : field.isNotNull());
-
-            Condition result = DSL.and(conditions);
-            return (QueryPartInternal) result;
-        }
-        else {
-            return new Native();
-        }
-    }
-
-    private class Native extends AbstractCondition {
-
-        /**
-         * Generated UID
-         */
-        private static final long serialVersionUID = -2977241780111574353L;
-
-        @Override
-        public final void accept(Context<?> ctx) {
-            ctx.visit(row)
-               .sql(' ')
-               .visit(isNull ? K_IS_NULL : K_IS_NOT_NULL);
-        }
-
-        @Override
-        public final Clause[] clauses(Context<?> ctx) {
-            return isNull ? CLAUSES_NULL : CLAUSES_NOT_NULL;
-        }
-    }
 }
diff --git a/jOOQ/src/main/java/org/jooq/impl/SelectImpl.java b/jOOQ/src/main/java/org/jooq/impl/SelectImpl.java
index 3289100ce4..5c0623bffc 100644
--- a/jOOQ/src/main/java/org/jooq/impl/SelectImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/SelectImpl.java
@@ -60,6 +60,9 @@ import java.util.function.Function;
 import java.util.stream.Collector;
 import java.util.stream.Stream;
 
+import org.jooq.BetweenAndStep;
+import org.jooq.BetweenAndStepR;
+import org.jooq.Comparator;
 import org.jooq.Condition;
 import org.jooq.Configuration;
 import org.jooq.Converter;
@@ -74,6 +77,7 @@ import org.jooq.Operator;
 import org.jooq.OrderField;
 import org.jooq.Param;
 // ...
+import org.jooq.QuantifiedSelect;
 import org.jooq.QueryPart;
 import org.jooq.Record;
 import org.jooq.Record1;
@@ -4230,6 +4234,341 @@ final class SelectImpl<R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
 
 
 
+    @Override
+    public final Condition compare(Comparator comparator, R record) {
+        return null;
+    }
+
+    @Override
+    public final Condition compare(Comparator comparator, Select<? extends R> select) {
+        return null;
+    }
+
+    @Override
+    public final Condition compare(Comparator comparator, QuantifiedSelect<? extends R> select) {
+        return null;
+    }
+
+    @Override
+    public final Condition eq(R record) {
+        return compare(Comparator.EQUALS, record);
+    }
+
+    @Override
+    public final Condition eq(Select<? extends R> select) {
+        return compare(Comparator.EQUALS, select);
+    }
+
+    @Override
+    public final Condition eq(QuantifiedSelect<? extends R> select) {
+        return compare(Comparator.EQUALS, select);
+    }
+
+    @Override
+    public final Condition equal(R record) {
+        return compare(Comparator.EQUALS, record);
+    }
+
+    @Override
+    public final Condition equal(Select<? extends R> select) {
+        return compare(Comparator.EQUALS, select);
+    }
+
+    @Override
+    public final Condition equal(QuantifiedSelect<? extends R> select) {
+        return compare(Comparator.EQUALS, select);
+    }
+
+    @Override
+    public final Condition ne(R record) {
+        return compare(Comparator.NOT_EQUALS, record);
+    }
+
+    @Override
+    public final Condition ne(Select<? extends R> select) {
+        return compare(Comparator.NOT_EQUALS, select);
+    }
+
+    @Override
+    public final Condition ne(QuantifiedSelect<? extends R> select) {
+        return compare(Comparator.NOT_EQUALS, select);
+    }
+
+    @Override
+    public final Condition notEqual(R record) {
+        return compare(Comparator.NOT_EQUALS, record);
+    }
+
+    @Override
+    public final Condition notEqual(Select<? extends R> select) {
+        return compare(Comparator.NOT_EQUALS, select);
+    }
+
+    @Override
+    public final Condition notEqual(QuantifiedSelect<? extends R> select) {
+        return compare(Comparator.NOT_EQUALS, select);
+    }
+
+    @Override
+    public final Condition lt(R record) {
+        return compare(Comparator.LESS, record);
+    }
+
+    @Override
+    public final Condition lt(Select<? extends R> select) {
+        return compare(Comparator.LESS, select);
+    }
+
+    @Override
+    public final Condition lt(QuantifiedSelect<? extends R> select) {
+        return compare(Comparator.LESS, select);
+    }
+
+    @Override
+    public final Condition lessThan(R record) {
+        return compare(Comparator.LESS, record);
+    }
+
+    @Override
+    public final Condition lessThan(Select<? extends R> select) {
+        return compare(Comparator.LESS, select);
+    }
+
+    @Override
+    public final Condition lessThan(QuantifiedSelect<? extends R> select) {
+        return compare(Comparator.LESS, select);
+    }
+
+    @Override
+    public final Condition le(R record) {
+        return compare(Comparator.LESS_OR_EQUAL, record);
+    }
+
+    @Override
+    public final Condition le(Select<? extends R> select) {
+        return compare(Comparator.LESS_OR_EQUAL, select);
+    }
+
+    @Override
+    public final Condition le(QuantifiedSelect<? extends R> select) {
+        return compare(Comparator.LESS_OR_EQUAL, select);
+    }
+
+    @Override
+    public final Condition lessOrEqual(R record) {
+        return compare(Comparator.LESS_OR_EQUAL, record);
+    }
+
+    @Override
+    public final Condition lessOrEqual(Select<? extends R> select) {
+        return compare(Comparator.LESS_OR_EQUAL, select);
+    }
+
+    @Override
+    public final Condition lessOrEqual(QuantifiedSelect<? extends R> select) {
+        return compare(Comparator.LESS_OR_EQUAL, select);
+    }
+
+    @Override
+    public final Condition gt(R record) {
+        return compare(Comparator.GREATER, record);
+    }
+
+    @Override
+    public final Condition gt(Select<? extends R> select) {
+        return compare(Comparator.GREATER, select);
+    }
+
+    @Override
+    public final Condition gt(QuantifiedSelect<? extends R> select) {
+        return compare(Comparator.GREATER, select);
+    }
+
+    @Override
+    public final Condition greaterThan(R record) {
+        return compare(Comparator.GREATER, record);
+    }
+
+    @Override
+    public final Condition greaterThan(Select<? extends R> select) {
+        return compare(Comparator.GREATER, select);
+    }
+
+    @Override
+    public final Condition greaterThan(QuantifiedSelect<? extends R> select) {
+        return compare(Comparator.GREATER, select);
+    }
+
+    @Override
+    public final Condition ge(R record) {
+        return compare(Comparator.GREATER_OR_EQUAL, record);
+    }
+
+    @Override
+    public final Condition ge(Select<? extends R> select) {
+        return compare(Comparator.GREATER_OR_EQUAL, select);
+    }
+
+    @Override
+    public final Condition ge(QuantifiedSelect<? extends R> select) {
+        return compare(Comparator.GREATER_OR_EQUAL, select);
+    }
+
+    @Override
+    public final Condition greaterOrEqual(R record) {
+        return compare(Comparator.GREATER_OR_EQUAL, record);
+    }
+
+    @Override
+    public final Condition greaterOrEqual(Select<? extends R> select) {
+        return compare(Comparator.GREATER_OR_EQUAL, select);
+    }
+
+    @Override
+    public final Condition greaterOrEqual(QuantifiedSelect<? extends R> select) {
+        return compare(Comparator.GREATER_OR_EQUAL, select);
+    }
+
+    @Override
+    public final Condition in(R... records) {
+        return null;
+    }
+
+    @Override
+    public final Condition in(Select<? extends R> select) {
+        return null;
+    }
+
+    @Override
+    public final Condition notIn(R... records) {
+        return null;
+    }
+
+    @Override
+    public final Condition notIn(Select<? extends R> select) {
+        return null;
+    }
+
+    @Override
+    public final Condition isDistinctFrom(R record) {
+        return null;
+    }
+
+    @Override
+    public final Condition isDistinctFrom(Select<? extends R> select) {
+        return null;
+    }
+
+    @Override
+    public final Condition isDistinctFrom(QuantifiedSelect<? extends R> select) {
+        return null;
+    }
+
+    @Override
+    public final Condition isNotDistinctFrom(R record) {
+        return null;
+    }
+
+    @Override
+    public final Condition isNotDistinctFrom(Select<? extends R> select) {
+        return null;
+    }
+
+    @Override
+    public final Condition isNotDistinctFrom(QuantifiedSelect<? extends R> select) {
+        return null;
+    }
+
+    @Override
+    public final BetweenAndStep<R> between(R minValue) {
+        return null;
+    }
+
+    @Override
+    public final Condition between(R minValue, R maxValue) {
+        return null;
+    }
+
+    @Override
+    public final BetweenAndStep<R> between(Select<? extends R> minValue) {
+        return null;
+    }
+
+    @Override
+    public final Condition between(Select<? extends R> minValue, Select<? extends R> maxValue) {
+        return null;
+    }
+
+    @Override
+    public final BetweenAndStepR<R> betweenSymmetric(R minValue) {
+        return null;
+    }
+
+    @Override
+    public final Condition betweenSymmetric(R minValue, R maxValue) {
+        return null;
+    }
+
+    @Override
+    public final BetweenAndStepR<R> betweenSymmetric(Select<? extends R> minValue) {
+        return null;
+    }
+
+    @Override
+    public final Condition betweenSymmetric(Select<? extends R> minValue, Select<? extends R> maxValue) {
+        return null;
+    }
+
+    @Override
+    public final BetweenAndStepR<R> notBetween(R minValue) {
+        return null;
+    }
+
+    @Override
+    public final Condition notBetween(R minValue, R maxValue) {
+        return null;
+    }
+
+    @Override
+    public final BetweenAndStepR<R> notBetween(Select<? extends R> minValue) {
+        return null;
+    }
+
+    @Override
+    public final Condition notBetween(Select<? extends R> minValue, Select<? extends R> maxValue) {
+        return null;
+    }
+
+    @Override
+    public final BetweenAndStepR<R> notBetweenSymmetric(R minValue) {
+        return null;
+    }
+
+    @Override
+    public final Condition notBetweenSymmetric(R minValue, R maxValue) {
+        return null;
+    }
+
+    @Override
+    public final BetweenAndStepR<R> notBetweenSymmetric(Select<? extends R> minValue) {
+        return null;
+    }
+
+    @Override
+    public final Condition notBetweenSymmetric(Select<? extends R> minValue, Select<? extends R> maxValue) {
+        return null;
+    }
+
+    @Override
+    public final Condition isNull() {
+        return new RowIsNull(this, true);
+    }
+
+    @Override
+    public final Condition isNotNull() {
+        return new RowIsNull(this, false);
+    }
+
     /**
      * The {@link SelectImpl} current condition step
      * <p>