Merge pull request #183 from valdasraps/master

wumpz · wumpz · commit 5598bbd520ca · 2015-10-19T15:15:36.000+02:00
Oracle Hint support for SELECT statements.
diff --git a/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitor.java b/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitor.java
@@ -162,4 +162,7 @@ public interface ExpressionVisitor {
     void visit(MySQLGroupConcat groupConcat);
     
     void visit(RowConstructor rowConstructor);
+    
+    void visit(OracleHint hint);
+    
 }
diff --git a/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapter.java b/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapter.java
@@ -452,4 +452,10 @@ public void visit(RowConstructor rowConstructor) {
 	public void visit(HexValue hexValue) {
 		
 	}
+        
+    @Override
+    public void visit(OracleHint hint) {
+
+    }
+        
 }
diff --git a/src/main/java/net/sf/jsqlparser/expression/OracleHint.java b/src/main/java/net/sf/jsqlparser/expression/OracleHint.java
@@ -0,0 +1,93 @@
+/*
+ * #%L
+ * JSQLParser library
+ * %%
+ * Copyright (C) 2004 - 2013 JSQLParser
+ * %%
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as 
+ * published by the Free Software Foundation, either version 2.1 of the 
+ * License, or (at your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Lesser Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Lesser Public 
+ * License along with this program.  If not, see
+ * <http://www.gnu.org/licenses/lgpl-2.1.html>.
+ * #L%
+ */
+package net.sf.jsqlparser.expression;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Oracle Hint Expression
+ * @author valdo
+ */
+public class OracleHint implements Expression {
+
+    private static final Pattern SINGLE_LINE = Pattern.compile("--\\+ *([^ ].*[^ ])");
+    private static final Pattern MULTI_LINE = Pattern.compile("\\/\\*\\+ *([^ ].*[^ ]) *\\*+\\/", Pattern.MULTILINE | Pattern.DOTALL);
+    
+    public static boolean isHintMatch(String comment) {
+        return SINGLE_LINE.matcher(comment).find() || 
+               MULTI_LINE.matcher(comment).find();
+    }
+    
+    private String value;
+    private boolean singleLine = false;
+
+    public final void setComment(String comment) {
+        Matcher m;
+        {
+            m = SINGLE_LINE.matcher(comment);
+            if (m.find()) {
+                this.value = m.group(1);
+                this.singleLine = true;
+                return;
+            }
+        }
+        {
+            m = MULTI_LINE.matcher(comment);
+            if (m.find()) {
+                this.value = m.group(1);
+                this.singleLine = false;
+            }
+        }
+    }
+    
+    public String getValue() {
+        return value;
+    }
+
+    public void setValue(String value) {
+        this.value = value;
+    }
+
+    public boolean isSingleLine() {
+        return singleLine;
+    }
+
+    public void setSingleLine(boolean singleLine) {
+        this.singleLine = singleLine;
+    }
+    
+    @Override
+    public void accept(ExpressionVisitor visitor) {
+        visitor.visit(this);
+    }
+    
+    @Override
+    public String toString() {
+        if (singleLine) {
+            return "--+ " + value + "\n";
+        } else {
+            return "/*+ " + value + " */";
+        }
+    }
+    
+}
diff --git a/src/main/java/net/sf/jsqlparser/statement/select/PlainSelect.java b/src/main/java/net/sf/jsqlparser/statement/select/PlainSelect.java
@@ -29,6 +29,7 @@
 import java.util.Iterator;
 import java.util.List;
 import net.sf.jsqlparser.expression.OracleHierarchicalExpression;
