From 25d902d7f6f4ce3e8dfd4db33a4bad89c62c7827 Mon Sep 17 00:00:00 2001
From: Lukas Eder <lukas.eder@gmail.com>
Date: Fri, 18 Nov 2022 11:35:13 +0100
Subject: [PATCH] [jOOQ/jOOQ#13593] transformPatternsCaseSearchedToCaseSimple

---
 .../src/main/java/org/jooq/conf/Settings.java | 47 +++++++++++++++++++
 .../src/main/java/org/jooq/impl/Patterns.java | 30 ++++++++++++
 jOOQ/src/main/java/org/jooq/impl/QOM.java     |  5 ++
 .../org/jooq/xsd/jooq-runtime-3.18.0.xsd      |  9 ++++
 4 files changed, 91 insertions(+)

diff --git a/jOOQ/src/main/java/org/jooq/conf/Settings.java b/jOOQ/src/main/java/org/jooq/conf/Settings.java
index 465550db59..557d5f8e5f 100644
--- a/jOOQ/src/main/java/org/jooq/conf/Settings.java
+++ b/jOOQ/src/main/java/org/jooq/conf/Settings.java
@@ -193,6 +193,8 @@ public class Settings
     @XmlElement(defaultValue = "true")
     protected Boolean transformPatternsMergeBetweenSymmetricPredicates = true;
     @XmlElement(defaultValue = "true")
+    protected Boolean transformPatternsCaseSearchedToCaseSimple = true;
+    @XmlElement(defaultValue = "true")
     protected Boolean transformPatternsCaseElseNull = true;
     @XmlElement(defaultValue = "true")
     protected Boolean transformPatternsUnreachableCaseClauses = true;
@@ -2432,6 +2434,35 @@ public class Settings
         this.transformPatternsMergeBetweenSymmetricPredicates = value;
     }
 
