diff --git a/jOOQ/src/main/java/org/jooq/impl/CaseConditionStepImpl.java b/jOOQ/src/main/java/org/jooq/impl/CaseConditionStepImpl.java
index 1c863144cb..8073081a91 100644
--- a/jOOQ/src/main/java/org/jooq/impl/CaseConditionStepImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/CaseConditionStepImpl.java
@@ -61,11 +61,9 @@ import org.jooq.DataType;
 import org.jooq.Field;
 import org.jooq.Function2;
 // ...
-import org.jooq.QueryPart;
 import org.jooq.Record1;
 // ...
 import org.jooq.Select;
-// ...
 import org.jooq.impl.QOM.CaseSearched;
 import org.jooq.impl.QOM.UTuple2;
 import org.jooq.impl.QOM.UnmodifiableList;
@@ -226,7 +224,7 @@ implements
            .formatIndentStart();
 
         for (UTuple2<Condition, Field<T>> e : when) {
-            Condition c = e.$part1();
+            Condition c = e.$1();
 
 
 
@@ -245,7 +243,7 @@ implements
 
             ctx.formatSeparator()
                .visit(K_WHEN).sql(' ').visit(c).sql(' ')
-               .visit(K_THEN).sql(' ').visit(e.$part2());
+               .visit(K_THEN).sql(' ').visit(e.$2());
         }
 
         if (else_ != null)
@@ -268,7 +266,7 @@ implements
     public final Function2<? super UnmodifiableList<? extends UTuple2<Condition, Field<T>>>, ? super Field<T>, ? extends CaseSearched<T>> $constructor() {
         return (w, e) -> {
             CaseConditionStepImpl<T> r = new CaseConditionStepImpl<>(getDataType());
-            w.forEach(t -> r.when(t.$part1(), t.$part2()));
+            w.forEach(t -> r.when(t.$1(), t.$2()));
             r.else_(e);
             return r;
         };
@@ -293,20 +291,4 @@ implements
     public final CaseSearched<T> $arg2(Field<T> e) {
         return $constructor().apply($when(), e);
     }
-
-    @Override
-    public final <R> R $traverse(Traverser<?, R> traverser) {
-        return QOM.traverse(traverser, this, $when(), $else());
-    }
-
-    @Override
-    public final QueryPart $replace(Replacer replacer) {
-        return QOM.replace(
-            this,
-            $when(),
-            $else(),
-            (w, e) -> $constructor().apply(w, e),
-            replacer
-        );
-    }
 }
diff --git a/jOOQ/src/main/java/org/jooq/impl/CaseImpl.java b/jOOQ/src/main/java/org/jooq/impl/CaseImpl.java
index 762b2b85c0..186aedc7c1 100644
--- a/jOOQ/src/main/java/org/jooq/impl/CaseImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/CaseImpl.java
@@ -44,14 +44,16 @@ import org.jooq.Condition;
 import org.jooq.Field;
 import org.jooq.Record1;
 import org.jooq.Select;
+import org.jooq.impl.QOM.UTransient;
 
 /**
+ * A transient step in the construction of <code>CASE</code> statements.
+ *
  * @author Lukas Eder
  */