+import net.sf.jsqlparser.expression.OracleHint;
 
 /**
  * The core of a "SELECT" statement (no UNION, no ORDER BY)
@@ -51,6 +52,7 @@ public class PlainSelect implements SelectBody {
     private First first;
     private Top top;
     private OracleHierarchicalExpression oracleHierarchical = null;
+    private OracleHint oracleHint = null;
     private boolean oracleSiblings = false;
     private boolean forUpdate = false;
     private Table forUpdateTable = null;
@@ -257,6 +259,14 @@ public void setForUpdateTable(Table forUpdateTable) {
         this.forUpdateTable = forUpdateTable;
     }
 
+    public OracleHint getOracleHint() {
+        return oracleHint;
+    }
+
+    public void setOracleHint(OracleHint oracleHint) {
+        this.oracleHint = oracleHint;
+    }
+
     @Override
     public String toString() {
         StringBuilder sql = new StringBuilder();
@@ -265,6 +275,10 @@ public String toString() {
         }
         sql.append("SELECT ");
         
+        if (oracleHint != null) {
+            sql.append(oracleHint).append(" ");
+        }
+
         if (skip != null) {
             sql.append(skip).append(" ");
         }
diff --git a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
@@ -633,4 +633,9 @@ public void visit(HexValue hexValue) {
     public void visit(Merge merge) {
         throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
     }
+    
+    @Override
+    public void visit(OracleHint hint) {
+    }
+    
 }
diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/ExpressionDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/ExpressionDeParser.java
@@ -569,4 +569,10 @@ public void visit(RowConstructor rowConstructor) {
         }
         buffer.append(")");
     }
+    
+    @Override
+    public void visit(OracleHint hint) {
+        buffer.append(hint.toString());
+    }
+    
 }
diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/SelectDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/SelectDeParser.java
@@ -57,6 +57,11 @@ public void visit(PlainSelect plainSelect) {
         }
         buffer.append("SELECT ");
         
+        OracleHint hint = plainSelect.getOracleHint();
+        if (hint != null) {
+            buffer.append(hint).append(" ");
+        }
+        
         Skip skip = plainSelect.getSkip();
         if (skip != null) {
             buffer.append(skip).append(" ");
diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
@@ -722,6 +722,8 @@ PlainSelect PlainSelect():
 {
     <K_SELECT>
 
+    { plainSelect.setOracleHint(getOracleHint()); }
+
     [skip = Skip() { plainSelect.setSkip(skip);	} ]
 
     [LOOKAHEAD(2) first = First() { plainSelect.setFirst(first); } ]
@@ -1397,6 +1399,23 @@ Skip Skip():
 	}
 }
 
+JAVACODE
+OracleHint getOracleHint() {
+  OracleHint hint = null;
+  Token tok = getToken(1);
+  // Retrieve first comment (if any) prior next token
+  if (tok.specialToken != null) {
+    tok = tok.specialToken;
+    while (tok.specialToken != null) tok = tok.specialToken;
+    // Check if it matches Hint pattern?
+    if (OracleHint.isHintMatch(tok.image)) {
+      hint = new OracleHint();
+      hint.setComment(tok.image);
+    }
+  }
+  return hint;
+}
+
 First First():
 {
 	First first = new First();
diff --git a/src/test/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapterTest.java b/src/test/java/net/sf/jsqlparser/expression/ExpressionVisitorAdapterTest.java
@@ -28,8 +28,11 @@
 import net.sf.jsqlparser.statement.select.Select;
 import org.junit.After;
 import org.junit.AfterClass;
+import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertEquals;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -102,4 +105,30 @@ public void visit(InExpression expr) {
         assertTrue(exprList.get(1) instanceof ItemsList);
         assertTrue(exprList.get(2) instanceof ItemsList);
     }
+    
+    @Test
+    public void testOracleHintExpressions() throws JSQLParserException {
+        testOracleHintExpression("select --+ MYHINT \n * from foo", "MYHINT", true);
+        testOracleHintExpression("select /*+ MYHINT */ * from foo", "MYHINT", false);
+    }
+
+    public static void testOracleHintExpression(String sql, String hint, boolean singleLine) throws JSQLParserException {
+        Select select = (Select) CCJSqlParserUtil.parse(sql);
+        PlainSelect plainSelect = (PlainSelect) select.getSelectBody();
+        final OracleHint[] holder = new OracleHint[1];
+        assertNotNull(plainSelect.getOracleHint());
+        plainSelect.getOracleHint().accept(new ExpressionVisitorAdapter() {
+
+            @Override
+            public void visit(OracleHint hint) {
+                super.visit(hint);
+                holder[0] = hint;
+            }
+        });
+        
+        assertNotNull(holder[0]);
+        assertEquals(singleLine, holder[0].isSingleLine());
+        assertEquals(hint, holder[0].getValue());
+    }
+    
 }
