Merge remote-tracking branch 'refs/remotes/JSQLParser/master' into fix-alter-drop

Author: schweighart

README.md

@@ -38,6 +38,7 @@ Also I would like to know about needed examples or documentation stuff.
 
 ## Extensions in the latest SNAPSHOT version 0.9.5
 
+* first Oracle hint support for **select** statements 
 * first **alter table foreign key** support
 * first **merge** support
 * first version of escaped single quotes support

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);
+    
 }

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) {
+
+    }
+        
 }

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 + " */";
+        }
+    }
+    
+}

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(" ");
         }

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) {
+    }
+    
 }

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());
+    }
+    
 }

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(" ");

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();

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());
+    }
+    
 }