-final class CaseImpl implements Case {
+final class CaseImpl implements Case, UTransient {
 
-    CaseImpl() {
-    }
+    CaseImpl() {}
 
     @Override
     public final <V> CaseValueStep<V> value(V value) {
diff --git a/jOOQ/src/main/java/org/jooq/impl/CaseValueStepImpl.java b/jOOQ/src/main/java/org/jooq/impl/CaseValueStepImpl.java
index b9734c4645..d2715b5cf1 100644
--- a/jOOQ/src/main/java/org/jooq/impl/CaseValueStepImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/CaseValueStepImpl.java
@@ -45,11 +45,14 @@ import org.jooq.CaseWhenStep;
 import org.jooq.Field;
 import org.jooq.Record1;
 import org.jooq.Select;
+import org.jooq.impl.QOM.UTransient;
 
 /**
+ * A transient step in the construction of <code>CASE</code> statements.
+ *
  * @author Lukas Eder
  */
-final class CaseValueStepImpl<V> implements CaseValueStep<V> {
+final class CaseValueStepImpl<V> implements CaseValueStep<V>, UTransient {
 
     private final Field<V> value;
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java b/jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java
index 7829910b2e..efba407f3f 100644
--- a/jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java
@@ -47,30 +47,37 @@ import static org.jooq.impl.Keywords.K_THEN;
 import static org.jooq.impl.Keywords.K_TRUE;
 import static org.jooq.impl.Keywords.K_WHEN;
 import static org.jooq.impl.Names.NQ_CASE;
+import static org.jooq.impl.QOM.tuple;
 import static org.jooq.impl.Tools.BooleanDataKey.DATA_FORCE_CASE_ELSE_NULL;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
 
 import org.jooq.CaseConditionStep;
 import org.jooq.CaseWhenStep;
 import org.jooq.Context;
 import org.jooq.DataType;
 import org.jooq.Field;
+import org.jooq.Function3;
 // ...
-import org.jooq.impl.QOM.UNotYetImplemented;
+import org.jooq.impl.QOM.CaseSimple;
+import org.jooq.impl.QOM.UTuple2;
+import org.jooq.impl.QOM.UnmodifiableList;
 
 /**
  * @author Lukas Eder
  */
-final class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenStep<V, T>, UNotYetImplemented {
+final class CaseWhenStepImpl<V, T>
+extends
+    AbstractField<T>
+implements
+    CaseWhenStep<V, T>,
+    QOM.CaseSimple<V, T>
+{
 
-    private final Field<V>       value;
-    private final List<Field<V>> compareValues;
-    private final List<Field<T>> results;
-    private Field<T>             else_;
+    private final Field<V>                          value;
+    private final List<UTuple2<Field<V>, Field<T>>> when;
+    private Field<T>                                else_;
 
     CaseWhenStepImpl(Field<V> value, Field<V> compareValue, Field<T> result) {
         this(value, result.getDataType());
@@ -84,12 +91,11 @@ final class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenS
         mapFields(map);
     }
 
-    private CaseWhenStepImpl(Field<V> value, DataType<T> type) {
+    CaseWhenStepImpl(Field<V> value, DataType<T> type) {
         super(NQ_CASE, type);
 
         this.value = value;
-        this.compareValues = new ArrayList<>();
-        this.results = new ArrayList<>();
+        this.when = new QueryPartList<>();
     }
 
     @SuppressWarnings("unchecked")
@@ -100,6 +106,10 @@ final class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenS
             return map.entrySet().iterator().next().getValue().getDataType();
     }
 
+    // -------------------------------------------------------------------------
+    // XXX: QueryPart API
+    // -------------------------------------------------------------------------
+
     @Override
     public final Field<T> otherwise(T result) {
         return else_(result);
@@ -139,8 +149,7 @@ final class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenS
 
     @Override
     public final CaseWhenStep<V, T> when(Field<V> compareValue, Field<T> result) {
-        compareValues.add(compareValue);
-        results.add(result);
+        when.add(tuple(compareValue, result));
 
         return this;
     }
@@ -222,39 +231,38 @@ final class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenS
 
 
 
+
 
 
     private final void acceptSearched(Context<?> ctx) {
-        int size = compareValues.size();
 
-        CaseConditionStep<T> when = null;
-        for (int i = 0; i < size; i++)
-            if (when == null)
-                when = DSL.when(value.eq(compareValues.get(i)), results.get(i));
+        CaseConditionStep<T> w = null;
+        for (UTuple2<Field<V>, Field<T>> e : when)
+            if (w == null)
+                w = DSL.when(value.eq(e.$1()), e.$2());
             else
-                when = when.when(value.eq(compareValues.get(i)), results.get(i));
+                w = w.when(value.eq(e.$1()), e.$2());
 
-        if (when != null)
+        if (w != null)
             if (else_ != null)
-                ctx.visit(when.else_(else_));
+                ctx.visit(w.else_(else_));
             else
-                ctx.visit(when);
+                ctx.visit(w);
     }
 
     private final void acceptNative(Context<?> ctx) {
         ctx.visit(K_CASE);
 
-        int size = compareValues.size();
         ctx.sql(' ')
            .visit(value)
            .formatIndentStart();
 
-        for (int i = 0; i < size; i++)
+        for (UTuple2<Field<V>, Field<T>> e : when)
             ctx.formatSeparator()
                .visit(K_WHEN).sql(' ')
-               .visit(compareValues.get(i)).sql(' ')
+               .visit(e.$1()).sql(' ')
                .visit(K_THEN).sql(' ')
-               .visit(results.get(i));
+               .visit(e.$2());
 
         if (else_ != null)
             ctx.formatSeparator()
@@ -268,4 +276,48 @@ final class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenS
            .formatSeparator()
            .visit(K_END);
     }
+
+    // -------------------------------------------------------------------------
+    // XXX: Query Object Model
+    // -------------------------------------------------------------------------
+
+    @Override
+    public final Function3<? super Field<V>, ? super UnmodifiableList<? extends UTuple2<Field<V>, Field<T>>>, ? super Field<T>, ? extends CaseSimple<V, T>> $constructor() {
+        return (v, w, e) -> {
+            CaseWhenStepImpl<V, T> r = new CaseWhenStepImpl<>(v, getDataType());
+            w.forEach(t -> r.when(t.$1(), t.$2()));
+            r.else_(e);
+            return r;
+        };
+    }
+
+    @Override
+    public final Field<V> $arg1() {
+        return value;
+    }
+
+    @Override
+    public final CaseSimple<V, T> $arg1(Field<V> newArg1) {
+        return $constructor().apply(newArg1, $when(), $else());
+    }
+
+    @Override
+    public final UnmodifiableList<? extends UTuple2<Field<V>, Field<T>>> $arg2() {
+        return QOM.unmodifiable(when);
+    }
+
+    @Override
+    public final CaseSimple<V, T> $arg2(UnmodifiableList<? extends UTuple2<Field<V>, Field<T>>> w) {
+        return $constructor().apply($value(), w, $else());
+    }
+
+    @Override
+    public final Field<T> $arg3() {
+        return else_;
+    }
+
+    @Override
+    public final CaseSimple<V, T> $arg3(Field<T> e) {
+        return $constructor().apply($value(), $when(), e);
+    }
 }
diff --git a/jOOQ/src/main/java/org/jooq/impl/Patterns.java b/jOOQ/src/main/java/org/jooq/impl/Patterns.java
index a3e59ec2e7..5e88619685 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Patterns.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Patterns.java
@@ -1719,6 +1719,11 @@ package org.jooq.impl;
 
 
 
+
+
+
+
+
 
 
 
diff --git a/jOOQ/src/main/java/org/jooq/impl/QOM.java b/jOOQ/src/main/java/org/jooq/impl/QOM.java
index 5b09c78de0..eee1a79ec8 100644
--- a/jOOQ/src/main/java/org/jooq/impl/QOM.java
+++ b/jOOQ/src/main/java/org/jooq/impl/QOM.java
@@ -224,10 +224,10 @@ public final class QOM {
         permits
             UTupleImpl2
     {
-        @NotNull Q1 $part1();
-        @NotNull UTuple2<Q1, Q2> $part1(Q1 newPart1);
-        @NotNull Q2 $part2();
-        @NotNull UTuple2<Q1, Q2> $part2(Q2 newPart2);
+        @NotNull Q1 $1();
+        @NotNull UTuple2<Q1, Q2> $1(Q1 newPart1);
+        @NotNull Q2 $2();
+        @NotNull UTuple2<Q1, Q2> $2(Q2 newPart2);
     }
 
     /**
diff --git a/jOOQ/src/main/java/org/jooq/impl/UTupleImpl2.java b/jOOQ/src/main/java/org/jooq/impl/UTupleImpl2.java
index 5588f25be4..8f3de66bdc 100644
--- a/jOOQ/src/main/java/org/jooq/impl/UTupleImpl2.java
+++ b/jOOQ/src/main/java/org/jooq/impl/UTupleImpl2.java
@@ -37,6 +37,8 @@
  */
 package org.jooq.impl;
 
+import static org.jooq.impl.QOM.tuple;
+
 import org.jooq.Context;
 import org.jooq.QueryPart;
 // ...
@@ -80,37 +82,37 @@ implements
     // -------------------------------------------------------------------------
 
     @Override
-    public final Q1 $part1() {
+    public final Q1 $1() {
         return part1;
     }
 
     @Override
-    public final Q2 $part2() {
+    public final Q2 $2() {
         return part2;
     }
 
     @Override
-    public final UTuple2<Q1, Q2> $part1(Q1 newPart1) {
-        return new UTupleImpl2<>(newPart1, part2);
+    public final UTuple2<Q1, Q2> $1(Q1 newPart1) {
+        return tuple(newPart1, part2);
     }
 
     @Override
-    public final UTuple2<Q1, Q2> $part2(Q2 newPart2) {
-        return new UTupleImpl2<>(part1, newPart2);
+    public final UTuple2<Q1, Q2> $2(Q2 newPart2) {
+        return tuple(part1, newPart2);
     }
 
     @Override
     public final <R> R $traverse(Traverser<?, R> traverser) {
-        return QOM.traverse(traverser, this, $part1(), $part2());
+        return QOM.traverse(traverser, this, $1(), $2());
     }
 
     @Override
     public final QueryPart $replace(Replacer replacer) {
         return QOM.replace(
             this,
-            $part1(),
-            $part2(),
-            (p1, p2) -> new UTupleImpl2<>(p1, p2),
+            $1(),
+            $2(),
+            (p1, p2) -> tuple(p1, p2),
             replacer
         );
     }