diff --git a/src/test/java/net/sf/jsqlparser/test/TestUtils.java b/src/test/java/net/sf/jsqlparser/test/TestUtils.java
@@ -27,6 +27,13 @@
 import java.io.*;
 
 import static junit.framework.Assert.assertEquals;
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertNotNull;
+import net.sf.jsqlparser.statement.select.PlainSelect;
+import net.sf.jsqlparser.statement.select.Select;
+import net.sf.jsqlparser.statement.select.SelectBody;
+import net.sf.jsqlparser.statement.select.SetOperationList;
+import org.junit.Assert;
 import org.junit.Test;
 
 /**
@@ -90,4 +97,32 @@ public static void assertExpressionCanBeDeparsedAs(final Expression parsed, Stri
 
         assertEquals(expression, stringBuilder.toString());
     }
+    
+    public static void assertOracleHintExists(String sql, boolean assertDeparser, String... hints) throws JSQLParserException {
+        if (assertDeparser) {
+            assertSqlCanBeParsedAndDeparsed(sql, true);
+        }
+        Select stmt = (Select) CCJSqlParserUtil.parse(sql);
+        if (stmt.getSelectBody() instanceof PlainSelect) {
+            PlainSelect ps = (PlainSelect) stmt.getSelectBody();
+            OracleHint hint = ps.getOracleHint();
+            assertNotNull(hint);
+            assertEquals(hints[0], hint.getValue());
+        } else {
+            if (stmt.getSelectBody() instanceof SetOperationList) {
+                SetOperationList setop = (SetOperationList) stmt.getSelectBody();
+                for (int i = 0; i < setop.getSelects().size(); i++) {
+                    PlainSelect pselect = (PlainSelect) setop.getSelects().get(i);
+                    OracleHint hint = pselect.getOracleHint();
+                    if (hints[i] == null) {
+                        Assert.assertNull(hint);
+                    } else {
+                        assertNotNull(hint);
+                        assertEquals(hints[i], hint.getValue());
+                    }
+                }
+            }
+        }
+    }
+    
 }
diff --git a/src/test/java/net/sf/jsqlparser/test/select/SelectTest.java b/src/test/java/net/sf/jsqlparser/test/select/SelectTest.java
@@ -1958,4 +1958,47 @@ public void testIssue167_singleQuoteEscape2() throws JSQLParserException {
 	public void testIssue77_singleQuoteEscape2() throws JSQLParserException {
 		assertSqlCanBeParsedAndDeparsed("SELECT 'test\\'' FROM dual");
 	}
+        
+    public void testOracleHint() throws JSQLParserException {
+        assertOracleHintExists("SELECT /*+ SOMEHINT */ * FROM mytable", true, "SOMEHINT");
+        assertOracleHintExists("SELECT /*+ MORE HINTS POSSIBLE */ * FROM mytable", true, "MORE HINTS POSSIBLE");
+        assertOracleHintExists("SELECT /*+   MORE\nHINTS\t\nPOSSIBLE  */ * FROM mytable", true, "MORE\nHINTS\t\nPOSSIBLE");
+        assertOracleHintExists("SELECT /*+ leading(sn di md sh ot) cardinality(ot 1000) */ c, b FROM mytable", true, "leading(sn di md sh ot) cardinality(ot 1000)");
+        assertOracleHintExists("SELECT /*+ ORDERED INDEX (b, jl_br_balances_n1) USE_NL (j b) \n" +
+                "           USE_NL (glcc glf) USE_MERGE (gp gsb) */\n" +
+                " b.application_id\n" +
+                "FROM  jl_br_journals j,\n" +
+                "      po_vendors p", true, "ORDERED INDEX (b, jl_br_balances_n1) USE_NL (j b) \n" +
+                "           USE_NL (glcc glf) USE_MERGE (gp gsb)");
+        assertOracleHintExists("SELECT /*+ROWID(emp)*/ /*+ THIS IS NOT HINT! ***/ * \n" +
+                "FROM emp \n" +
+                "WHERE rowid > 'AAAAtkAABAAAFNTAAA' AND empno = 155", false, "ROWID(emp)");
+        assertOracleHintExists("SELECT /*+ INDEX(patients sex_index) use sex_index because there are few\n" +
+                "   male patients  */ name, height, weight\n" +
+                "FROM patients\n" +
+                "WHERE sex = 'm'", true, "INDEX(patients sex_index) use sex_index because there are few\n   male patients");
+        assertOracleHintExists("SELECT /*+INDEX_COMBINE(emp sal_bmi hiredate_bmi)*/ * \n" +
+                "FROM emp  \n" +
+                "WHERE sal < 50000 AND hiredate < '01-JAN-1990'", true, "INDEX_COMBINE(emp sal_bmi hiredate_bmi)");
+        assertOracleHintExists("SELECT --+ CLUSTER \n" +
+                "emp.ename, deptno\n" +
+                "FROM emp, dept\n" +
+                "WHERE deptno = 10 \n" +
+                "AND emp.deptno = dept.deptno", true, "CLUSTER");
+        assertOracleHintExists("SELECT --+ CLUSTER \n --+ some other comment, not hint\n /* even more comments */ * from dual", false, "CLUSTER");
+        assertOracleHintExists("(SELECT * from t1) UNION (select /*+ CLUSTER */ * from dual)", true, null, "CLUSTER");
+        assertOracleHintExists("(SELECT * from t1) UNION (select /*+ CLUSTER */ * from dual) UNION (select * from dual)", true, null, "CLUSTER", null);
+        assertOracleHintExists("(SELECT --+ HINT1 HINT2 HINT3\n * from t1) UNION (select /*+ HINT4 HINT5 */ * from dual)", true, "HINT1 HINT2 HINT3", "HINT4 HINT5");
+
+    }
+    
+    public void testOracleHintExpression() throws JSQLParserException {
+        String statement = "SELECT --+ HINT\n * FROM tab1";
+        Statement parsed = parserManager.parse(new StringReader(statement));
+
+        assertEquals(statement, parsed.toString());
+        PlainSelect plainSelect = (PlainSelect) ((Select) parsed).getSelectBody();
+        assertExpressionCanBeDeparsedAs(plainSelect.getOracleHint(), "--+ HINT\n");
+    }
+        
 }