+    /**
+     * Transform a searched <code>CASE WHEN x = .. WHEN x = ..</code> to a simple <code>CASE x WHEN … WHEN …</code> expression.
+     * <p>
+     * When a searched <code>CASE</code> expression always compares the same column to a value, then it can be simplified, possibly
+     * unlocking further transformations that are available only to the simple <code>CASE</code> expression.
+     * <p>
+     * This feature is available in the commercial distribution only.
+     * 
+     * @return
+     *     possible object is
+     *     {@link Boolean }
+     *     
+     */
+    public Boolean isTransformPatternsCaseSearchedToCaseSimple() {
+        return transformPatternsCaseSearchedToCaseSimple;
+    }
+
+    /**
+     * Sets the value of the transformPatternsCaseSearchedToCaseSimple property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link Boolean }
+     *     
+     */
+    public void setTransformPatternsCaseSearchedToCaseSimple(Boolean value) {
+        this.transformPatternsCaseSearchedToCaseSimple = value;
+    }
+
     /**
      * Transform <code>CASE … ELSE NULL</code> removing the <code>ELSE</code> clause.
      * <p>
@@ -5933,6 +5964,11 @@ public class Settings
         return this;
     }
 
+    public Settings withTransformPatternsCaseSearchedToCaseSimple(Boolean value) {
+        setTransformPatternsCaseSearchedToCaseSimple(value);
+        return this;
+    }
+
     public Settings withTransformPatternsCaseElseNull(Boolean value) {
         setTransformPatternsCaseElseNull(value);
         return this;
@@ -6999,6 +7035,7 @@ public class Settings
         builder.append("transformPatternsMergeInLists", transformPatternsMergeInLists);
         builder.append("transformPatternsMergeRangePredicates", transformPatternsMergeRangePredicates);
         builder.append("transformPatternsMergeBetweenSymmetricPredicates", transformPatternsMergeBetweenSymmetricPredicates);
+        builder.append("transformPatternsCaseSearchedToCaseSimple", transformPatternsCaseSearchedToCaseSimple);
         builder.append("transformPatternsCaseElseNull", transformPatternsCaseElseNull);
         builder.append("transformPatternsUnreachableCaseClauses", transformPatternsUnreachableCaseClauses);
         builder.append("transformPatternsUnreachableDecodeClauses", transformPatternsUnreachableDecodeClauses);
@@ -7790,6 +7827,15 @@ public class Settings
                 return false;
             }
         }
+        if (transformPatternsCaseSearchedToCaseSimple == null) {
+            if (other.transformPatternsCaseSearchedToCaseSimple!= null) {
+                return false;
+            }
+        } else {
+            if (!transformPatternsCaseSearchedToCaseSimple.equals(other.transformPatternsCaseSearchedToCaseSimple)) {
+                return false;
+            }
+        }
         if (transformPatternsCaseElseNull == null) {
             if (other.transformPatternsCaseElseNull!= null) {
                 return false;
@@ -9047,6 +9093,7 @@ public class Settings
         result = ((prime*result)+((transformPatternsMergeInLists == null)? 0 :transformPatternsMergeInLists.hashCode()));
         result = ((prime*result)+((transformPatternsMergeRangePredicates == null)? 0 :transformPatternsMergeRangePredicates.hashCode()));
         result = ((prime*result)+((transformPatternsMergeBetweenSymmetricPredicates == null)? 0 :transformPatternsMergeBetweenSymmetricPredicates.hashCode()));
+        result = ((prime*result)+((transformPatternsCaseSearchedToCaseSimple == null)? 0 :transformPatternsCaseSearchedToCaseSimple.hashCode()));
         result = ((prime*result)+((transformPatternsCaseElseNull == null)? 0 :transformPatternsCaseElseNull.hashCode()));
         result = ((prime*result)+((transformPatternsUnreachableCaseClauses == null)? 0 :transformPatternsUnreachableCaseClauses.hashCode()));
         result = ((prime*result)+((transformPatternsUnreachableDecodeClauses == null)? 0 :transformPatternsUnreachableDecodeClauses.hashCode()));
diff --git a/jOOQ/src/main/java/org/jooq/impl/Patterns.java b/jOOQ/src/main/java/org/jooq/impl/Patterns.java
index 17bf29cd5f..a62354f315 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Patterns.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Patterns.java
@@ -2462,6 +2462,36 @@ 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 626d547217..013431a81e 100644
--- a/jOOQ/src/main/java/org/jooq/impl/QOM.java
+++ b/jOOQ/src/main/java/org/jooq/impl/QOM.java
@@ -56,6 +56,7 @@ import java.util.UUID;
 import java.util.function.BiPredicate;
 import java.util.function.Function;
 import java.util.function.Predicate;
+import java.util.stream.Collector;
 
 // ...
 import org.jooq.Catalog;
@@ -289,6 +290,10 @@ public final class QOM {
         // TODO: These methods could return unmodifiable views instead, to avoid
         //       copying things around...
 
+        default <R> R $collect(Collector<Q, ?, R> collector) {
+            return stream().collect(collector);
+        }
+
         /**
          * Concatenate a collection to this UnmodifiableList, returning a new
          * UnmodifiableList from the combined data.
diff --git a/jOOQ/src/main/resources/org/jooq/xsd/jooq-runtime-3.18.0.xsd b/jOOQ/src/main/resources/org/jooq/xsd/jooq-runtime-3.18.0.xsd
index e891cffe3e..32cc474e59 100644
--- a/jOOQ/src/main/resources/org/jooq/xsd/jooq-runtime-3.18.0.xsd
+++ b/jOOQ/src/main/resources/org/jooq/xsd/jooq-runtime-3.18.0.xsd
@@ -646,6 +646,15 @@ To enable this feature, {@link #transformPatterns} must be enabled as well.
 This feature is available in the commercial distribution only.]]></jxb:javadoc></jxb:property></appinfo></annotation>
       </element>
       
+      <element name="transformPatternsCaseSearchedToCaseSimple" type="boolean" minOccurs="0" maxOccurs="1" default="true">
+        <annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Transform a searched <code>CASE WHEN x = .. WHEN x = ..</code> to a simple <code>CASE x WHEN .. WHEN ..</code> expression.
+<p>
+When a searched <code>CASE</code> expression always compares the same column to a value, then it can be simplified, possibly
+unlocking further transformations that are available only to the simple <code>CASE</code> expression.
+<p>
+This feature is available in the commercial distribution only.]]></jxb:javadoc></jxb:property></appinfo></annotation>
+      </element>
+      
       <element name="transformPatternsCaseElseNull" type="boolean" minOccurs="0" maxOccurs="1" default="true">
         <annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Transform <code>CASE .. ELSE NULL</code> removing the <code>ELSE</code> clause.
 <p>