tests #775

removed some not flags from some classes

Author: wumpz

src/main/java/net/sf/jsqlparser/expression/BinaryExpression.java

@@ -15,10 +15,8 @@ public abstract class BinaryExpression extends ASTNodeAccessImpl implements Expr
 
     private Expression leftExpression;
     private Expression rightExpression;
-    private boolean not = false;
-    
-    
-    
+//    private boolean not = false;
+
     public BinaryExpression() {
     }
 
@@ -38,23 +36,23 @@ public void setRightExpression(Expression expression) {
         rightExpression = expression;
     }
 
-    public void setNot() {
-        not = true;
-    }
-    
-    public void removeNot() {
-        not = false;
-    }
- 
-    public boolean isNot() {
-        return not;
-    }
-
+//    public void setNot() {
+//        not = true;
+//    }
+//    
+//    public void removeNot() {
+//        not = false;
+//    }
+// 
+//    public boolean isNot() {
+//        return not;
+//    }
     @Override
     public String toString() {
-        return (not ? "NOT " : "") + getLeftExpression() + " " + getStringExpression() + " " + getRightExpression();
+        return //(not ? "NOT " : "") + 
+                getLeftExpression() + " " + getStringExpression() + " " + getRightExpression();
     }
 
     public abstract String getStringExpression();
-    
+
 }

src/main/java/net/sf/jsqlparser/expression/operators/relational/LikeExpression.java