diff --git a/src/test/java/net/sf/jsqlparser/util/TablesNamesFinderTest.java b/src/test/java/net/sf/jsqlparser/util/TablesNamesFinderTest.java
@@ -9,6 +9,7 @@
 import java.util.StringTokenizer;
 import net.sf.jsqlparser.JSQLParserException;
 import net.sf.jsqlparser.expression.Expression;
+import net.sf.jsqlparser.expression.OracleHint;
 
 import net.sf.jsqlparser.parser.CCJSqlParserManager;
 import net.sf.jsqlparser.parser.CCJSqlParserUtil;
@@ -333,4 +334,24 @@ public void testExpr() throws JSQLParserException {
 	private String getLine(BufferedReader in) throws Exception {
 		return CCJSqlParserManagerTest.getLine(in);
 	}
+        
+    @Test
+    public void testOracleHint() throws JSQLParserException {
+        String sql = "select --+ HINT\ncol2 from mytable";
+        Select select = (Select) CCJSqlParserUtil.parse(sql);
+        final OracleHint[] holder = new OracleHint[1];
+        TablesNamesFinder tablesNamesFinder = new TablesNamesFinder() {
+
+            @Override
+            public void visit(OracleHint hint) {
+                super.visit(hint);
+                holder[0] = hint;
+            }
+            
+        };
+        tablesNamesFinder.getTableList(select);
+        assertNull(holder[0]);
+
+    }
+        
 }

Original file line number	Diff line number	Diff line change
`@@ -162,4 +162,7 @@ public interface ExpressionVisitor {`
`162`	`162`	`void visit(MySQLGroupConcat groupConcat);`
`163`	`163`
`164`	`164`	`void visit(RowConstructor rowConstructor);`
	`165`	`+`
	`166`	`+ void visit(OracleHint hint);`
	`167`	`+`
`165`	`168`	`}`
Original file line number	Diff line number	Diff line change
`@@ -452,4 +452,10 @@ public void visit(RowConstructor rowConstructor) {`
`452`	`452`	`public void visit(HexValue hexValue) {`
`453`	`453`
`454`	`454`	`}`
	`455`	`+`
	`456`	`+ @Override`
	`457`	`+ public void visit(OracleHint hint) {`
	`458`	`+`
	`459`	`+ }`
	`460`	`+`
`455`	`461`	`}`
Original file line number	Diff line number	Diff line change
`@@ -633,4 +633,9 @@ public void visit(HexValue hexValue) {`
`633`	`633`	`public void visit(Merge merge) {`
`634`	`634`	`throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools \| Templates.`
`635`	`635`	`}`
	`636`	`+`
	`637`	`+ @Override`
	`638`	`+ public void visit(OracleHint hint) {`
	`639`	`+ }`
	`640`	`+`
`636`	`641`	`}`
Original file line number	Diff line number	Diff line change
`@@ -569,4 +569,10 @@ public void visit(RowConstructor rowConstructor) {`
`569`	`569`	`}`
`570`	`570`	`buffer.append(")");`
`571`	`571`	`}`
	`572`	`+`
	`573`	`+ @Override`
	`574`	`+ public void visit(OracleHint hint) {`
	`575`	`+ buffer.append(hint.toString());`
	`576`	`+ }`
	`577`	`+`
`572`	`578`	`}`