From aa730390966832f9c7fa0fd51378c3495febfe6b Mon Sep 17 00:00:00 2001
From: Lukas Eder <lukas.eder@gmail.com>
Date: Thu, 17 Nov 2022 16:16:47 +0100
Subject: [PATCH] [jOOQ/jOOQ#13593] transformPatternsUnnecessaryInnerJoin

---
 .../src/main/java/org/jooq/conf/Settings.java | 48 +++++++++++++++++++
 .../src/main/java/org/jooq/impl/Patterns.java |  8 ++++
 .../org/jooq/xsd/jooq-runtime-3.18.0.xsd      | 10 ++++
 3 files changed, 66 insertions(+)

diff --git a/jOOQ/src/main/java/org/jooq/conf/Settings.java b/jOOQ/src/main/java/org/jooq/conf/Settings.java
index c4122ab325..465550db59 100644
--- a/jOOQ/src/main/java/org/jooq/conf/Settings.java
+++ b/jOOQ/src/main/java/org/jooq/conf/Settings.java
@@ -151,6 +151,8 @@ public class Settings
     @XmlElement(defaultValue = "true")
     protected Boolean transformPatternsUnnecessaryScalarSubquery = true;
     @XmlElement(defaultValue = "true")
+    protected Boolean transformPatternsUnnecessaryInnerJoin = true;
+    @XmlElement(defaultValue = "true")
     protected Boolean transformPatternsUnnecessaryGroupByExpressions = true;
     @XmlElement(defaultValue = "true")
     protected Boolean transformPatternsUnnecessaryOrderByExpressions = true;
@@ -1793,6 +1795,36 @@ public class Settings
         this.transformPatternsUnnecessaryScalarSubquery = value;
     }
 
+    /**
+     * Transform <code>SELECT * FROM t INNER JOIN u ON TRUE</code> to <code>SELECT * FROM t CROSS JOIN u</code>.
+     * <p>
+     * Some <code>INNER JOIN</code> expressions can be proven to be unnecessary.
+     * <p>
+     * To enable this feature, {@link #transformPatterns} must be enabled as well.
+     * <p>
+     * This feature is available in the commercial distribution only.
+     * 
+     * @return
+     *     possible object is
+     *     {@link Boolean }
+     *     
+     */
+    public Boolean isTransformPatternsUnnecessaryInnerJoin() {
+        return transformPatternsUnnecessaryInnerJoin;
+    }
+
+    /**
+     * Sets the value of the transformPatternsUnnecessaryInnerJoin property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link Boolean }
+     *     
+     */
+    public void setTransformPatternsUnnecessaryInnerJoin(Boolean value) {
+        this.transformPatternsUnnecessaryInnerJoin = value;
+    }
+
     /**
      * Transform <code>SELECT a, b FROM t GROUP BY a, a, b</code> to <code>SELECT a, b FROM t GROUP BY a, b</code>.
      * <p>
@@ -5796,6 +5828,11 @@ public class Settings
         return this;
     }
 
+    public Settings withTransformPatternsUnnecessaryInnerJoin(Boolean value) {
+        setTransformPatternsUnnecessaryInnerJoin(value);
+        return this;
+    }
+
     public Settings withTransformPatternsUnnecessaryGroupByExpressions(Boolean value) {
         setTransformPatternsUnnecessaryGroupByExpressions(value);
         return this;
@@ -6941,6 +6978,7 @@ public class Settings
         builder.append("transformPatternsLogging", transformPatternsLogging);
         builder.append("transformPatternsUnnecessaryDistinct", transformPatternsUnnecessaryDistinct);
         builder.append("transformPatternsUnnecessaryScalarSubquery", transformPatternsUnnecessaryScalarSubquery);
+        builder.append("transformPatternsUnnecessaryInnerJoin", transformPatternsUnnecessaryInnerJoin);
         builder.append("transformPatternsUnnecessaryGroupByExpressions", transformPatternsUnnecessaryGroupByExpressions);
         builder.append("transformPatternsUnnecessaryOrderByExpressions", transformPatternsUnnecessaryOrderByExpressions);
         builder.append("transformPatternsUnnecessaryExistsSubqueryClauses", transformPatternsUnnecessaryExistsSubqueryClauses);
@@ -7563,6 +7601,15 @@ public class Settings
                 return false;
             }
         }
+        if (transformPatternsUnnecessaryInnerJoin == null) {
+            if (other.transformPatternsUnnecessaryInnerJoin!= null) {
+                return false;
+            }
+        } else {
+            if (!transformPatternsUnnecessaryInnerJoin.equals(other.transformPatternsUnnecessaryInnerJoin)) {
+                return false;
+            }
+        }
         if (transformPatternsUnnecessaryGroupByExpressions == null) {
             if (other.transformPatternsUnnecessaryGroupByExpressions!= null) {
                 return false;
@@ -8979,6 +9026,7 @@ public class Settings
         result = ((prime*result)+((transformPatternsLogging == null)? 0 :transformPatternsLogging.hashCode()));
         result = ((prime*result)+((transformPatternsUnnecessaryDistinct == null)? 0 :transformPatternsUnnecessaryDistinct.hashCode()));
         result = ((prime*result)+((transformPatternsUnnecessaryScalarSubquery == null)? 0 :transformPatternsUnnecessaryScalarSubquery.hashCode()));
+        result = ((prime*result)+((transformPatternsUnnecessaryInnerJoin == null)? 0 :transformPatternsUnnecessaryInnerJoin.hashCode()));
         result = ((prime*result)+((transformPatternsUnnecessaryGroupByExpressions == null)? 0 :transformPatternsUnnecessaryGroupByExpressions.hashCode()));
         result = ((prime*result)+((transformPatternsUnnecessaryOrderByExpressions == null)? 0 :transformPatternsUnnecessaryOrderByExpressions.hashCode()));
         result = ((prime*result)+((transformPatternsUnnecessaryExistsSubqueryClauses == null)? 0 :transformPatternsUnnecessaryExistsSubqueryClauses.hashCode()));
diff --git a/jOOQ/src/main/java/org/jooq/impl/Patterns.java b/jOOQ/src/main/java/org/jooq/impl/Patterns.java
index 230dc87b61..fdc5b3ff90 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Patterns.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Patterns.java
@@ -2452,6 +2452,14 @@ package org.jooq.impl;
 
 
 
+
+
+
+
+
+
+
+
 
 
 
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 c61544d549..e891cffe3e 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
@@ -429,6 +429,16 @@ 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="transformPatternsUnnecessaryInnerJoin" type="boolean" minOccurs="0" maxOccurs="1" default="true">
+        <annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Transform <code>SELECT * FROM t INNER JOIN u ON TRUE</code> to <code>SELECT * FROM t CROSS JOIN u</code>.
+<p>
+Some <code>INNER JOIN</code> expressions can be proven to be unnecessary.
+<p>
+To enable this feature, {@link #transformPatterns} must be enabled as well.
+<p>
+This feature is available in the commercial distribution only.]]></jxb:javadoc></jxb:property></appinfo></annotation>
+      </element>
+      
       <element name="transformPatternsUnnecessaryGroupByExpressions" type="boolean" minOccurs="0" maxOccurs="1" default="true">
         <annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Transform <code>SELECT a, b FROM t GROUP BY a, a, b</code> to <code>SELECT a, b FROM t GROUP BY a, b</code>.
 <p>