Chemy1220
/
examples
forked from opengaussexamples/examples
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

revise

This commit is contained in:
XudongXie 2024-09-10 16:48:55 +08:00
parent 15ef28ad4f
commit 54a4bf3db0
3 changed files with 193 additions and 122 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
sqlTranslate/.idea/workspace.xml
View File

@ -4,12 +4,9 @@
<option name="autoReloadType" value="SELECTIVE" />
</component>
<component name="ChangeListManager">
<list default="true" id="d8d12963-4777-48e3-9669-309cf5e41d60" name="更改" comment="add select">
<change afterPath="$PROJECT_DIR$/src/main/java/Parser/AST/CaseWhen/CaseConditionNode.java" afterDir="false" />
<change afterPath="$PROJECT_DIR$/src/main/java/Parser/AST/CaseWhen/CaseElseNode.java" afterDir="false" />
<change afterPath="$PROJECT_DIR$/src/main/java/Parser/AST/CaseWhen/CaseEndNode.java" afterDir="false" />
<change afterPath="$PROJECT_DIR$/src/main/java/Parser/AST/CaseWhen/CaseThenNode.java" afterDir="false" />
<list default="true" id="d8d12963-4777-48e3-9669-309cf5e41d60" name="更改" comment="add case when">
<change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/main/java/Main.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/main/java/Main.java" afterDir="false" />
<change beforePath="$PROJECT_DIR$/src/main/java/Parser/OracleParser.java" beforeDir="false" afterPath="$PROJECT_DIR$/src/main/java/Parser/OracleParser.java" afterDir="false" />
</list>
<option name="SHOW_DIALOG" value="false" />
@ -290,7 +287,14 @@
<option name="project" value="LOCAL" />
<updated>1725955766774</updated>
</task>
<option name="localTasksCounter" value="27" />
<task id="LOCAL-00027" summary="add case when">
<created>1725956415475</created>
<option name="number" value="00027" />
<option name="presentableId" value="LOCAL-00027" />
<option name="project" value="LOCAL" />
<updated>1725956415475</updated>
</task>
<option name="localTasksCounter" value="28" />
<servers />
</component>
<component name="Vcs.Log.Tabs.Properties">
@ -318,7 +322,8 @@
<MESSAGE value="add insert sql" />
<MESSAGE value="add todolist" />
<MESSAGE value="add select" />
<option name="LAST_COMMIT_MESSAGE" value="add select" />
<MESSAGE value="add case when" />
<option name="LAST_COMMIT_MESSAGE" value="add case when" />
</component>
<component name="XDebuggerManager">
<watches-manager>

16
sqlTranslate/src/main/java/Main.java
View File

