From 54a4bf3db0d327b79e9ad3fa550feb1e2fd987e9 Mon Sep 17 00:00:00 2001
From: XudongXie <xiexudong23@otcaix.iscas.ac.cn>
Date: Tue, 10 Sep 2024 16:48:55 +0800
Subject: [PATCH] revise

---
 sqlTranslate/.idea/workspace.xml              |  19 +-
 sqlTranslate/src/main/java/Main.java          |  16 +-
 .../src/main/java/Parser/OracleParser.java    | 280 +++++++++++-------
 3 files changed, 193 insertions(+), 122 deletions(-)

diff --git a/sqlTranslate/.idea/workspace.xml b/sqlTranslate/.idea/workspace.xml
index c2120bd1..4aae095a 100644
--- a/sqlTranslate/.idea/workspace.xml
+++ b/sqlTranslate/.idea/workspace.xml
@@ -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>
diff --git a/sqlTranslate/src/main/java/Main.java b/sqlTranslate/src/main/java/Main.java
index 883902c4..12a70a15 100644
--- a/sqlTranslate/src/main/java/Main.java
+++ b/sqlTranslate/src/main/java/Main.java
@@ -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);
diff --git a/sqlTranslate/src/main/java/Parser/OracleParser.java b/sqlTranslate/src/main/java/Parser/OracleParser.java
index c5034ede..38d615c3 100644
--- a/sqlTranslate/src/main/java/Parser/OracleParser.java
+++ b/sqlTranslate/src/main/java/Parser/OracleParser.java
@@ -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;
     }