Keep the operator spelling of LIKE in step with the model

- The `~~` spelling is now derived from the keyword and `NOT`, so
  `setNot` or `setLikeKeyWord` no longer leave a stale operator, and
  `PRIOR` and `BINARY` are printed with it. `!~~~` and `null` are
  rejected.
- A sign is also separated from an operand when either is `~`: DuckDB
  and PostgreSQL read `-~1` as one unknown operator.
- `**` is the `OP_POWER` token; the `MulChain` alternative was never
  reached.
- `visit(Exponentiation)` is a default method, so existing
  `ExpressionVisitor` implementations keep compiling.

Author: guizmaii

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

@@ -272,7 +272,10 @@ default void visit(Division division) {
 
     <S> T visit(IntegerDivision integerDivision, S context);
 
-    <S> T visit(Exponentiation exponentiation, S context);
+    default <S> T visit(Exponentiation exponentiation, S context) {
+        visitExpression(exponentiation.getLeftExpression(), context);
+        return visitExpression(exponentiation.getRightExpression(), context);
+    }
 
     default void visit(Exponentiation exponentiation) {
         this.visit(exponentiation, null);

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

@@ -60,10 +60,13 @@ public String toString() {
 
     /**
      * Whether the sign must be separated from an operand starting with {@code firstChar}: "- -1"
-     * must not become the line comment "--1", nor "~ ~a" the LIKE operator "~~".
+     * must not become the line comment "--1", nor "~ -a" or "~ ~a" a single operator such as "~-"
+     * or the LIKE operator "~~", as DuckDB and PostgreSQL read a run of signs containing {@code ~}.
      */
     public boolean needsSpaceBefore(char firstChar) {
-        return (sign == '-' || sign == '~') && firstChar == sign;
+        boolean signedOperand = firstChar == '+' || firstChar == '-' || firstChar == '~';
+        return sign == '-' && firstChar == '-' || sign == '~' && signedOperand
+                || firstChar == '~' && (sign == '+' || sign == '-');
     }
 
     private boolean needsSpaceBefore(String operand) {

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

@@ -18,7 +18,7 @@ public class LikeExpression extends BinaryExpression implements SupportsOldOracl
     private boolean not = false;
     private boolean useBinary = false;
     private Expression escapeExpression = null;
-    private String likeOperator = null;
+    private boolean useOperator = false;
     private KeyWord likeKeyWord = KeyWord.LIKE;
 
     public boolean isNot() {
@@ -49,23 +49,42 @@ public String getStringExpression() {
         return likeKeyWord.toString();
     }
 
-    /** DuckDB's and PostgreSQL's operator spelling, e.g. {@code !~~} for {@code NOT LIKE}. */
+    /**
+     * The operator spelling of this condition when it was written as one and has one, e.g.
+     * {@code !~~} for {@code NOT LIKE}; otherwise {@code null} and the keyword form is used.
+     */
     public String getLikeOperator() {
-        return likeOperator;
+        if (!useOperator) {
+            return null;
+        }
+        switch (likeKeyWord) {
+            case LIKE:
+                return not ? "!~~" : "~~";
+            case ILIKE:
+                return not ? "!~~*" : "~~*";
+            case GLOB:
+                return not ? null : "~~~";
+            default:
+                return null;
+        }
     }
 
     /**
-     * Sets the operator spelling and the matching keyword: {@code ~~} is {@code LIKE}, {@code ~~*}
-     * {@code ILIKE}, {@code ~~~} {@code GLOB}, and a leading {@code !} negates.
+     * Sets the keyword and {@code NOT} from DuckDB's and PostgreSQL's operator spelling: {@code ~~}
+     * is {@code LIKE}, {@code ~~*} {@code ILIKE}, {@code ~~~} {@code GLOB}, and a leading {@code !}
+     * negates the first two. The operator is printed while it matches the keyword and {@code NOT}.
      */
     public LikeExpression setLikeOperator(String likeOperator) {
-        boolean negated = likeOperator.startsWith("!");
-        String operator = negated ? likeOperator.substring(1) : likeOperator;
-        switch (operator) {
+        if (likeOperator == null) {
+            throw new IllegalArgumentException("The LIKE operator must not be null");
+        }
+        switch (likeOperator) {
             case "~~":
+            case "!~~":
                 likeKeyWord = KeyWord.LIKE;
                 break;
             case "~~*":
+            case "!~~*":
                 likeKeyWord = KeyWord.ILIKE;
                 break;
             case "~~~":
@@ -74,21 +93,20 @@ public LikeExpression setLikeOperator(String likeOperator) {
             default:
                 throw new IllegalArgumentException("Unknown LIKE operator: " + likeOperator);
         }
-        this.not = negated;
-        this.likeOperator = likeOperator;
+        this.not = likeOperator.startsWith("!");
+        this.useOperator = true;
         return this;
     }
 
     @Override
     public String toString() {
-        if (likeOperator != null) {
-            return getLeftExpression() + " " + likeOperator + " " + getRightExpression()
-                    + (escapeExpression != null ? " ESCAPE " + escapeExpression : "");
-        }
+        String likeOperator = getLikeOperator();
         String retval = (oraclePriorPosition == ORACLE_PRIOR_START ? "PRIOR " : "")
-                + getLeftExpression() + " " + (not ? "NOT " : "")
-                + (likeKeyWord == KeyWord.SIMILAR_TO ? "SIMILAR TO" : likeKeyWord) + " "
-                + (useBinary ? "BINARY " : "") + getRightExpression();
+                + getLeftExpression() + " "
+                + (likeOperator != null ? likeOperator
+                        : (not ? "NOT " : "")
+                                + (likeKeyWord == KeyWord.SIMILAR_TO ? "SIMILAR TO" : likeKeyWord))
+                + " " + (useBinary ? "BINARY " : "") + getRightExpression();
         if (escapeExpression != null) {
             retval += " ESCAPE " + escapeExpression;
         }

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

@@ -521,16 +521,6 @@ public <S> StringBuilder visit(JdbcParameter jdbcParameter, S context) {
 
     @Override
     public <S> StringBuilder visit(LikeExpression likeExpression, S context) {
-        if (likeExpression.getLikeOperator() != null) {
-            likeExpression.getLeftExpression().accept(this, context);
-            builder.append(" ").append(likeExpression.getLikeOperator()).append(" ");
-            likeExpression.getRightExpression().accept(this, context);
-            if (likeExpression.getEscape() != null) {
-                builder.append(" ESCAPE ");
-                likeExpression.getEscape().accept(this, context);
-            }
-            return builder;
-        }
         String keywordStr = likeExpression.getLikeKeyWord() == LikeExpression.KeyWord.SIMILAR_TO
                 ? " SIMILAR TO"
                 : likeExpression.getLikeKeyWord().toString();
@@ -541,10 +531,14 @@ public <S> StringBuilder visit(LikeExpression likeExpression, S context) {
         }
         likeExpression.getLeftExpression().accept(this, context);
         builder.append(" ");
-        if (likeExpression.isNot()) {
-            builder.append("NOT ");
+        if (likeExpression.getLikeOperator() != null) {
+            builder.append(likeExpression.getLikeOperator()).append(" ");
+        } else {
+            if (likeExpression.isNot()) {
+                builder.append("NOT ");
+            }
+            builder.append(keywordStr).append(" ");
         }
-        builder.append(keywordStr).append(" ");
         if (likeExpression.isUseBinary()) {
             builder.append("BINARY ");
         }

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

@@ -688,7 +688,7 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
                     || (op == OP_CONCAT && Dialect.POSTGRESQL.name()
                             .equals(getAsString(Feature.dialect))))          prec = 4;
             else if (op == OP_SLASH || op == OP_CARET || op == K_DIV)         prec = 6;
-            else if ("**".equals(t.image))                                     prec = 7;
+            else if (op == OP_POWER)                                          prec = 7;
             else if (op == S_HASH_OPERATOR)                                   prec = 5;
             else if (op == OP_CONCAT || op == OP_PIPE
                   || op == OP_LSHIFT || op == OP_RSHIFT)                      prec = 5;
@@ -727,7 +727,7 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
             else if (op == S_HASH_OPERATOR) { Intersects r = new Intersects(); r.setLeftExpression(left); r.setRightExpression(right); left = r; }
             else if (op == OP_CARET)  { net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor r = new net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor(); r.setLeftExpression(left); r.setRightExpression(right); left = r; }
             else if (op == K_DIV)     { IntegerDivision  r = new IntegerDivision();  r.setLeftExpression(left); r.setRightExpression(right); left = r; }
-            else if ("**".equals(t.image)) { left = new Exponentiation(left, right); }
+            else if (op == OP_POWER)  { left = new Exponentiation(left, right); }
             else if (op == OP_CONCAT) { Concat           r = new Concat();           r.setLeftExpression(left); r.setRightExpression(right); left = r; }
             else if (op == OP_PIPE)   { BitwiseOr        r = new BitwiseOr();        r.setLeftExpression(left); r.setRightExpression(right); left = r; }
             else if (op == OP_LSHIFT) { BitwiseLeftShift r = new BitwiseLeftShift(); r.setLeftExpression(left); r.setRightExpression(right); left = r; }
@@ -3134,6 +3134,7 @@ TOKEN : /* Operators */
 |   <OP_CONCAT: "||">
 |   <OP_PIPE: "|">
 |   <OP_CARET: "^">
+|   <OP_POWER: "**">
 |   <OP_SLASH: "/">
 |   <OP_LSHIFT: "<<">
 |   <OP_RSHIFT: ">>">
@@ -11395,36 +11396,24 @@ Expression MulChain():
     Expression right;
 }
 {
-    retval=PowerChain()
+    retval=PrimaryExpression()
     (
         LOOKAHEAD(2)
         (
-            "*"          right=PowerChain() {{ Multiplication r = new Multiplication(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
+            "*"          right=PrimaryExpression() {{ Multiplication r = new Multiplication(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
             |
-            <OP_SLASH>   right=PowerChain() {{ Division r = new Division(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
+            <OP_SLASH>   right=PrimaryExpression() {{ Division r = new Division(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
             |
-            "%"          right=PowerChain() {{ Modulo r = new Modulo(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
+            "%"          right=PrimaryExpression() {{ Modulo r = new Modulo(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
             |
-            <OP_CARET>   right=PowerChain() {{ net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor r = new net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
+            <OP_CARET>   right=PrimaryExpression() {{ net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor r = new net.sf.jsqlparser.expression.operators.arithmetic.BitwiseXor(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
             |
-            <K_DIV>      right=PowerChain() {{ IntegerDivision r = new IntegerDivision(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
+            <K_DIV>      right=PrimaryExpression() {{ IntegerDivision r = new IntegerDivision(); r.setLeftExpression(retval); r.setRightExpression(right); retval = r; }}
         )
     )*
     { return retval; }
 }
 
-/** DuckDB's exponentiation, above the multiplicative operators */
-Expression PowerChain():
-{
-    Expression retval;
-    Expression right;
-}
-{
-    retval=PrimaryExpression()
-    ( LOOKAHEAD(2) "**" right=PrimaryExpression() { retval = new Exponentiation(retval, right); } )*
-    { return retval; }
-}
-
 /** Additive/concat/bitwise — lower precedence */
 Expression AddChain():
 {

src/test/java/net/sf/jsqlparser/statement/select/DuckDBTest.java

@@ -913,6 +913,32 @@ void testChainedSigns() throws JSQLParserException {
         Assertions.assertEquals("- - -a", CCJSqlParserUtil.parseExpression("- - -a").toString());
     }
 
+    @Test
+    void testLikeOperatorFollowsTheModel() throws JSQLParserException {
+        net.sf.jsqlparser.expression.operators.relational.LikeExpression like =
+                (net.sf.jsqlparser.expression.operators.relational.LikeExpression) CCJSqlParserUtil
+                        .parseCondExpression("a ~~ 'x'");
+        like.setNot(true);
+        Assertions.assertEquals("a !~~ 'x'", like.toString());
+        like.setLikeKeyWord(
+                net.sf.jsqlparser.expression.operators.relational.LikeExpression.KeyWord.SIMILAR_TO);
+        Assertions.assertEquals("a NOT SIMILAR TO 'x'", like.toString());
+        Assertions.assertThrows(IllegalArgumentException.class, () -> like.setLikeOperator("!~~~"));
+        Assertions.assertThrows(IllegalArgumentException.class, () -> like.setLikeOperator(null));
+    }
+
+    @Test
+    void testMixedSignsStaySeparate() throws JSQLParserException {
+        for (String expression : new String[] {"- ~1", "~ -1", "~ - ~a", "- ~ -a", "+ ~a"}) {
+            String deparsed = CCJSqlParserUtil.parseExpression(expression).toString();
+            Assertions.assertEquals(expression.replace(" ", ""),
+                    deparsed.replace(" ", ""));
+            Assertions.assertFalse(deparsed.contains("-~") || deparsed.contains("~-")
+                    || deparsed.contains("~~") || deparsed.contains("+~"), deparsed);
+        }
+        TestUtils.assertSqlCanBeParsedAndDeparsed("SELECT - ~1, ~ -1, -+1", true);
+    }
+
     private static String tree(net.sf.jsqlparser.expression.Expression expression) {
         if (expression instanceof net.sf.jsqlparser.expression.BinaryExpression) {
             net.sf.jsqlparser.expression.BinaryExpression binary =