@ -7,15 +7,15 @@ import Parser.OracleParser;
public class Main {
public static void main(String[] args) {
// String sql = "CREATE TABLE employees (\n" +
// " employee_id NUMBER PRIMARY KEY,\n" +
// " first_name VARCHAR2(20),\n" +
// " last_name VARCHAR2(25),\n" +
// " email VARCHAR2(25),\n" +
// " hire_date DATE\n" +
// ");";
String sql = "CREATE TABLE employees (\n" +
" employee_id NUMBER PRIMARY KEY,\n" +
" first_name VARCHAR2(20),\n" +
" last_name VARCHAR2(25),\n" +
" email VARCHAR2(25),\n" +
" hire_date DATE\n" +
");";
// String sql = "INSERT INTO employees (first_name, last_name, email) VALUES ('Jane', 'Smith', 'janesm@example.com');";
String sql = "DROP TABLE employees CASCADE CONSTRAINTS;";
// String sql = "DROP TABLE employees CASCADE CONSTRAINTS;";
OracleLexer lexer = new OracleLexer(sql);
lexer.printTokens();
OracleParser parser = new OracleParser(lexer);

280
sqlTranslate/src/main/java/Parser/OracleParser.java
View File

@ -4,6 +4,10 @@ import Lexer.OracleLexer;
import Lexer.Token;
import Parser.AST.ASTNode;
import Exception.ParseFailedException;
import Parser.AST.CaseWhen.CaseConditionNode;
import Parser.AST.CaseWhen.CaseElseNode;
import Parser.AST.CaseWhen.CaseEndNode;
import Parser.AST.CaseWhen.CaseThenNode;
import Parser.AST.CreateTable.*;
import Parser.AST.DropTable.DropTableEndNode;
import Parser.AST.DropTable.DropTableNameNode;
@ -28,20 +32,19 @@ public class OracleParser {
}
public ASTNode parse()
{
List<Token> tokens = lexer.getTokens();
// check if the input is a create table statement
if ((tokens.get(0).getValue().equalsIgnoreCase("CREATE") && tokens.get(1).getValue().equalsIgnoreCase("TABLE")) ||
(tokens.get(0).getValue().equalsIgnoreCase("CREATE") && tokens.get(2).getValue().equalsIgnoreCase("TEMPORARY") && tokens.get(3).getValue().equalsIgnoreCase("TABLE")) ) {
return parseCreateTab();
if ((lexer.getTokens().get(0).getValue().equalsIgnoreCase("CREATE") && lexer.getTokens().get(1).getValue().equalsIgnoreCase("TABLE")) ||
(lexer.getTokens().get(0).getValue().equalsIgnoreCase("CREATE") && lexer.getTokens().get(2).getValue().equalsIgnoreCase("TEMPORARY") && lexer.getTokens().get(3).getValue().equalsIgnoreCase("TABLE")) ) {
return parseCreateTab(lexer.getTokens());
}
else if (tokens.get(0).getValue().equalsIgnoreCase("INSERT")) {
return parseInsert();
else if (lexer.getTokens().get(0).getValue().equalsIgnoreCase("INSERT")) {
return parseInsert(lexer.getTokens());
}
else if (tokens.get(0).getValue().equalsIgnoreCase("DROP")) {
return parseDrop();
else if (lexer.getTokens().get(0).getValue().equalsIgnoreCase("DROP")) {
return parseDrop(lexer.getTokens());
}
else if (tokens.get(0).getValue().equalsIgnoreCase("SELECT")) {
return parseSelect();
else if (lexer.getTokens().get(0).getValue().equalsIgnoreCase("SELECT")) {
return parseSelect(lexer.getTokens());
}
else {
try {
@ -54,19 +57,19 @@ public class OracleParser {
}
}
private ASTNode parseCreateTab() {
private ASTNode parseCreateTab(List<Token> parseTokens) {
List <Token> tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(0));
tokens.add(parseTokens.get(0));
ASTNode root = new CreateTabNode(tokens);
ASTNode currentNode = null;
for (int i = 1; i < lexer.getTokens().size(); i++) {
// System.out.println("Parsing the token: " + lexer.getTokens().get(i).getValue());
if (i == 1 && lexer.getTokens().get(i).getValue().equalsIgnoreCase("TABLE")) {
for (int i = 1; i < parseTokens.size(); i++) {
// System.out.println("Parsing the token: " + parseTokens.get(i).getValue());
if (i == 1 && parseTokens.get(i).getValue().equalsIgnoreCase("TABLE")) {
tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(i));
tokens.add(parseTokens.get(i));
try {
tokens.add(lexer.getTokens().get(i + 1));
tokens.add(parseTokens.get(i + 1));
}
catch (ParseFailedException e) {
e.printStackTrace();
@ -77,18 +80,18 @@ public class OracleParser {
root.addChild(child);
currentNode = child;
}
else if (i == 1 && !lexer.getTokens().get(i).getValue().equalsIgnoreCase("TABLE")){
else if (i == 1 && !parseTokens.get(i).getValue().equalsIgnoreCase("TABLE")){
tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(i));
for (int j = i + 1; j < lexer.getTokens().size(); j++) {
if (lexer.getTokens().get(j).getValue().equalsIgnoreCase("TABLE")) {
tokens.add(parseTokens.get(i));
for (int j = i + 1; j < parseTokens.size(); j++) {
if (parseTokens.get(j).getValue().equalsIgnoreCase("TABLE")) {
ASTNode child = new TableTypeNode(tokens);
root.addChild(child);
currentNode = child;
tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(j));
tokens.add(parseTokens.get(j));
try {
tokens.add(lexer.getTokens().get(j + 1));
tokens.add(parseTokens.get(j + 1));
}
catch (ParseFailedException e) {
e.printStackTrace();
@ -96,42 +99,42 @@ public class OracleParser {
i = j + 2; // pass the "("
break;
}
tokens.add(lexer.getTokens().get(j));
tokens.add(parseTokens.get(j));
}
ASTNode child = new TableNode(tokens);
currentNode.addChild(child);
currentNode = child;
}
else if (lexer.getTokens().get(i).hasType(Token.TokenType.IDENTIFIER)) {
else if (parseTokens.get(i).hasType(Token.TokenType.IDENTIFIER)) {
// Token.TokenType.IDENTIFIER ... , -> column node
tokens = new ArrayList<>();
ColumnNode child = new ColumnNode();
child.setName(lexer.getTokens().get(i));
tokens.add(lexer.getTokens().get(i));
child.setName(parseTokens.get(i));
tokens.add(parseTokens.get(i));
List <Token> constraint = new ArrayList<>();
for (int j = i + 1; j < lexer.getTokens().size(); j++) {
for (int j = i + 1; j < parseTokens.size(); j++) {
if (j == i + 1) {
child.setType(lexer.getTokens().get(j));
child.setType(parseTokens.get(j));
}
// Check () or REFERENCES other_table(other_column)
if (lexer.getTokens().get(j).hasType(Token.TokenType.KEYWORD) &&
(lexer.getTokens().get(j).getValue().equalsIgnoreCase("REFERENCES")
|| lexer.getTokens().get(j).getValue().equalsIgnoreCase("CHECK"))) {
tokens.add(lexer.getTokens().get(j));
if (parseTokens.get(j).hasType(Token.TokenType.KEYWORD) &&
(parseTokens.get(j).getValue().equalsIgnoreCase("REFERENCES")
|| parseTokens.get(j).getValue().equalsIgnoreCase("CHECK"))) {
tokens.add(parseTokens.get(j));
Stack<String> stack = new Stack<>();
for (int k = j + 1; k < lexer.getTokens().size(); k++) {
tokens.add(lexer.getTokens().get(k));
constraint.add(lexer.getTokens().get(k));
if (lexer.getTokens().get(k).getValue().equals("(")) {
for (int k = j + 1; k < parseTokens.size(); k++) {
tokens.add(parseTokens.get(k));
constraint.add(parseTokens.get(k));
if (parseTokens.get(k).getValue().equals("(")) {
stack.push("(");
for (int t = k + 1; t < lexer.getTokens().size(); t++) {
tokens.add(lexer.getTokens().get(t));
constraint.add(lexer.getTokens().get(t));
if (lexer.getTokens().get(t).getValue().equals("(")) {
for (int t = k + 1; t < parseTokens.size(); t++) {
tokens.add(parseTokens.get(t));
constraint.add(parseTokens.get(t));
if (parseTokens.get(t).getValue().equals("(")) {
stack.push("(");
}
else if (lexer.getTokens().get(t).getValue().equals(")")) {
else if (parseTokens.get(t).getValue().equals(")")) {
stack.pop();
if (stack.empty()) {
i = t;
@ -144,14 +147,14 @@ public class OracleParser {
}
break;
}
if ((lexer.getTokens().get(j).hasType(Token.TokenType.SYMBOL) && lexer.getTokens().get(j).getValue().equals(",")) ||
(lexer.getTokens().get(j).hasType(Token.TokenType.SYMBOL) && lexer.getTokens().get(j).getValue().equals(")")) ) {
if ((parseTokens.get(j).hasType(Token.TokenType.SYMBOL) && parseTokens.get(j).getValue().equals(",")) ||
(parseTokens.get(j).hasType(Token.TokenType.SYMBOL) && parseTokens.get(j).getValue().equals(")")) ) {
i = j;
break;
}
tokens.add(lexer.getTokens().get(j));
tokens.add(parseTokens.get(j));
if (j != i + 1) {
constraint.add(lexer.getTokens().get(j));
constraint.add(parseTokens.get(j));
}
}
child.setTokens(tokens);
@ -159,36 +162,36 @@ public class OracleParser {
currentNode.addChild(child);
currentNode = child;
}
else if (lexer.getTokens().get(i).hasType(Token.TokenType.KEYWORD)
&& lexer.getTokens().get(i).getValue().equalsIgnoreCase("CONSTRAINT")) {
else if (parseTokens.get(i).hasType(Token.TokenType.KEYWORD)
&& parseTokens.get(i).getValue().equalsIgnoreCase("CONSTRAINT")) {
// Table constraint
tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(i));
for (int j = i + 1; j < lexer.getTokens().size(); j++) {
tokens.add(parseTokens.get(i));
for (int j = i + 1; j < parseTokens.size(); j++) {
/**
* CONSTRAINT pk_example PRIMARY KEY (column1, column2)
* CONSTRAINT uk_example UNIQUE (column1)
* CONSTRAINT fk_example FOREIGN KEY (column1) REFERENCES other_table(column2)
* CONSTRAINT chk_example CHECK (column1 > 0)
*/
if (lexer.getTokens().get(j).hasType(Token.TokenType.KEYWORD) &&
(lexer.getTokens().get(j).getValue().equalsIgnoreCase("UNIQUE")
|| lexer.getTokens().get(j).getValue().equalsIgnoreCase("CHECK")
|| lexer.getTokens().get(j).getValue().equalsIgnoreCase("PRIMARY KEY")
|| lexer.getTokens().get(j).getValue().equalsIgnoreCase("FOREIGN KEY")
|| lexer.getTokens().get(j).getValue().equalsIgnoreCase("REFERENCES"))) {
tokens.add(lexer.getTokens().get(j));
if (parseTokens.get(j).hasType(Token.TokenType.KEYWORD) &&
(parseTokens.get(j).getValue().equalsIgnoreCase("UNIQUE")
|| parseTokens.get(j).getValue().equalsIgnoreCase("CHECK")
|| parseTokens.get(j).getValue().equalsIgnoreCase("PRIMARY KEY")
|| parseTokens.get(j).getValue().equalsIgnoreCase("FOREIGN KEY")
|| parseTokens.get(j).getValue().equalsIgnoreCase("REFERENCES"))) {
tokens.add(parseTokens.get(j));
Stack<String> stack = new Stack<>();
for (int k = j + 1; k < lexer.getTokens().size(); k++) {
tokens.add(lexer.getTokens().get(k));
if (lexer.getTokens().get(k).getValue().equals("(")) {
for (int k = j + 1; k < parseTokens.size(); k++) {
tokens.add(parseTokens.get(k));
if (parseTokens.get(k).getValue().equals("(")) {
stack.push("(");
for (int t = k + 1; t < lexer.getTokens().size(); t++) {
tokens.add(lexer.getTokens().get(t));
if (lexer.getTokens().get(t).getValue().equals("(")) {
for (int t = k + 1; t < parseTokens.size(); t++) {
tokens.add(parseTokens.get(t));
if (parseTokens.get(t).getValue().equals("(")) {
stack.push("(");
}
else if (lexer.getTokens().get(t).getValue().equals(")")) {
else if (parseTokens.get(t).getValue().equals(")")) {
stack.pop();
if (stack.empty()) {
i = t;
@ -202,27 +205,27 @@ public class OracleParser {
}
continue;
}
if ((lexer.getTokens().get(j).hasType(Token.TokenType.SYMBOL) && lexer.getTokens().get(j).getValue().equals(",")) ||
(lexer.getTokens().get(j).hasType(Token.TokenType.SYMBOL) && lexer.getTokens().get(j).getValue().equals(")")) ) {
if ((parseTokens.get(j).hasType(Token.TokenType.SYMBOL) && parseTokens.get(j).getValue().equals(",")) ||
(parseTokens.get(j).hasType(Token.TokenType.SYMBOL) && parseTokens.get(j).getValue().equals(")")) ) {
i = j;
break;
}
tokens.add(lexer.getTokens().get(j));
tokens.add(parseTokens.get(j));
}
}
else if (lexer.getTokens().get(i).hasType(Token.TokenType.SYMBOL) && lexer.getTokens().get(i).getValue().equals(";")) {
else if (parseTokens.get(i).hasType(Token.TokenType.SYMBOL) && parseTokens.get(i).getValue().equals(";")) {
tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(i));
tokens.add(parseTokens.get(i));
ASTNode EndNode = new CRTEndNode(tokens);
currentNode.addChild(EndNode);
currentNode = EndNode;
}
else if (lexer.getTokens().get(i).hasType(Token.TokenType.EOF)) {
else if (parseTokens.get(i).hasType(Token.TokenType.EOF)) {
break;
}
else {
// System.out.println("Fail to parse:" + lexer.getTokens().get(i).getValue());
// System.out.println("Fail to parse:" + parseTokens.get(i).getValue());
try {
throw new ParseFailedException("Parse failed!");
}
@ -234,11 +237,11 @@ public class OracleParser {
return root;
}
private ASTNode parseInsert() {
private ASTNode parseInsert(List<Token> parseTokens) {
List <Token> tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(0));
tokens.add(parseTokens.get(0));
try {
tokens.add(lexer.getTokens().get(1));
tokens.add(parseTokens.get(1));
}
catch (ParseFailedException e) {
e.printStackTrace();
@ -246,14 +249,14 @@ public class OracleParser {
ASTNode root = new InsertNode(tokens);
ASTNode currentNode = root;
for (int i = 2; i < lexer.getTokens().size(); i++) {
if (lexer.getTokens().get(i).hasType(Token.TokenType.IDENTIFIER)) { // table name
for (int i = 2; i < parseTokens.size(); i++) {
if (parseTokens.get(i).hasType(Token.TokenType.IDENTIFIER)) { // table name
tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(i));
if (i + 1 < lexer.getTokens().size() && ! (lexer.getTokens().get(i + 1).hasType(Token.TokenType.KEYWORD) && lexer.getTokens().get(i + 1).getValue().equalsIgnoreCase("VALUES"))) {
for (int j = i + 1; j < lexer.getTokens().size(); j++) {
tokens.add(lexer.getTokens().get(j));
if (lexer.getTokens().get(j).hasType(Token.TokenType.SYMBOL) && lexer.getTokens().get(j).getValue().equals(")")) {
tokens.add(parseTokens.get(i));
if (i + 1 < parseTokens.size() && ! (parseTokens.get(i + 1).hasType(Token.TokenType.KEYWORD) && parseTokens.get(i + 1).getValue().equalsIgnoreCase("VALUES"))) {
for (int j = i + 1; j < parseTokens.size(); j++) {
tokens.add(parseTokens.get(j));
if (parseTokens.get(j).hasType(Token.TokenType.SYMBOL) && parseTokens.get(j).getValue().equals(")")) {
i = j;
break;
}
@ -263,28 +266,28 @@ public class OracleParser {
currentNode.addChild(childNode);
currentNode = childNode;
}
else if (lexer.getTokens().get(i).hasType(Token.TokenType.KEYWORD) && lexer.getTokens().get(i).getValue().equalsIgnoreCase("VALUES")) {
else if (parseTokens.get(i).hasType(Token.TokenType.KEYWORD) && parseTokens.get(i).getValue().equalsIgnoreCase("VALUES")) {
tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(i));
for (int j = i + 1; j < lexer.getTokens().size(); j++) {
if (lexer.getTokens().get(j).hasType(Token.TokenType.SYMBOL) && lexer.getTokens().get(j).getValue().equals(";")) {
tokens.add(parseTokens.get(i));
for (int j = i + 1; j < parseTokens.size(); j++) {
if (parseTokens.get(j).hasType(Token.TokenType.SYMBOL) && parseTokens.get(j).getValue().equals(";")) {
i = j - 1;
break;
}
tokens.add(lexer.getTokens().get(j));
tokens.add(parseTokens.get(j));
}
ASTNode childNode = new InsertDataNode(tokens);
currentNode.addChild(childNode);
currentNode = childNode;
}
else if (lexer.getTokens().get(i).hasType(Token.TokenType.SYMBOL) && lexer.getTokens().get(i).getValue().equals(";")) {
else if (parseTokens.get(i).hasType(Token.TokenType.SYMBOL) && parseTokens.get(i).getValue().equals(";")) {
tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(i));
tokens.add(parseTokens.get(i));
ASTNode childNode = new InsertEndNode(tokens);
currentNode.addChild(childNode);
currentNode = childNode;
}
else if (lexer.getTokens().get(i).hasType(Token.TokenType.EOF)) {
else if (parseTokens.get(i).hasType(Token.TokenType.EOF)) {
break;
}
else {
@ -302,11 +305,11 @@ public class OracleParser {
}
// Drop table
private ASTNode parseDrop() {
private ASTNode parseDrop(List<Token> parseTokens) {
List <Token> tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(0));
tokens.add(parseTokens.get(0));
try {
tokens.add(lexer.getTokens().get(1));
tokens.add(parseTokens.get(1));
}
catch (ParseFailedException e) {
e.printStackTrace();
@ -314,33 +317,33 @@ public class OracleParser {
ASTNode root = new DropTableNode(tokens);
ASTNode currentNode = root;
for (int i = 2; i < lexer.getTokens().size(); i++) {
if (lexer.getTokens().get(i).hasType(Token.TokenType.IDENTIFIER)) {
for (int i = 2; i < parseTokens.size(); i++) {
if (parseTokens.get(i).hasType(Token.TokenType.IDENTIFIER)) {
tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(i));
tokens.add(parseTokens.get(i));
ASTNode childNode = new DropTableNameNode(tokens);
currentNode.addChild(childNode);
currentNode = childNode;
}
else if (lexer.getTokens().get(i).hasType(Token.TokenType.KEYWORD) && lexer.getTokens().get(i).getValue().equalsIgnoreCase("CASCADE")) {
else if (parseTokens.get(i).hasType(Token.TokenType.KEYWORD) && parseTokens.get(i).getValue().equalsIgnoreCase("CASCADE")) {
tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(i));
if (i + 1 < lexer.getTokens().size() && (lexer.getTokens().get(i + 1).hasType(Token.TokenType.KEYWORD) && lexer.getTokens().get(i + 1).getValue().equals("CONSTRAINTS"))) {
tokens.add(lexer.getTokens().get(i + 1));
tokens.add(parseTokens.get(i));
if (i + 1 < parseTokens.size() && (parseTokens.get(i + 1).hasType(Token.TokenType.KEYWORD) && parseTokens.get(i + 1).getValue().equals("CONSTRAINTS"))) {
tokens.add(parseTokens.get(i + 1));
i++;
}
ASTNode childNode = new DropTableOptionNode(tokens);
currentNode.addChild(childNode);
currentNode = childNode;
}
else if (lexer.getTokens().get(i).hasType(Token.TokenType.SYMBOL) && lexer.getTokens().get(i).getValue().equals(";")) {
else if (parseTokens.get(i).hasType(Token.TokenType.SYMBOL) && parseTokens.get(i).getValue().equals(";")) {
tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(i));
tokens.add(parseTokens.get(i));
ASTNode childNode = new DropTableEndNode(tokens);
currentNode.addChild(childNode);
currentNode = childNode;
}
else if (lexer.getTokens().get(i).hasType(Token.TokenType.EOF)) {
else if (parseTokens.get(i).hasType(Token.TokenType.EOF)) {
break;
}
else {
@ -356,21 +359,84 @@ public class OracleParser {
return root;
}
private ASTNode parseSelect() {
private ASTNode parseSelect(List<Token> parseTokens) {
List <Token> tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(0));
tokens.add(parseTokens.get(0));
ASTNode root = new SelectNode(tokens);
ASTNode currentNode = root;
return root;
}
private ASTNode parseCaseWhen() {
/**
* CASE WHEN expr THEN expr [ELSE expr] END
*/
private ASTNode parseCaseWhen(List<Token> parseTokens) {
List <Token> tokens = new ArrayList<>();
tokens.add(lexer.getTokens().get(0));
ASTNode root = new SelectNode(tokens);
tokens.add(parseTokens.get(0));
try {
tokens.add(parseTokens.get(1));
}
catch (ParseFailedException e) {
e.printStackTrace();
}
int currentIndex = 2;
for (int i = currentIndex; i < parseTokens.size(); i++) {
tokens.add(parseTokens.get(i));
if (parseTokens.get(i).hasType(Token.TokenType.KEYWORD) && parseTokens.get(i).getValue().equalsIgnoreCase("THEN")) {
currentIndex = i;
break;
}
}
ASTNode root = new CaseConditionNode(tokens);
ASTNode currentNode = root;
tokens = new ArrayList<>();
for (int i = currentIndex; i < parseTokens.size(); i++) {
tokens.add(parseTokens.get(i));
if ( (parseTokens.get(i).hasType(Token.TokenType.KEYWORD) && parseTokens.get(i).getValue().equalsIgnoreCase("ELSE"))
|| (parseTokens.get(i).hasType(Token.TokenType.KEYWORD) && parseTokens.get(i).getValue().equalsIgnoreCase("END")) ) {
currentIndex = i;
break;
}
}
ASTNode childNode = new CaseThenNode(tokens);
currentNode.addChild(childNode);
currentNode = childNode;
tokens = new ArrayList<>();
for (int i = currentIndex; i < parseTokens.size(); i++) {
if (parseTokens.get(i).hasType(Token.TokenType.KEYWORD) && parseTokens.get(i).getValue().equalsIgnoreCase("ELSE")) {
for (int j = i; j < parseTokens.size(); j++) {
tokens.add(parseTokens.get(j));
if (parseTokens.get(j).hasType(Token.TokenType.KEYWORD) && parseTokens.get(j).getValue().equalsIgnoreCase("END")) {
childNode = new CaseElseNode(tokens);
currentNode.addChild(childNode);
currentNode = childNode;
i = j;
break;
}
}
}
else if (parseTokens.get(i).hasType(Token.TokenType.KEYWORD) && parseTokens.get(i).getValue().equalsIgnoreCase("END")) {
tokens = new ArrayList<>();
tokens.add(parseTokens.get(i));
childNode = new CaseEndNode(tokens);
currentNode.addChild(childNode);
currentNode = childNode;
break;
}
else {
try {
throw new ParseFailedException("Parse failed!");
}
catch (ParseFailedException e) {
e.printStackTrace();
}
}
}
return root;
}