@@ -14,18 +14,18 @@
 
 public class LikeExpression extends BinaryExpression {
 
-    //private boolean not = false;
+    private boolean not = false;
     private String escape = null;
     private boolean caseInsensitive = false;
 
-//    @Override
-//    public boolean isNot() {
-//        return not;
-//    }
-//
-//    public void setNot(boolean b) {
-//        not = b;
-//    }
+    public boolean isNot() {
+        return not;
+    }
+
+    public void setNot(boolean b) {
+        not = b;
+    }
+
     @Override
     public void accept(ExpressionVisitor expressionVisitor) {
         expressionVisitor.visit(this);
@@ -38,7 +38,7 @@ public String getStringExpression() {
 
     @Override
     public String toString() {
-        String retval = super.toString();
+        String retval = getLeftExpression() + " " + (not ? "NOT " : "") + getStringExpression() + " " + getRightExpression();
         if (escape != null) {
             retval += " ESCAPE " + "'" + escape + "'";
         }

src/main/java/net/sf/jsqlparser/expression/operators/relational/OldOracleJoinBinaryExpression.java

@@ -28,8 +28,8 @@ public void setOldOracleJoinSyntax(int oldOracleJoinSyntax) {
 
     @Override
     public String toString() {
-        return (isNot() ? "NOT " : "")
-                + (oraclePriorPosition == ORACLE_PRIOR_START ? "PRIOR " : "")
+        return //(isNot() ? "NOT " : "")
+                (oraclePriorPosition == ORACLE_PRIOR_START ? "PRIOR " : "")
                 + getLeftExpression()
                 + (oldOracleJoinSyntax == ORACLE_JOIN_RIGHT ? "(+)" : "") + " "
                 + getStringExpression() + " "

src/main/java/net/sf/jsqlparser/util/cnfexpression/CNFConverter.java

@@ -14,10 +14,8 @@
 import java.util.List;
 import java.util.Queue;
 import java.util.Stack;
-import net.sf.jsqlparser.expression.BinaryExpression;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.NotExpression;
-import net.sf.jsqlparser.expression.operators.relational.LikeExpression;
 
 public class CNFConverter {
 
@@ -55,9 +53,8 @@ public static Expression convertToCNF(Expression expr) {
     }
 
     /**
-     * this method takes an expression tree and converts that into
-     * a CNF form. Notice the 5 steps shown above will turn into
-     * 5 different methods. For the sake of testing, I set them public.
+     * this method takes an expression tree and converts that into a CNF form. Notice the 5 steps
+     * shown above will turn into 5 different methods. For the sake of testing, I set them public.
      * return the converted expression.
      *
      * @param express the original expression tree.
@@ -82,9 +79,8 @@ private Expression convert(Expression express)
     }
 
     /**
-     * this is the first step that rebuild the expression tree.
-     * Use the standard specified in the above class. Traverse the
-     * original tree recursively and rebuild the tree from that.
+     * this is the first step that rebuild the expression tree. Use the standard specified in the
+     * above class. Traverse the original tree recursively and rebuild the tree from that.
      *
      * @param express the original expression tree.
      */
@@ -96,9 +92,8 @@ private void reorder(Expression express) {
     }
 
     /**
-     * This method is used to deal with pushing not operators down.
-     * Since it needs an extra parameter, I will create a new
-     * method to handle this.
+     * This method is used to deal with pushing not operators down. Since it needs an extra
+     * parameter, I will create a new method to handle this.
      */
     private void pushNotDown() {
         /* set the two temp parameters to their staring point. */
@@ -114,15 +109,12 @@ private void pushNotDown() {
     }
 
     /**
-     * This method is the helper function to push not operators down.
-     * traverse the tree thoroughly, when we meet the not operator.
-     * We only need to consider these three operators: MultiAndOperator,
-     * MultiOrOperator, NotOperator. Handle them in a seperate way.
-     * when we finish the traverse, the expression tree will have
-     * all the not operators pushed as downwards as they could.
-     * In the method, I use two global variables: temp1 and temp2
-     * to traverse the expression tree. Notice that temp2 will always
-     * be the parent of temp1.
+     * This method is the helper function to push not operators down. traverse the tree thoroughly,
+     * when we meet the not operator. We only need to consider these three operators:
+     * MultiAndOperator, MultiOrOperator, NotOperator. Handle them in a seperate way. when we finish
+     * the traverse, the expression tree will have all the not operators pushed as downwards as they
+     * could. In the method, I use two global variables: temp1 and temp2 to traverse the expression
+     * tree. Notice that temp2 will always be the parent of temp1.
      *
      * @param index the index of the children appeared in parents array.
      */
@@ -149,9 +141,8 @@ private void pushNot(int index) {
     }
 
     /**
-     * This function mainly deals with pushing not operators down.
-     * check the child. If it is not a logic operator(and or or).
-     * stop at that point. Else use De Morgan law to push not downwards.
+     * This function mainly deals with pushing not operators down. check the child. If it is not a
+     * logic operator(and or or). stop at that point. Else use De Morgan law to push not downwards.
      *
      * @param index the index of the children appeared in parents array.
      */
@@ -176,15 +167,15 @@ private void handleNot(int index) {
              * and connect that operator with the parent and return. */
             if (!(child instanceof MultiAndExpression)
                     && !(child instanceof MultiOrExpression)) {
-                if (child instanceof LikeExpression) {
-                    ((LikeExpression) child).setNot();
-                } else if (child instanceof BinaryExpression) {
-                    ((BinaryExpression) child).setNot();
-                } else {
-                    child = new NotExpression(child);
-                }
+//                if (child instanceof LikeExpression) {
+//                    ((LikeExpression) child).setNot();
+//                } else if (child instanceof BinaryExpression) {
+//                    ((BinaryExpression) child).setNot();
+//                } else {
+                child = new NotExpression(child);
+//                }
                 ((MultipleExpression) temp2).setChild(index, child);
-                return;
+//                return;
             } else if (child instanceof MultiAndExpression) {
                 MultiAndExpression and = (MultiAndExpression) child;
                 List<Expression> list = new ArrayList<Expression>();
@@ -214,11 +205,10 @@ private void handleNot(int index) {
     }
 
     /**
-     * This method serves as dealing with the third step. It is used
-     * to put all the adjacent same multi operators together. BFS the
-     * tree and do it node by node. In the end we will get the tree
-     * where all the same multi operators store in the same odd level
-     * of the tree or in the same even level of the tree.
+     * This method serves as dealing with the third step. It is used to put all the adjacent same
+     * multi operators together. BFS the tree and do it node by node. In the end we will get the
+     * tree where all the same multi operators store in the same odd level of the tree or in the
+     * same even level of the tree.
      */
     private void gather() {
         Queue<Expression> queue = new LinkedList<Expression>();
@@ -296,11 +286,10 @@ private void gather() {
     }
 
     /**
-     * First, BFS the tree and gather all the or operators and their parents
-     * into a stack. Next, pop them out and push the and operators under the
-     * or operators upwards(if there are). Do this level by level, which means
-     * during each level we will call the gather() method to make the tree uniform.
-     * When we move out of the stack. The expression tree shall be in CNF form.
+     * First, BFS the tree and gather all the or operators and their parents into a stack. Next, pop
+     * them out and push the and operators under the or operators upwards(if there are). Do this
+     * level by level, which means during each level we will call the gather() method to make the
+     * tree uniform. When we move out of the stack. The expression tree shall be in CNF form.
      */
     private void pushAndUp() {
         Queue<Mule> queue = new LinkedList<Mule>();
@@ -346,16 +335,13 @@ private void pushAndUp() {
     }
 
     /**
-     * This helper function is used to deal with pushing and up:
-     * generally, pop the top element out of the stack,
-     * use BFS to traverse the tree and push and up.
-     * It will case the expression tree to have the and as the new
-     * root and multiple or as the children. Push them on the queue
-     * and repeat the same process until the newly generated or
-     * operator does not have any and operators in it(which means no
-     * elements will be added into the queue). when one level is
-     * finished, regroup the tree. Do this until the stack is empty,
-     * the result will be the expression in CNF form.
+     * This helper function is used to deal with pushing and up: generally, pop the top element out
+     * of the stack, use BFS to traverse the tree and push and up. It will case the expression tree
+     * to have the and as the new root and multiple or as the children. Push them on the queue and
+     * repeat the same process until the newly generated or operator does not have any and operators
+     * in it(which means no elements will be added into the queue). when one level is finished,
+     * regroup the tree. Do this until the stack is empty, the result will be the expression in CNF
+     * form.
      *
      * @param stack the stack stores a list of combined data.
      */
@@ -412,13 +398,11 @@ private void pushAnd(Stack<Mule> stack) {
     }
 
     /**
-     * This is the final step of the CNF conversion: now we have the
-     * Expression tree that has one multiple and expression with a list
-     * of multiple or expression as the child. So we need to convert the
-     * multiple expression back to the binary counterparts. Note the
-     * converted tree is left inclined. Also I attach a parenthesis node
-     * before the or expression that is attached to the and expression
-     * to make the generated result resembles the CNF form.
+     * This is the final step of the CNF conversion: now we have the Expression tree that has one
+     * multiple and expression with a list of multiple or expression as the child. So we need to
+     * convert the multiple expression back to the binary counterparts. Note the converted tree is
+     * left inclined. Also I attach a parenthesis node before the or expression that is attached to
+     * the and expression to make the generated result resembles the CNF form.
      */
     private void changeBack() {
         if (!(root instanceof MultiAndExpression)) {

src/main/java/net/sf/jsqlparser/util/cnfexpression/CloneHelper.java

@@ -11,7 +11,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import net.sf.jsqlparser.expression.BinaryExpression;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.NotExpression;
 import net.sf.jsqlparser.expression.Parenthesis;
@@ -35,9 +34,9 @@ public Expression modify(Expression express) {
             list.add(modify(and.getLeftExpression()));
             list.add(modify(and.getRightExpression()));
             MultiAndExpression result = new MultiAndExpression(list);
-            if (and.isNot()) {
-                return new NotExpression(result);
-            }
+//            if (and.isNot()) {
+//                return new NotExpression(result);
+//            }
             return result;
         }
         if (express instanceof OrExpression) {
@@ -46,18 +45,18 @@ public Expression modify(Expression express) {
             list.add(modify(or.getLeftExpression()));
             list.add(modify(or.getRightExpression()));
             MultiOrExpression result = new MultiOrExpression(list);
-            if (or.isNot()) {
-                return new NotExpression(result);
-            }
+//            if (or.isNot()) {
+//                return new NotExpression(result);
+//            }
             return result;
         }
-        if (express instanceof BinaryExpression) {
-            BinaryExpression binary = (BinaryExpression) express;
-            if (binary.isNot()) {
-                binary.removeNot();
-                return new NotExpression(modify(binary));
-            }
-        }
+//        if (express instanceof BinaryExpression) {
+//            BinaryExpression binary = (BinaryExpression) express;
+//            if (binary.isNot()) {
+//                binary.removeNot();
+//                return new NotExpression(modify(binary));
+//            }
+//        }
         return express;
     }
 

src/main/java/net/sf/jsqlparser/util/deparser/ExpressionDeParser.java

@@ -185,9 +185,9 @@ public void visit(BitwiseLeftShift expr) {
     }
 
     public void visitOldOracleJoinBinaryExpression(OldOracleJoinBinaryExpression expression, String operator) {
-        if (expression.isNot()) {
-            buffer.append(NOT);
-        }
+//        if (expression.isNot()) {
+//            buffer.append(NOT);
+//        }
         expression.getLeftExpression().accept(this);
         if (expression.getOldOracleJoinSyntax() == EqualsTo.ORACLE_JOIN_RIGHT) {
             buffer.append("(+)");
@@ -263,7 +263,9 @@ public void visit(JdbcParameter jdbcParameter) {
 
     @Override
     public void visit(LikeExpression likeExpression) {
-        visitBinaryExpression(likeExpression, likeExpression.isCaseInsensitive() ? " ILIKE " : " LIKE ");
+        visitBinaryExpression(likeExpression,
+                (likeExpression.isNot() ? " NOT" : "")
+                + (likeExpression.isCaseInsensitive() ? " ILIKE " : " LIKE "));
         String escape = likeExpression.getEscape();
         if (escape != null) {
             buffer.append(" ESCAPE '").append(escape).append('\'');
@@ -344,9 +346,9 @@ public void visit(Subtraction subtraction) {
     }
 
     protected void visitBinaryExpression(BinaryExpression binaryExpression, String operator) {
-        if (binaryExpression.isNot()) {
-            buffer.append(NOT);
-        }
+//        if (binaryExpression.isNot()) {
+//            buffer.append(NOT);
+//        }
         binaryExpression.getLeftExpression().accept(this);
         buffer.append(operator);
         binaryExpression.getRightExpression().accept(this);

src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt

@@ -2312,7 +2312,7 @@ Expression LikeExpression() #LikeExpression:
 }
 {
     leftExpression=SimpleExpression()
-    [<K_NOT> { result.setNot(); } ] ( <K_LIKE> | <K_ILIKE> { result.setCaseInsensitive(true); } ) rightExpression=SimpleExpression()
+    [<K_NOT> { result.setNot(true); } ] ( <K_LIKE> | <K_ILIKE> { result.setCaseInsensitive(true); } ) rightExpression=SimpleExpression()
     [<K_ESCAPE> token=<S_CHAR_LITERAL> { result.setEscape((new StringValue(token.image)).getValue()); }]
     {
         result.setLeftExpression(leftExpression);

src/test/java/net/sf/jsqlparser/expression/operators/relational/LikeExpressionTest.java

@@ -9,7 +9,8 @@
  */
 package net.sf.jsqlparser.expression.operators.relational;
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 import org.junit.Test;
 
 /**
@@ -22,7 +23,7 @@ public class LikeExpressionTest {
     public void testLikeNotIssue660() {
         LikeExpression instance = new LikeExpression();
         assertFalse(instance.isNot());
-        instance.setNot();
+        instance.setNot(true);
         assertTrue(instance.isNot());
     }
 }