Skip to content

Commit 3774451

Browse files
fudianchnfudianchn
authored
fix(parser): preserve Oracle PRIOR position on all condition expressions (#2601) (#2602)
Condition() drops the consumed PRIOR keyword unless the parsed condition implements SupportsOldOracleJoinSyntax: BETWEEN / LIKE / SIMILAR TO / IS NULL / IS TRUE / IS UNKNOWN / IS DISTINCT FROM / MEMBER OF silently lose it, InExpression throws IllegalArgumentException, and comparisons keep it in toString() but lose it in the deparser. The eight classes now implement the interface (real prior field, explicit reject for the join operator), InExpression stores the position instead of rejecting it, and ExpressionDeParser renders PRIOR for all of them including both positions of OldOracleJoinBinaryExpression. Signed-off-by: 付典 <fudianchn@gmail.com>
1 parent 1515637 commit 3774451

11 files changed

Lines changed: 572 additions & 24 deletions

File tree

‎src/main/java/net/sf/jsqlparser/expression/operators/relational/Between.java‎

Lines changed: 38 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@
1616
/**
1717
* A "BETWEEN" expr1 expr2 statement
1818
*/
19-
public class Between extends ASTNodeAccessImpl implements Expression {
19+
public class Between extends ASTNodeAccessImpl implements Expression, SupportsOldOracleJoinSyntax {
2020

2121
private Expression leftExpression;
2222
private boolean not = false;
@@ -82,7 +82,8 @@ public <T, S> T accept(ExpressionVisitor<T> expressionVisitor, S context) {
8282

8383
@Override
8484
public String toString() {
85-
return leftExpression + " " + (not ? "NOT " : "") + "BETWEEN "
85+
return (oraclePriorPosition == ORACLE_PRIOR_START ? "PRIOR " : "") + leftExpression + " "
86+
+ (not ? "NOT " : "") + "BETWEEN "
8687
+ (usingSymmetric ? "SYMMETRIC " : "") + (usingAsymmetric ? "ASYMMETRIC " : "")
8788
+ betweenExpressionStart
8889
+ " AND "
@@ -120,4 +121,39 @@ public <E extends Expression> E getBetweenExpressionStart(Class<E> type) {
120121
public <E extends Expression> E getLeftExpression(Class<E> type) {
121122
return type.cast(getLeftExpression());
122123
}
124+
125+
private int oraclePriorPosition = NO_ORACLE_PRIOR;
126+
127+
@Override
128+
public int getOldOracleJoinSyntax() {
129+
return NO_ORACLE_JOIN;
130+
}
131+
132+
@Override
133+
public void setOldOracleJoinSyntax(int oldOracleJoinSyntax) {
134+
throw new IllegalArgumentException(
135+
"oracle join operator (+) is not supported on this condition");
136+
}
137+
138+
@Override
139+
public Between withOldOracleJoinSyntax(int oldOracleJoinSyntax) {
140+
setOldOracleJoinSyntax(oldOracleJoinSyntax);
141+
return this;
142+
}
143+
144+
@Override
145+
public int getOraclePriorPosition() {
146+
return oraclePriorPosition;
147+
}
148+
149+
@Override
150+
public void setOraclePriorPosition(int oraclePriorPosition) {
151+
this.oraclePriorPosition = oraclePriorPosition;
152+
}
153+
154+
public Between withOraclePriorPosition(int oraclePriorPosition) {
155+
setOraclePriorPosition(oraclePriorPosition);
156+
return this;
157+
}
158+
123159
}

‎src/main/java/net/sf/jsqlparser/expression/operators/relational/InExpression.java‎

Lines changed: 7 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,8 @@ public class InExpression extends ASTNodeAccessImpl
2222
private Expression rightExpression;
2323
private int oldOracleJoinSyntax = NO_ORACLE_JOIN;
2424

25+
private int oraclePriorPosition = NO_ORACLE_PRIOR;
26+
2527
public InExpression() {}
2628

2729
public InExpression(Expression leftExpression, Expression rightExpression) {
@@ -94,6 +96,9 @@ private String getLeftExpressionString() {
9496
@Override
9597
public String toString() {
9698
StringBuilder statementBuilder = new StringBuilder();
99+
if (oraclePriorPosition == ORACLE_PRIOR_START) {
100+
statementBuilder.append("PRIOR ");
101+
}
97102
statementBuilder.append(getLeftExpressionString());
98103

99104
statementBuilder.append(" ");
@@ -110,14 +115,12 @@ public String toString() {
110115

111116
@Override
112117
public int getOraclePriorPosition() {
113-
return SupportsOldOracleJoinSyntax.NO_ORACLE_PRIOR;
118+
return oraclePriorPosition;
114119
}
115120

116121
@Override
117122
public void setOraclePriorPosition(int priorPosition) {
118-
if (priorPosition != SupportsOldOracleJoinSyntax.NO_ORACLE_PRIOR) {
119-
throw new IllegalArgumentException("unexpected prior for oracle found");
120-
}
123+
this.oraclePriorPosition = priorPosition;
121124
}
122125

123126
public InExpression withRightExpression(Expression rightExpression) {

‎src/main/java/net/sf/jsqlparser/expression/operators/relational/IsBooleanExpression.java‎

Lines changed: 40 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,8 @@
1313
import net.sf.jsqlparser.expression.ExpressionVisitor;
1414
import net.sf.jsqlparser.parser.ASTNodeAccessImpl;
1515

16-
public class IsBooleanExpression extends ASTNodeAccessImpl implements Expression {
16+
public class IsBooleanExpression extends ASTNodeAccessImpl
17+
implements Expression, SupportsOldOracleJoinSyntax {
1718

1819
private Expression leftExpression;
1920
private boolean not = false;
@@ -50,10 +51,11 @@ public <T, S> T accept(ExpressionVisitor<T> expressionVisitor, S context) {
5051

5152
@Override
5253
public String toString() {
54+
String prior = oraclePriorPosition == ORACLE_PRIOR_START ? "PRIOR " : "";
5355
if (isTrue()) {
54-
return leftExpression + " IS" + (not ? " NOT" : "") + " TRUE";
56+
return prior + leftExpression + " IS" + (not ? " NOT" : "") + " TRUE";
5557
} else {
56-
return leftExpression + " IS" + (not ? " NOT" : "") + " FALSE";
58+
return prior + leftExpression + " IS" + (not ? " NOT" : "") + " FALSE";
5759
}
5860
}
5961

@@ -75,4 +77,39 @@ public IsBooleanExpression withNot(boolean not) {
7577
public <E extends Expression> E getLeftExpression(Class<E> type) {
7678
return type.cast(getLeftExpression());
7779
}
80+
81+
private int oraclePriorPosition = NO_ORACLE_PRIOR;
82+
83+
@Override
84+
public int getOldOracleJoinSyntax() {
85+
return NO_ORACLE_JOIN;
86+
}
87+
88+
@Override
89+
public void setOldOracleJoinSyntax(int oldOracleJoinSyntax) {
90+
throw new IllegalArgumentException(
91+
"oracle join operator (+) is not supported on this condition");
92+
}
93+
94+
@Override
95+
public IsBooleanExpression withOldOracleJoinSyntax(int oldOracleJoinSyntax) {
96+
setOldOracleJoinSyntax(oldOracleJoinSyntax);
97+
return this;
98+
}
99+
100+
@Override
101+
public int getOraclePriorPosition() {
102+
return oraclePriorPosition;
103+
}
104+
105+
@Override
106+
public void setOraclePriorPosition(int oraclePriorPosition) {
107+
this.oraclePriorPosition = oraclePriorPosition;
108+
}
109+
110+
public IsBooleanExpression withOraclePriorPosition(int oraclePriorPosition) {
111+
setOraclePriorPosition(oraclePriorPosition);
112+
return this;
113+
}
114+
78115
}

‎src/main/java/net/sf/jsqlparser/expression/operators/relational/IsDistinctExpression.java‎

Lines changed: 38 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@
1212
import net.sf.jsqlparser.expression.BinaryExpression;
1313
import net.sf.jsqlparser.expression.ExpressionVisitor;
1414

15-
public class IsDistinctExpression extends BinaryExpression {
15+
public class IsDistinctExpression extends BinaryExpression implements SupportsOldOracleJoinSyntax {
1616

1717
private boolean not = false;
1818

@@ -36,7 +36,43 @@ public String getStringExpression() {
3636

3737
@Override
3838
public String toString() {
39-
String retval = getLeftExpression() + getStringExpression() + getRightExpression();
39+
String retval = (oraclePriorPosition == ORACLE_PRIOR_START ? "PRIOR " : "")
40+
+ getLeftExpression() + getStringExpression() + getRightExpression();
4041
return retval;
4142
}
43+
44+
private int oraclePriorPosition = NO_ORACLE_PRIOR;
45+
46+
@Override
47+
public int getOldOracleJoinSyntax() {
48+
return NO_ORACLE_JOIN;
49+
}
50+
51+
@Override
52+
public void setOldOracleJoinSyntax(int oldOracleJoinSyntax) {
53+
throw new IllegalArgumentException(
54+
"oracle join operator (+) is not supported on this condition");
55+
}
56+
57+
@Override
58+
public IsDistinctExpression withOldOracleJoinSyntax(int oldOracleJoinSyntax) {
59+
setOldOracleJoinSyntax(oldOracleJoinSyntax);
60+
return this;
61+
}
62+
63+
@Override
64+
public int getOraclePriorPosition() {
65+
return oraclePriorPosition;
66+
}
67+
68+
@Override
69+
public void setOraclePriorPosition(int oraclePriorPosition) {
70+
this.oraclePriorPosition = oraclePriorPosition;
71+
}
72+
73+
public IsDistinctExpression withOraclePriorPosition(int oraclePriorPosition) {
74+
setOraclePriorPosition(oraclePriorPosition);
75+
return this;
76+
}
77+
4278
}

‎src/main/java/net/sf/jsqlparser/expression/operators/relational/IsNullExpression.java‎

Lines changed: 41 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,8 @@
1414
import net.sf.jsqlparser.parser.ASTNodeAccessImpl;
1515
import net.sf.jsqlparser.schema.Column;
1616

17-
public class IsNullExpression extends ASTNodeAccessImpl implements Expression {
17+
public class IsNullExpression extends ASTNodeAccessImpl
18+
implements Expression, SupportsOldOracleJoinSyntax {
1819

1920
private Expression leftExpression;
2021
private boolean not = false;
@@ -72,12 +73,13 @@ public <T, S> T accept(ExpressionVisitor<T> expressionVisitor, S context) {
7273

7374
@Override
7475
public String toString() {
76+
String prior = oraclePriorPosition == ORACLE_PRIOR_START ? "PRIOR " : "";
7577
if (useNotNull) {
76-
return leftExpression + " NOTNULL";
78+
return prior + leftExpression + " NOTNULL";
7779
} else if (useIsNull) {
78-
return leftExpression + (not ? " NOT" : "") + " ISNULL";
80+
return prior + leftExpression + (not ? " NOT" : "") + " ISNULL";
7981
} else {
80-
return leftExpression + " IS " + (not ? "NOT " : "") + "NULL";
82+
return prior + leftExpression + " IS " + (not ? "NOT " : "") + "NULL";
8183
}
8284
}
8385

@@ -99,4 +101,39 @@ public IsNullExpression withNot(boolean not) {
99101
public <E extends Expression> E getLeftExpression(Class<E> type) {
100102
return type.cast(getLeftExpression());
101103
}
104+
105+
private int oraclePriorPosition = NO_ORACLE_PRIOR;
106+
107+
@Override
108+
public int getOldOracleJoinSyntax() {
109+
return NO_ORACLE_JOIN;
110+
}
111+
112+
@Override
113+
public void setOldOracleJoinSyntax(int oldOracleJoinSyntax) {
114+
throw new IllegalArgumentException(
115+
"oracle join operator (+) is not supported on this condition");
116+
}
117+
118+
@Override
119+
public IsNullExpression withOldOracleJoinSyntax(int oldOracleJoinSyntax) {
120+
setOldOracleJoinSyntax(oldOracleJoinSyntax);
121+
return this;
122+
}
123+
124+
@Override
125+
public int getOraclePriorPosition() {
126+
return oraclePriorPosition;
127+
}
128+
129+
@Override
130+
public void setOraclePriorPosition(int oraclePriorPosition) {
131+
this.oraclePriorPosition = oraclePriorPosition;
132+
}
133+
134+
public IsNullExpression withOraclePriorPosition(int oraclePriorPosition) {
135+
setOraclePriorPosition(oraclePriorPosition);
136+
return this;
137+
}
138+
102139
}

‎src/main/java/net/sf/jsqlparser/expression/operators/relational/IsUnknownExpression.java‎

Lines changed: 39 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,8 @@
1313
import net.sf.jsqlparser.expression.ExpressionVisitor;
1414
import net.sf.jsqlparser.parser.ASTNodeAccessImpl;
1515

16-
public class IsUnknownExpression extends ASTNodeAccessImpl implements Expression {
16+
public class IsUnknownExpression extends ASTNodeAccessImpl
17+
implements Expression, SupportsOldOracleJoinSyntax {
1718

1819
private Expression leftExpression;
1920
private boolean isNot = false;
@@ -41,7 +42,8 @@ public <T, S> T accept(ExpressionVisitor<T> expressionVisitor, S context) {
4142

4243
@Override
4344
public String toString() {
44-
return leftExpression + " IS" + (isNot ? " NOT" : "") + " UNKNOWN";
45+
return (oraclePriorPosition == ORACLE_PRIOR_START ? "PRIOR " : "") + leftExpression + " IS"
46+
+ (isNot ? " NOT" : "") + " UNKNOWN";
4547
}
4648

4749
public IsUnknownExpression withLeftExpression(Expression leftExpression) {
@@ -57,4 +59,39 @@ public IsUnknownExpression withNot(boolean isNot) {
5759
public <E extends Expression> E getLeftExpression(Class<E> type) {
5860
return type.cast(getLeftExpression());
5961
}
62+
63+
private int oraclePriorPosition = NO_ORACLE_PRIOR;
64+
65+
@Override
66+
public int getOldOracleJoinSyntax() {
67+
return NO_ORACLE_JOIN;
68+
}
69+
70+
@Override
71+
public void setOldOracleJoinSyntax(int oldOracleJoinSyntax) {
72+
throw new IllegalArgumentException(
73+
"oracle join operator (+) is not supported on this condition");
74+
}
75+
76+
@Override
77+
public IsUnknownExpression withOldOracleJoinSyntax(int oldOracleJoinSyntax) {
78+
setOldOracleJoinSyntax(oldOracleJoinSyntax);
79+
return this;
80+
}
81+
82+
@Override
83+
public int getOraclePriorPosition() {
84+
return oraclePriorPosition;
85+
}
86+
87+
@Override
88+
public void setOraclePriorPosition(int oraclePriorPosition) {
89+
this.oraclePriorPosition = oraclePriorPosition;
90+
}
91+
92+
public IsUnknownExpression withOraclePriorPosition(int oraclePriorPosition) {
93+
setOraclePriorPosition(oraclePriorPosition);
94+
return this;
95+
}
96+
6097
}

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

Lines changed: 38 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -14,7 +14,7 @@
1414
import net.sf.jsqlparser.expression.Expression;
1515
import net.sf.jsqlparser.expression.ExpressionVisitor;
1616

17-
public class LikeExpression extends BinaryExpression {
17+
public class LikeExpression extends BinaryExpression implements SupportsOldOracleJoinSyntax {
1818
private boolean not = false;
1919
private boolean useBinary = false;
2020
private Expression escapeExpression = null;
@@ -50,7 +50,8 @@ public String getStringExpression() {
5050

5151
@Override
5252
public String toString() {
53-
String retval = getLeftExpression() + " " + (not ? "NOT " : "")
53+
String retval = (oraclePriorPosition == ORACLE_PRIOR_START ? "PRIOR " : "")
54+
+ getLeftExpression() + " " + (not ? "NOT " : "")
5455
+ (likeKeyWord == KeyWord.SIMILAR_TO ? "SIMILAR TO" : likeKeyWord) + " "
5556
+ (useBinary ? "BINARY " : "") + getRightExpression();
5657
if (escapeExpression != null) {
@@ -125,4 +126,39 @@ public static KeyWord from(String keyword) {
125126
keyword.toUpperCase(Locale.ROOT).replaceAll("\\s+", "_"));
126127
}
127128
}
129+
130+
private int oraclePriorPosition = NO_ORACLE_PRIOR;
131+
132+
@Override
133+
public int getOldOracleJoinSyntax() {
134+
return NO_ORACLE_JOIN;
135+
}
136+
137+
@Override
138+
public void setOldOracleJoinSyntax(int oldOracleJoinSyntax) {
139+
throw new IllegalArgumentException(
140+
"oracle join operator (+) is not supported on this condition");
141+
}
142+
143+
@Override
144+
public LikeExpression withOldOracleJoinSyntax(int oldOracleJoinSyntax) {
145+
setOldOracleJoinSyntax(oldOracleJoinSyntax);
146+
return this;
147+
}
148+
149+
@Override
150+
public int getOraclePriorPosition() {
151+
return oraclePriorPosition;
152+
}
153+
154+
@Override
155+
public void setOraclePriorPosition(int oraclePriorPosition) {
156+
this.oraclePriorPosition = oraclePriorPosition;
157+
}
158+
159+
public LikeExpression withOraclePriorPosition(int oraclePriorPosition) {
160+
setOraclePriorPosition(oraclePriorPosition);
161+
return this;
162+
}
163+
128164
}

0 commit comments

Comments
 (0)