From 1557cfc73bec145940fa93e88ca94454bec38a6e Mon Sep 17 00:00:00 2001
From: lukaseder <lukas.eder@gmail.com>
Date: Thu, 10 Mar 2016 15:32:02 +0100
Subject: [PATCH] [#3691] Improve API to create CASE expressions with arbitrary
 numbers of arguments

---
 .../src/main/java/org/jooq/CaseValueStep.java | 19 ++++++++
 jOOQ/src/main/java/org/jooq/CaseWhenStep.java | 18 ++++++++
 .../java/org/jooq/impl/CaseValueStepImpl.java | 19 ++++++++
 .../java/org/jooq/impl/CaseWhenStepImpl.java  | 43 ++++++++++++++++++-
 4 files changed, 97 insertions(+), 2 deletions(-)

diff --git a/jOOQ/src/main/java/org/jooq/CaseValueStep.java b/jOOQ/src/main/java/org/jooq/CaseValueStep.java
index 166f7db2f6..eff7ab2b93 100644
--- a/jOOQ/src/main/java/org/jooq/CaseValueStep.java
+++ b/jOOQ/src/main/java/org/jooq/CaseValueStep.java
@@ -40,6 +40,8 @@
  */
 package org.jooq;
 
+import java.util.Map;
+
 /**
  * An intermediary step in creating a case statement of the type <code><pre>
  * CASE x WHEN 1 THEN 'one'
@@ -131,4 +133,21 @@ public interface CaseValueStep<V> {
      */
     @Support
     <T> CaseWhenStep<V, T> when(Field<V> compareValue, Select<? extends Record1<T>> result);
+
+    /**
+     * Create <code>WHEN .. THEN</code> expressions from a {@link Map}.
+     * <p>
+     * This will iterate over the map's entries to create individual
+     * <code>WHEN .. THEN</code> expressions for each map entry.
+     */
+    <T> CaseWhenStep<V, T> mapValues(Map<V, T> values);
+
+    /**
+     * Create <code>WHEN .. THEN</code> expressions from a {@link Map}.
+     * <p>
+     * This will iterate over the map's entries to create individual
+     * <code>WHEN .. THEN</code> expressions for each map entry.
+     */
+    <T> CaseWhenStep<V, T> mapFields(Map<? extends Field<V>, ? extends Field<T>> fields);
+
 }
diff --git a/jOOQ/src/main/java/org/jooq/CaseWhenStep.java b/jOOQ/src/main/java/org/jooq/CaseWhenStep.java
index 660e9ae1b9..4d0e69bb6e 100644
--- a/jOOQ/src/main/java/org/jooq/CaseWhenStep.java
+++ b/jOOQ/src/main/java/org/jooq/CaseWhenStep.java
@@ -40,6 +40,8 @@
  */
 package org.jooq;
 
+import java.util.Map;
+
 /**
  * The final step in creating a case statement of the type <code><pre>
  * CASE x WHEN 1 THEN 'one'
@@ -103,6 +105,22 @@ public interface CaseWhenStep<V, T> extends Field<T> {
     @Support
     CaseWhenStep<V, T> when(Field<V> compareValue, Field<T> result);
 
+    /**
+     * Create <code>WHEN .. THEN</code> expressions from a {@link Map}.
+     * <p>
+     * This will iterate over the map's entries to create individual
+     * <code>WHEN .. THEN</code> expressions for each map entry.
+     */
+    CaseWhenStep<V, T> mapValues(Map<V, T> values);
+
+    /**
+     * Create <code>WHEN .. THEN</code> expressions from a {@link Map}.
+     * <p>
+     * This will iterate over the map's entries to create individual
+     * <code>WHEN .. THEN</code> expressions for each map entry.
+     */
+    CaseWhenStep<V, T> mapFields(Map<? extends Field<V>, ? extends Field<T>> fields);
+
     /**
      * Add an else clause to the already constructed case statement
      *
diff --git a/jOOQ/src/main/java/org/jooq/impl/CaseValueStepImpl.java b/jOOQ/src/main/java/org/jooq/impl/CaseValueStepImpl.java
index c2dc3bc5d6..8028e4295d 100644
--- a/jOOQ/src/main/java/org/jooq/impl/CaseValueStepImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/CaseValueStepImpl.java
@@ -40,6 +40,10 @@
  */
 package org.jooq.impl;
 
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
 import org.jooq.CaseValueStep;
 import org.jooq.CaseWhenStep;
 import org.jooq.Field;
