diff --git a/jOOQ/src/main/java/org/jooq/Field.java b/jOOQ/src/main/java/org/jooq/Field.java
index 5583d9da01..8ecca7ed7b 100644
--- a/jOOQ/src/main/java/org/jooq/Field.java
+++ b/jOOQ/src/main/java/org/jooq/Field.java
@@ -1134,6 +1134,34 @@ public interface Field<T> extends NamedTypeProviderQueryPart<T>, AliasProvider<F
     @Support
     Condition equal(Select<?> query);
 
+    /**
+     * <code>this = value</code>
+     * <p>
+     * If <code>value == null</code>, then this will return a condition
+     * equivalent to {@link #isNull()} for convenience. SQL's ternary
+     * <code>NULL</code> logic is rarely of use for Java programmers.
+     *
+     * @see #equal(Object)
+     */
+    @Support
+    Condition eq(T value);
+
+    /**
+     * <code>this = field</code>
+     *
+     * @see #equal(Field)
+     */
+    @Support
+    Condition eq(Field<T> field);
+
+    /**
+     * <code>this = (Select<?> ...)</code>
+     *
+     * @see #equal(Select)
+     */
+    @Support
+    Condition eq(Select<?> query);
+
     /**
      * <code>this != value</code>
      * <p>
@@ -1156,6 +1184,34 @@ public interface Field<T> extends NamedTypeProviderQueryPart<T>, AliasProvider<F
     @Support
     Condition notEqual(Select<?> query);
 
+    /**
+     * <code>this != value</code>
+     * <p>
+     * If <code>value == null</code>, then this will return a condition
+     * equivalent to {@link #isNotNull()} for convenience. SQL's ternary
+     * <code>NULL</code> logic is rarely of use for Java programmers.
+     *
+     * @see #notEqual(Object)
+     */
+    @Support
+    Condition ne(T value);
+
+    /**
+     * <code>this != field</code>
+     *
+     * @see #notEqual(Field)
+     */
+    @Support
+    Condition ne(Field<T> field);
+
+    /**
+     * <code>this != (Select<?> ...)</code>
+     *
+     * @see #notEqual(Select)
+     */
+    @Support
+    Condition ne(Select<?> query);
+
     /**
      * <code>this < value</code>
      */
@@ -1174,6 +1230,30 @@ public interface Field<T> extends NamedTypeProviderQueryPart<T>, AliasProvider<F
     @Support
     Condition lessThan(Select<?> query);
 
+    /**
+     * <code>this < value</code>
+     *
+     * @see #lessThan(Object)
+     */
+    @Support
+    Condition lt(T value);
+
+    /**
+     * <code>this < field</code>
+     *
+     * @see #lessThan(Field)
+     */
+    @Support
+    Condition lt(Field<T> field);
+
+    /**
+     * <code>this < (Select<?> ...)</code>
+     *
+     * @see #lessThan(Select)
+     */
+    @Support
+    Condition lt(Select<?> query);
+
     /**
      * <code>this <= value</code>
      */
@@ -1192,6 +1272,30 @@ public interface Field<T> extends NamedTypeProviderQueryPart<T>, AliasProvider<F
     @Support
     Condition lessOrEqual(Select<?> query);
 
+    /**
+     * <code>this <= value</code>
+     *
+     * @see #lessOrEqual(Object)
+     */
+    @Support
+    Condition le(T value);
+
+    /**
+     * <code>this <= field</code>
+     *
+     * @see #lessOrEqual(Field)
+     */
+    @Support
+    Condition le(Field<T> field);
+
+    /**
+     * <code>this <= (Select<?> ...)</code>
+     *
+     * @see #lessOrEqual(Select)
+     */
+    @Support
+    Condition le(Select<?> query);
+
     /**
      * <code>this > value</code>
      */
@@ -1210,6 +1314,30 @@ public interface Field<T> extends NamedTypeProviderQueryPart<T>, AliasProvider<F
     @Support
     Condition greaterThan(Select<?> query);
 
