merge oracle hierarchical syntax into main

JSQLParser · Oct 8, 2013 · 6c30062 · 6c30062
2 parents 3901bc6 + b48f26e
commit 6c30062
Show file tree

Hide file tree

Showing 11 changed files with 209 additions and 10 deletions.
diff --git a/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitor.java b/src/main/java/net/sf/jsqlparser/expression/ExpressionVisitor.java
@@ -138,4 +138,6 @@ public interface ExpressionVisitor {
 	void visit(ExtractExpression eexpr);
 
 	void visit(IntervalExpression iexpr);
+
+	void visit(OracleHierarchicalExpression oexpr);
 }
diff --git a/src/main/java/net/sf/jsqlparser/expression/OracleHierarchicalExpression.java b/src/main/java/net/sf/jsqlparser/expression/OracleHierarchicalExpression.java
@@ -0,0 +1,75 @@
+/*
+ * #%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;
+
+/**
+ *
+ * @author toben
+ */
+public class OracleHierarchicalExpression implements Expression {
+
+	private Expression startExpression;
+	private Expression connectExpression;
+	private boolean noCycle = false;
+
+	public Expression getStartExpression() {
+		return startExpression;
+	}
+
+	public void setStartExpression(Expression startExpression) {
+		this.startExpression = startExpression;
+	}
+
+	public Expression getConnectExpression() {
+		return connectExpression;
+	}
+
+	public void setConnectExpression(Expression connectExpression) {
+		this.connectExpression = connectExpression;
+	}
+
+	public boolean isNoCycle() {
+		return noCycle;
+	}
+
+	public void setNoCycle(boolean noCycle) {
+		this.noCycle = noCycle;
+	}
+
+	@Override
+	public void accept(ExpressionVisitor expressionVisitor) {
+		expressionVisitor.visit(this);
+	}
+
+	public String toString() {
+		StringBuilder b = new StringBuilder();
+		if (startExpression != null) {
+			b.append(" START WITH ").append(startExpression.toString());
+		}
+		b.append(" CONNECT BY ");
+		if (isNoCycle()) {
+			b.append("NOCYCLE ");
+		}
+		b.append(connectExpression.toString());
+		return b.toString();
+	}
+}
diff --git a/src/main/java/net/sf/jsqlparser/expression/operators/relational/InExpression.java b/src/main/java/net/sf/jsqlparser/expression/operators/relational/InExpression.java
@@ -41,13 +41,15 @@ public InExpression(Expression leftExpression, ItemsList itemsList) {
 		setRightItemsList(itemsList);
 	}
 
+	@Override
     public void setOldOracleJoinSyntax(int oldOracleJoinSyntax) {
         this.oldOracleJoinSyntax = oldOracleJoinSyntax;
         if (oldOracleJoinSyntax < 0 || oldOracleJoinSyntax > 1) {
             throw new IllegalArgumentException("unexpected join type for oracle found with IN (type=" + oldOracleJoinSyntax + ")");
         }
     }
 
+	@Override
     public int getOldOracleJoinSyntax() {
         return oldOracleJoinSyntax;
     }
@@ -97,4 +99,16 @@ private String getLeftExpressionString() {
 	public String toString() {
 		return (leftExpression == null ? leftItemsList : getLeftExpressionString()) + " " + ((not) ? "NOT " : "") + "IN " + rightItemsList + "";
 	}
+
+	@Override
+	public int getOraclePriorPosition() {
+		return SupportsOldOracleJoinSyntax.NO_ORACLE_PRIOR;
+	}
+
+	@Override
+	public void setOraclePriorPosition(int priorPosition) {
+        if (priorPosition != SupportsOldOracleJoinSyntax.NO_ORACLE_PRIOR) {
+            throw new IllegalArgumentException("unexpected prior for oracle found");
+        }
+	}
 }
diff --git a/...java/net/sf/jsqlparser/expression/operators/relational/OldOracleJoinBinaryExpression.java b/...java/net/sf/jsqlparser/expression/operators/relational/OldOracleJoinBinaryExpression.java
@@ -22,10 +22,13 @@
 package net.sf.jsqlparser.expression.operators.relational;
 
 import net.sf.jsqlparser.expression.BinaryExpression;
