fix(parser): parse Oracle outer join operator (+) after LIKE / SIMILAR TO operands (#2598)

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

@@ -8672,6 +8672,15 @@ Expression LikeExpression(Expression leftExpression) #LikeExpression:
     ) { result.setLikeKeyWord( LikeExpression.KeyWord.from(token.image)); }
     [ LOOKAHEAD(2) <K_BINARY> {result.setUseBinary(true); } ]
     rightExpression=SimpleExpression()
+    [
+        LOOKAHEAD("(" "+" ")")
+        "(" "+" ")"
+        {
+            if (rightExpression instanceof Column) {
+                ((Column) rightExpression).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT);
+            }
+        }
+    ]
     [ LOOKAHEAD(2) <K_ESCAPE>
         (
             LOOKAHEAD(2)  token = <S_CHAR_LITERAL> { result.setEscape( new StringValue( token.image ) ); }
@@ -8696,6 +8705,15 @@ Expression SimilarToExpression(Expression leftExpression) #SimilarToExpression:
     [<K_NOT> { result.setNot(true); } ]
     <K_SIMILAR> <K_TO>
     rightExpression=SimpleExpression()
+    [
+        LOOKAHEAD("(" "+" ")")
+        "(" "+" ")"
+        {
+            if (rightExpression instanceof Column) {
+                ((Column) rightExpression).setOldOracleJoinSyntax(EqualsTo.ORACLE_JOIN_RIGHT);
+            }
+        }
+    ]
     [ LOOKAHEAD(2) <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

@@ -12,9 +12,13 @@
 import static org.junit.jupiter.api.Assertions.*;
 
 import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.expression.BinaryExpression;
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.expression.StringValue;
+import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
+import net.sf.jsqlparser.schema.Column;
+import net.sf.jsqlparser.statement.select.PlainSelect;
 import net.sf.jsqlparser.test.TestUtils;
 import org.junit.jupiter.api.Test;
 
@@ -98,4 +102,87 @@ public void testMatchRegexp() throws JSQLParserException {
         TestUtils.assertSqlCanBeParsedAndDeparsed(
                 "select * from dual where v NOT MATCH_REGEXP 'keyword1 keyword2'", true);
     }
+
+    @Test
+    public void testLikeWithOldOracleJoinSyntaxOnRightOperand() throws JSQLParserException {
+        String sqlStr = "SELECT * FROM table1 t1, table2 t2 WHERE t1.col1 LIKE t2.col2(+)";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        LikeExpression like = (LikeExpression) select.getWhere();
+
+        assertEquals(EqualsTo.ORACLE_JOIN_RIGHT,
+                ((Column) like.getRightExpression()).getOldOracleJoinSyntax());
+        assertEquals(EqualsTo.NO_ORACLE_JOIN,
+                ((Column) like.getLeftExpression()).getOldOracleJoinSyntax());
+    }
+
+    @Test
+    public void testNotLikeWithOldOracleJoinSyntaxOnRightOperand() throws JSQLParserException {
+        TestUtils.assertSqlCanBeParsedAndDeparsed(
+                "SELECT * FROM table1 t1, table2 t2 WHERE t1.col1 NOT LIKE t2.col2(+)", true);
+    }
+
+    @Test
+    public void testSimilarToWithOldOracleJoinSyntaxOnRightOperand() throws JSQLParserException {
+        String sqlStr = "SELECT * FROM table1 t1, table2 t2 WHERE t1.col1 SIMILAR TO t2.col2(+)";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        BinaryExpression similarTo = (BinaryExpression) select.getWhere();
+
+        assertEquals(EqualsTo.ORACLE_JOIN_RIGHT,
+                ((Column) similarTo.getRightExpression()).getOldOracleJoinSyntax());
+    }
+
+    @Test
+    public void testSimilarToOnSeparateTokensWithOldOracleJoinSyntaxOnRightOperand()
+            throws JSQLParserException {
+        String sqlStr = "SELECT * FROM table1 t1, table2 t2 WHERE t1.col1 SIMILAR\nTO t2.col2(+)";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+
+        assertTrue(select.getWhere() instanceof SimilarToExpression);
+        assertEquals(EqualsTo.ORACLE_JOIN_RIGHT,
+                ((Column) ((SimilarToExpression) select.getWhere()).getRightExpression())
+                        .getOldOracleJoinSyntax());
+    }
+
+    @Test
+    public void testILikeWithOldOracleJoinSyntaxOnRightOperand() throws JSQLParserException {
+        String sqlStr = "SELECT * FROM table1 t1, table2 t2 WHERE t1.col1 ILIKE t2.col2(+)";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        LikeExpression like = (LikeExpression) select.getWhere();
+
+        assertEquals(LikeExpression.KeyWord.ILIKE, like.getLikeKeyWord());
+        assertEquals(EqualsTo.ORACLE_JOIN_RIGHT,
+                ((Column) like.getRightExpression()).getOldOracleJoinSyntax());
+    }
+
+    @Test
+    public void testLikeWithOldOracleJoinSyntaxInJoinOnClause() throws JSQLParserException {
+        String sqlStr =
+                "SELECT * FROM table1 t1 LEFT JOIN table2 t2 ON t1.a = t2.b AND t1.col1 LIKE t2.col2(+)";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        LikeExpression like = (LikeExpression) ((AndExpression) select.getJoins().get(0)
+                .getOnExpression()).getRightExpression();
+
+        assertEquals(EqualsTo.ORACLE_JOIN_RIGHT,
+                ((Column) like.getRightExpression()).getOldOracleJoinSyntax());
+    }
+
+    @Test
+    public void testSimilarToWithOldOracleJoinSyntaxOnRightOperandAndEscape()
+            throws JSQLParserException {
+        TestUtils.assertSqlCanBeParsedAndDeparsed(
+                "SELECT * FROM table1 t1, table2 t2 WHERE t1.col1 SIMILAR TO t2.col2(+) ESCAPE '\\'",
+                true);
+    }
+
+    @Test
+    public void testLikeWithOldOracleJoinSyntaxOnLeftOperand() throws JSQLParserException {
+        String sqlStr = "SELECT * FROM table1 t1, table2 t2 WHERE t1.col1(+) LIKE t2.col2";
+        PlainSelect select = (PlainSelect) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+        LikeExpression like = (LikeExpression) select.getWhere();
+
+        assertEquals(EqualsTo.ORACLE_JOIN_RIGHT,
+                ((Column) like.getLeftExpression()).getOldOracleJoinSyntax());
+        assertEquals(EqualsTo.NO_ORACLE_JOIN,
+                ((Column) like.getRightExpression()).getOldOracleJoinSyntax());
+    }
 }