+    /**
+     * <code>this > value</code>
+     *
+     * @see #greaterThan(Object)
+     */
+    @Support
+    Condition gt(T value);
+
+    /**
+     * <code>this > field</code>
+     *
+     * @see #greaterThan(Field)
+     */
+    @Support
+    Condition gt(Field<T> field);
+
+    /**
+     * <code>this > (Select<?> ...)</code>
+     *
+     * @see #greaterThan(Select)
+     */
+    @Support
+    Condition gt(Select<?> query);
+
     /**
      * <code>this >= value</code>
      */
@@ -1228,6 +1356,30 @@ public interface Field<T> extends NamedTypeProviderQueryPart<T>, AliasProvider<F
     @Support
     Condition greaterOrEqual(Select<?> query);
 
+    /**
+     * <code>this >= value</code>
+     *
+     * @see #greaterOrEqual(Object)
+     */
+    @Support
+    Condition ge(T value);
+
+    /**
+     * <code>this >= field</code>
+     *
+     * @see #greaterOrEqual(Field)
+     */
+    @Support
+    Condition ge(Field<T> field);
+
+    /**
+     * <code>this >= (Select<?> ...)</code>
+     *
+     * @see #greaterOrEqual(Select)
+     */
+    @Support
+    Condition ge(Select<?> query);
+
     /**
      * Create a condition to check this field against known string literals for
      * <code>true</code>
diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractField.java b/jOOQ/src/main/java/org/jooq/impl/AbstractField.java
index ce397079ff..4d41f4152d 100644
--- a/jOOQ/src/main/java/org/jooq/impl/AbstractField.java
+++ b/jOOQ/src/main/java/org/jooq/impl/AbstractField.java
@@ -558,6 +558,96 @@ abstract class AbstractField<T> extends AbstractNamedTypeProviderQueryPart<T> im
         return new BetweenCondition<T>(this, nullSafe(minValue), nullSafe(maxValue), true);
     }
 
+    @Override
+    public final Condition eq(T value) {
+        return equal(value);
+    }
+
+    @Override
+    public final Condition eq(Field<T> field) {
+        return equal(field);
+    }
+
+    @Override
+    public final Condition eq(Select<?> query) {
+        return equal(query);
+    }
+
+    @Override
+    public final Condition ne(T value) {
+        return notEqual(value);
+    }
+
+    @Override
+    public final Condition ne(Field<T> field) {
+        return notEqual(field);
+    }
+
+    @Override
+    public final Condition ne(Select<?> query) {
+        return notEqual(query);
+    }
+
+    @Override
+    public final Condition lt(T value) {
+        return lessThan(value);
+    }
+
+    @Override
+    public final Condition lt(Field<T> field) {
+        return lessThan(field);
+    }
+
+    @Override
+    public final Condition lt(Select<?> query) {
+        return lessThan(query);
+    }
+
+    @Override
+    public final Condition le(T value) {
+        return lessOrEqual(value);
+    }
+
+    @Override
+    public final Condition le(Field<T> field) {
+        return lessOrEqual(field);
+    }
+
+    @Override
+    public final Condition le(Select<?> query) {
+        return lessOrEqual(query);
+    }
+
+    @Override
+    public final Condition gt(T value) {
+        return greaterThan(value);
+    }
+
+    @Override
+    public final Condition gt(Field<T> field) {
+        return greaterThan(field);
+    }
+
+    @Override
+    public final Condition gt(Select<?> query) {
+        return greaterThan(query);
+    }
+
+    @Override
+    public final Condition ge(T value) {
+        return greaterOrEqual(value);
+    }
+
+    @Override
+    public final Condition ge(Field<T> field) {
+        return greaterOrEqual(field);
+    }
+
+    @Override
+    public final Condition ge(Select<?> query) {
+        return greaterOrEqual(query);
+    }
+
     @Override
     public final Condition equal(T value) {
         return equal(val(value, this));