From e99d864b85f5bb86f4bebfc1b3f2d8d0f09fd482 Mon Sep 17 00:00:00 2001
From: Lukas Eder <lukas.eder@gmail.com>
Date: Fri, 18 Nov 2022 13:59:59 +0100
Subject: [PATCH] [jOOQ/jOOQ#13593] transformPatternsNotAnd and
 transformPatternsNotOr

---
 .../src/main/java/org/jooq/conf/Settings.java | 96 +++++++++++++++++++
 .../src/main/java/org/jooq/impl/Patterns.java | 37 +++++++
 .../org/jooq/xsd/jooq-runtime-3.18.0.xsd      | 20 ++++
 3 files changed, 153 insertions(+)

diff --git a/jOOQ/src/main/java/org/jooq/conf/Settings.java b/jOOQ/src/main/java/org/jooq/conf/Settings.java
index 557d5f8e5f..ad3fdbd687 100644
--- a/jOOQ/src/main/java/org/jooq/conf/Settings.java
+++ b/jOOQ/src/main/java/org/jooq/conf/Settings.java
@@ -163,6 +163,10 @@ public class Settings
     @XmlElement(defaultValue = "true")
     protected Boolean transformPatternsTrim = true;
     @XmlElement(defaultValue = "true")
+    protected Boolean transformPatternsNotAnd = true;
+    @XmlElement(defaultValue = "true")
+    protected Boolean transformPatternsNotOr = true;
+    @XmlElement(defaultValue = "true")
     protected Boolean transformPatternsNotNot = true;
     @XmlElement(defaultValue = "true")
     protected Boolean transformPatternsNotComparison = true;
@@ -1987,6 +1991,66 @@ public class Settings
         this.transformPatternsTrim = value;
     }
 
+    /**
+     * Transform <code>NOT(p AND q)</code> to <code>NOT(p) OR NOT(q)</code>.
+     * <p>
+     * This transformation normalises a predicate using De Morgan's rules.
+     * <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 isTransformPatternsNotAnd() {
+        return transformPatternsNotAnd;
+    }
+
+    /**
+     * Sets the value of the transformPatternsNotAnd property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link Boolean }
+     *     
+     */
+    public void setTransformPatternsNotAnd(Boolean value) {
+        this.transformPatternsNotAnd = value;
+    }
+
+    /**
+     * Transform <code>NOT(p OR q)</code> to <code>NOT(p) AND NOT(q)</code>.
+     * <p>
+     * This transformation normalises a predicate using De Morgan's rules.
+     * <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 isTransformPatternsNotOr() {
+        return transformPatternsNotOr;
+    }
+
+    /**
+     * Sets the value of the transformPatternsNotOr property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link Boolean }
+     *     
+     */
+    public void setTransformPatternsNotOr(Boolean value) {
+        this.transformPatternsNotOr = value;
+    }
+
     /**
      * Transform <code>NOT(NOT(x))</code> to <code>x</code>.
      * <p>
@@ -5889,6 +5953,16 @@ public class Settings
         return this;
     }
 
+    public Settings withTransformPatternsNotAnd(Boolean value) {
+        setTransformPatternsNotAnd(value);
+        return this;
+    }
+
+    public Settings withTransformPatternsNotOr(Boolean value) {
+        setTransformPatternsNotOr(value);
+        return this;
+    }
+
     public Settings withTransformPatternsNotNot(Boolean value) {
         setTransformPatternsNotNot(value);
         return this;
@@ -7020,6 +7094,8 @@ public class Settings
         builder.append("transformPatternsUnnecessaryExistsSubqueryClauses", transformPatternsUnnecessaryExistsSubqueryClauses);
         builder.append("transformPatternsCountConstant", transformPatternsCountConstant);
         builder.append("transformPatternsTrim", transformPatternsTrim);
+        builder.append("transformPatternsNotAnd", transformPatternsNotAnd);
+        builder.append("transformPatternsNotOr", transformPatternsNotOr);
         builder.append("transformPatternsNotNot", transformPatternsNotNot);
         builder.append("transformPatternsNotComparison", transformPatternsNotComparison);
         builder.append("transformPatternsNotNotDistinct", transformPatternsNotNotDistinct);
@@ -7692,6 +7768,24 @@ public class Settings
                 return false;
             }
         }
+        if (transformPatternsNotAnd == null) {
+            if (other.transformPatternsNotAnd!= null) {
+                return false;
+            }
+        } else {
+            if (!transformPatternsNotAnd.equals(other.transformPatternsNotAnd)) {
+                return false;
+            }
+        }
+        if (transformPatternsNotOr == null) {
+            if (other.transformPatternsNotOr!= null) {
+                return false;
+            }
+        } else {
+            if (!transformPatternsNotOr.equals(other.transformPatternsNotOr)) {
+                return false;
+            }
+        }
         if (transformPatternsNotNot == null) {
             if (other.transformPatternsNotNot!= null) {
                 return false;
@@ -9078,6 +9172,8 @@ public class Settings
         result = ((prime*result)+((transformPatternsUnnecessaryExistsSubqueryClauses == null)? 0 :transformPatternsUnnecessaryExistsSubqueryClauses.hashCode()));
         result = ((prime*result)+((transformPatternsCountConstant == null)? 0 :transformPatternsCountConstant.hashCode()));
         result = ((prime*result)+((transformPatternsTrim == null)? 0 :transformPatternsTrim.hashCode()));
+        result = ((prime*result)+((transformPatternsNotAnd == null)? 0 :transformPatternsNotAnd.hashCode()));
+        result = ((prime*result)+((transformPatternsNotOr == null)? 0 :transformPatternsNotOr.hashCode()));
         result = ((prime*result)+((transformPatternsNotNot == null)? 0 :transformPatternsNotNot.hashCode()));
         result = ((prime*result)+((transformPatternsNotComparison == null)? 0 :transformPatternsNotComparison.hashCode()));
         result = ((prime*result)+((transformPatternsNotNotDistinct == null)? 0 :transformPatternsNotNotDistinct.hashCode()));
diff --git a/jOOQ/src/main/java/org/jooq/impl/Patterns.java b/jOOQ/src/main/java/org/jooq/impl/Patterns.java
index 5bc9adfd58..d180b07a42 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Patterns.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Patterns.java
@@ -2490,6 +2490,43 @@ 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 32cc474e59..c26878d0e0 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
@@ -499,6 +499,26 @@ 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="transformPatternsNotAnd" type="boolean" minOccurs="0" maxOccurs="1" default="true">
+        <annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Transform <code>NOT(p AND q)</code> to <code>NOT(p) OR NOT(q)</code>.
+<p>
+This transformation normalises a predicate using De Morgan's rules.
+<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="transformPatternsNotOr" type="boolean" minOccurs="0" maxOccurs="1" default="true">
+        <annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Transform <code>NOT(p OR q)</code> to <code>NOT(p) AND NOT(q)</code>.
+<p>
+This transformation normalises a predicate using De Morgan's rules.
+<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="transformPatternsNotNot" type="boolean" minOccurs="0" maxOccurs="1" default="true">
         <annotation><appinfo><jxb:property><jxb:javadoc><![CDATA[Transform <code>NOT(NOT(x))</code> to <code>x</code>.
 <p>