@@ -86,4 +90,19 @@ final class CaseValueStepImpl<V> implements CaseValueStep<V> {
     public final <T> CaseWhenStep<V, T> when(Field<V> compareValue, Select<? extends Record1<T>> result) {
         return when(compareValue, DSL.field(result));
     }
+
+    @Override
+    public final <T> CaseWhenStep<V, T> mapValues(Map<V, T> values) {
+        Map<Field<V>, Field<T>> fields = new LinkedHashMap<Field<V>, Field<T>>();
+
+        for (Entry<V, T> entry : values.entrySet())
+            fields.put(Tools.field(entry.getKey()), Tools.field(entry.getValue()));
+
+        return mapFields(fields);
+    }
+
+    @Override
+    public final <T> CaseWhenStep<V, T> mapFields(Map<? extends Field<V>, ? extends Field<T>> fields) {
+        return new CaseWhenStepImpl<V, T>(value, fields);
+    }
 }
diff --git a/jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java b/jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java
index 0953433fdb..11df6f94f5 100644
--- a/jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java
+++ b/jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java
@@ -41,12 +41,16 @@
 package org.jooq.impl;
 
 import java.util.ArrayList;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
 
 import org.jooq.CaseWhenStep;
 import org.jooq.Clause;
 import org.jooq.Configuration;
 import org.jooq.Context;
+import org.jooq.DataType;
 import org.jooq.Field;
 import org.jooq.QueryPart;
 
@@ -63,13 +67,33 @@ final class CaseWhenStepImpl<V, T> extends AbstractFunction<T> implements CaseWh
     private Field<T>             otherwise;
 
     CaseWhenStepImpl(Field<V> value, Field<V> compareValue, Field<T> result) {
-        super("case", result.getDataType());
+        this(value, result.getDataType());
+
+        when(compareValue, result);
+    }
+
+    CaseWhenStepImpl(Field<V> value, Map<? extends Field<V>, ? extends Field<T>> map) {
+        this(value, dataType(map));
+
+        for (Entry<? extends Field<V>, ? extends Field<T>> entry : map.entrySet())
+            when(entry.getKey(), entry.getValue());
+    }
+
+    private CaseWhenStepImpl(Field<V> value, DataType<T> type) {
+        super("case", type);
 
         this.value = value;
         this.compareValues = new ArrayList<Field<V>>();
         this.results = new ArrayList<Field<T>>();
+    }
 
-        when(compareValue, result);
+
+    @SuppressWarnings("unchecked")
+    private static final <T> DataType<T> dataType(Map<? extends Field<?>, ? extends Field<T>> map) {
+        if (map.isEmpty())
+            return (DataType<T>) SQLDataType.OTHER;
+        else
+            return map.entrySet().iterator().next().getValue().getDataType();
     }
 
     @Override
@@ -107,6 +131,21 @@ final class CaseWhenStepImpl<V, T> extends AbstractFunction<T> implements CaseWh
         return this;
     }
 
+    @Override
+    public final CaseWhenStep<V, T> mapValues(Map<V, T> values) {
+        Map<Field<V>, Field<T>> fields = new LinkedHashMap<Field<V>, Field<T>>();
+
+        for (Entry<V, T> entry : values.entrySet())
+            fields.put(Tools.field(entry.getKey()), Tools.field(entry.getValue()));
+
+        return mapFields(fields);
+    }
+
+    @Override
+    public final CaseWhenStep<V, T> mapFields(Map<? extends Field<V>, ? extends Field<T>> fields) {
+        return null;
+    }
+
     @Override
     final QueryPart getFunction0(Configuration configuration) {
         switch (configuration.dialect().family()) {