+import static net.sf.jsqlparser.expression.operators.relational.SupportsOldOracleJoinSyntax.ORACLE_PRIOR_START;
 
 public abstract class OldOracleJoinBinaryExpression extends BinaryExpression implements SupportsOldOracleJoinSyntax {
 
     private int oldOracleJoinSyntax = NO_ORACLE_JOIN;
+
+	private int oraclePriorPosition = NO_ORACLE_PRIOR;
 
 	@Override
     public void setOldOracleJoinSyntax(int oldOracleJoinSyntax) {
@@ -37,11 +40,28 @@ public void setOldOracleJoinSyntax(int oldOracleJoinSyntax) {
 
     @Override
     public String toString() {
-        return (isNot() ? "NOT " : "") + getLeftExpression() + (oldOracleJoinSyntax == ORACLE_JOIN_RIGHT ? "(+)" : "") + " " + getStringExpression() + " " + getRightExpression() + (oldOracleJoinSyntax == ORACLE_JOIN_LEFT ? "(+)" : "");
+        return (isNot() ? "NOT " : "") 
+				+ (oraclePriorPosition == ORACLE_PRIOR_START ? "PRIOR " : "")
+				+ getLeftExpression() 
+				+ (oldOracleJoinSyntax == ORACLE_JOIN_RIGHT ? "(+)" : "") + " " 
+				+ getStringExpression() + " " 
+				+ (oraclePriorPosition == ORACLE_PRIOR_END ? "PRIOR " : "")
+				+ getRightExpression() 
+				+ (oldOracleJoinSyntax == ORACLE_JOIN_LEFT ? "(+)" : "");
     }
 
 	@Override
     public int getOldOracleJoinSyntax() {
         return oldOracleJoinSyntax;
     }
+
+	@Override
+	public int getOraclePriorPosition() {
+		return oraclePriorPosition;
+	}
+
+	@Override
+	public void setOraclePriorPosition(int oraclePriorPosition) {
+		this.oraclePriorPosition = oraclePriorPosition;
+	}
 }
diff --git a/...n/java/net/sf/jsqlparser/expression/operators/relational/SupportsOldOracleJoinSyntax.java b/...n/java/net/sf/jsqlparser/expression/operators/relational/SupportsOldOracleJoinSyntax.java
@@ -30,4 +30,12 @@ public interface SupportsOldOracleJoinSyntax {
 	int getOldOracleJoinSyntax();
 
 	void setOldOracleJoinSyntax(int oldOracleJoinSyntax);
+
+	static final int NO_ORACLE_PRIOR = 0;
+	static final int ORACLE_PRIOR_START = 1;
+	static final int ORACLE_PRIOR_END = 2;
+
+	int getOraclePriorPosition();
+
+	void setOraclePriorPosition(int priorPosition);
 }
diff --git a/src/main/java/net/sf/jsqlparser/statement/select/PlainSelect.java b/src/main/java/net/sf/jsqlparser/statement/select/PlainSelect.java
@@ -26,6 +26,7 @@
 
 import java.util.Iterator;
 import java.util.List;
+import net.sf.jsqlparser.expression.OracleHierarchicalExpression;
 
 /**
  * The core of a "SELECT" statement (no UNION, no ORDER BY)
@@ -43,6 +44,8 @@ public class PlainSelect implements SelectBody {
 	private Expression having;
 	private Limit limit;
 	private Top top;
+	private OracleHierarchicalExpression oracleHierarchical = null;
+	private boolean oracleSiblings = false;
 
 	/**
 	 * The {@link FromItem} in this query
@@ -159,7 +162,23 @@ public void setGroupByColumnReferences(List<Expression> list) {
 		groupByColumnReferences = list;
 	}
 
-    @Override
+	public OracleHierarchicalExpression getOracleHierarchical() {
+		return oracleHierarchical;
+	}
+
+	public void setOracleHierarchical(OracleHierarchicalExpression oracleHierarchical) {
+		this.oracleHierarchical = oracleHierarchical;
+	}
+
+	public boolean isOracleSiblings() {
+		return oracleSiblings;
+	}
+
+	public void setOracleSiblings(boolean oracleSiblings) {
+		this.oracleSiblings = oracleSiblings;
+	}
+
+	@Override
 	public String toString() {
 		StringBuilder sql = new StringBuilder("SELECT ");
 		if (distinct != null) {
@@ -186,11 +205,14 @@ public String toString() {
 			if (where != null) {
 				sql.append(" WHERE ").append(where);
 			}
+			if (oracleHierarchical != null) {
+				sql.append(oracleHierarchical.toString());
+			}
 			sql.append(getFormatedList(groupByColumnReferences, "GROUP BY"));
 			if (having != null) {
 				sql.append(" HAVING ").append(having);
 			}
-			sql.append(orderByToString(orderByElements));
+			sql.append(orderByToString(oracleSiblings, orderByElements));
 			if (limit != null) {
 				sql.append(limit);
 			}
@@ -199,7 +221,11 @@ public String toString() {
 	}
 
 	public static String orderByToString(List<OrderByElement> orderByElements) {
-		return getFormatedList(orderByElements, "ORDER BY");
+		return orderByToString(false, orderByElements);
+	}
+
+	public static String orderByToString(boolean oracleSiblings, List<OrderByElement> orderByElements) {
+		return getFormatedList(orderByElements, oracleSiblings?"ORDER SIBLINGS BY":"ORDER BY");
 	}
 
 	public static String getFormatedList(List<?> list, String expression) {

diff --git a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
@@ -41,6 +41,7 @@
 import net.sf.jsqlparser.expression.JdbcParameter;
 import net.sf.jsqlparser.expression.LongValue;
 import net.sf.jsqlparser.expression.NullValue;
+import net.sf.jsqlparser.expression.OracleHierarchicalExpression;
 import net.sf.jsqlparser.expression.Parenthesis;
 import net.sf.jsqlparser.expression.StringValue;
 import net.sf.jsqlparser.expression.TimeValue;
@@ -501,4 +502,8 @@ public void visit(IntervalExpression iexpr) {
     @Override
     public void visit(JdbcNamedParameter jdbcNamedParameter) {
     }
+
+	@Override
+	public void visit(OracleHierarchicalExpression oexpr) {
+	}
 }
diff --git a/src/main/java/net/sf/jsqlparser/util/deparser/ExpressionDeParser.java b/src/main/java/net/sf/jsqlparser/util/deparser/ExpressionDeParser.java
@@ -482,4 +482,9 @@ public void visit(IntervalExpression iexpr) {
 	public void visit(JdbcNamedParameter jdbcNamedParameter) {
 		buffer.append(jdbcNamedParameter.toString());
 	}
+
+	@Override
+	public void visit(OracleHierarchicalExpression oexpr) {
+		buffer.append(oexpr.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
@@ -95,6 +95,10 @@ public void visit(PlainSelect plainSelect) {
             }
 		}
 
+		if (plainSelect.getOracleHierarchical() != null) {
+			plainSelect.getOracleHierarchical().accept(expressionVisitor);
+		}
+
 		if (plainSelect.getWhere() != null) {
 			buffer.append(" WHERE ");
 			plainSelect.getWhere().accept(expressionVisitor);
@@ -117,7 +121,7 @@ public void visit(PlainSelect plainSelect) {
 		}
 
 		if (plainSelect.getOrderByElements() != null) {
-			deparseOrderBy(plainSelect.getOrderByElements());
+			deparseOrderBy(plainSelect.isOracleSiblings(), plainSelect.getOrderByElements());
 		}
 
 		if (plainSelect.getLimit() != null) {
@@ -212,7 +216,14 @@ public void visit(PivotXml pivot) {
     }
 
 	public void deparseOrderBy(List<OrderByElement> orderByElements) {
-		buffer.append(" ORDER BY ");
+		deparseOrderBy(false, orderByElements);
+	}
+
+	public void deparseOrderBy(boolean oracleSiblings, List<OrderByElement> orderByElements) {
+		if (oracleSiblings)
+			buffer.append(" ORDER SIBLINGS BY ");
+		else
+			buffer.append(" ORDER BY ");
 		for (Iterator<OrderByElement> iter = orderByElements.iterator(); iter.hasNext();) {
 			OrderByElement orderByElement = iter.next();
 			orderByElement.accept(this);