diff --git a/sqlTranslate/.idea/workspace.xml b/sqlTranslate/.idea/workspace.xml index 783ee2933..72c990a7b 100644 --- a/sqlTranslate/.idea/workspace.xml +++ b/sqlTranslate/.idea/workspace.xml @@ -5,10 +5,22 @@ - - - + + + + + + + + + + + + + + + - - + + + + + + + + - + - - - - - - - + - - - - - + + + + + - - - - - + + + + + @@ -480,7 +501,7 @@ diff --git a/sqlTranslate/src/main/java/Main.java b/sqlTranslate/src/main/java/Main.java index 59442883d..b17eed35b 100644 --- a/sqlTranslate/src/main/java/Main.java +++ b/sqlTranslate/src/main/java/Main.java @@ -57,32 +57,32 @@ public class Main { // " DBMS_OUTPUT.PUT_LINE('Caught an exception: Invalid number');\n" + // " WHEN OTHERS THEN\n" + // " DBMS_OUTPUT.PUT_LINE('Caught an exception: ' || SQLERRM);"; -// String sql = "CREATE OR REPLACE PROCEDURE update_salary (\n" + -// " employee_id IN NUMBER,\n" + -// " new_salary IN OUT NUMBER\n" + -// " ) IS\n" + -// " v_employee NUMBER;\n" + -// " BEGIN\n" + -// " SELECT * INTO v_employee FROM employees WHERE employee_id = employee_id;\n" + -// "\n" + -// " IF new_salary < 3000 THEN\n" + -// " new_salary := new_salary * 1.1;\n" + -// " ELSE\n" + -// " new_salary := new_salary * 1.05;\n" + -// " END IF;\n" + -// "\n" + -// " UPDATE employees SET salary = new_salary WHERE employee_id = employee_id;\n" + -// " COMMIT;\n" + -// "\n" + -// " DBMS_OUTPUT.PUT_LINE('Updated Salary: ' || new_salary);\n" + -// " EXCEPTION\n" + -// " WHEN NO_DATA_FOUND THEN\n" + -// " DBMS_OUTPUT.PUT_LINE('Employee not found.');\n" + -// " WHEN TOO_MANY_ROWS THEN\n" + -// " DBMS_OUTPUT.PUT_LINE('Multiple employees found.');\n" + -// " WHEN OTHERS THEN\n" + -// " DBMS_OUTPUT.PUT_LINE('An error occurred: ' || SQLERRM);\n" + -// " END update_salary;\n"; + String sql = "CREATE OR REPLACE PROCEDURE update_salary (\n" + + " employee_id IN NUMBER,\n" + + " new_salary IN OUT NUMBER\n" + + " ) IS\n" + + " v_employee NUMBER;\n" + + " BEGIN\n" + + " SELECT * INTO v_employee FROM employees WHERE employee_id = employee_id;\n" + + "\n" + + " IF new_salary < 3000 THEN\n" + + " new_salary := new_salary * 1.1;\n" + + " ELSE\n" + + " new_salary := new_salary * 1.05;\n" + + " END IF;\n" + + "\n" + + " UPDATE employees SET salary = new_salary WHERE employee_id = employee_id;\n" + + " COMMIT;\n" + + "\n" + + " DBMS_OUTPUT.PUT_LINE('Updated Salary: ' || new_salary);\n" + + " EXCEPTION\n" + + " WHEN NO_DATA_FOUND THEN\n" + + " DBMS_OUTPUT.PUT_LINE('Employee not found.');\n" + + " WHEN TOO_MANY_ROWS THEN\n" + + " DBMS_OUTPUT.PUT_LINE('Multiple employees found.');\n" + + " WHEN OTHERS THEN\n" + + " DBMS_OUTPUT.PUT_LINE('An error occurred: ' || SQLERRM);\n" + + " END update_salary;\n"; // String sql = "CREATE OR REPLACE FUNCTION string_length (\n" + // " input_string VARCHAR2\n" + // ") RETURN NUMBER IS\n" + @@ -95,13 +95,13 @@ public class Main { // " BEGIN\n" + // " INSERT INTO audit_log (action, employee_id) VALUES ('INSERT', :NEW.id);\n" + // " END;"; - String sql = "DECLARE\n" + - " v_name Varchar2(20);\n" + - " v_salary employees.salary%TYPE;\n" + - " BEGIN\n" + - " SELECT name, salary INTO v_name, v_salary FROM employees WHERE employee_id = 100;\n" + - " DBMS_OUTPUT.PUT_LINE('Name: ' || v_name || ', Salary: ' || v_salary);\n" + - " END;"; +// String sql = "DECLARE\n" + +// " v_name Varchar2(20);\n" + +// " v_salary employees.salary%TYPE;\n" + +// " BEGIN\n" + +// " SELECT name, salary INTO v_name, v_salary FROM employees WHERE employee_id = 100;\n" + +// " DBMS_OUTPUT.PUT_LINE('Name: ' || v_name || ', Salary: ' || v_salary);\n" + +// " END;"; OracleLexer lexer = new OracleLexer(sql); lexer.printTokens(); OracleParser parser = new OracleParser(lexer); diff --git a/sqlTranslate/src/main/java/generator/OpenGaussGenerator.java b/sqlTranslate/src/main/java/generator/OpenGaussGenerator.java index 30224eea9..9ae034c9d 100644 --- a/sqlTranslate/src/main/java/generator/OpenGaussGenerator.java +++ b/sqlTranslate/src/main/java/generator/OpenGaussGenerator.java @@ -20,6 +20,7 @@ import parser.ast.function.FunctionColumnNode; import parser.ast.function.FunctionEndNode; import parser.ast.function.FunctionNode; import parser.ast.function.FunctionRetDefNode; +import parser.ast.iFELSIF.IFConditionNode; import parser.ast.insert.InsertNode; import parser.ast.join.JoinConditionNode; import parser.ast.join.JoinSourceTabNode; @@ -31,10 +32,7 @@ import parser.ast.pl.PLBodyNode; import parser.ast.pl.PLDeclareNode; import parser.ast.pl.PLEndNode; import parser.ast.pl.PLNode; -import parser.ast.procedure.ProcedureColumnNode; -import parser.ast.procedure.ProcedureEndNode; -import parser.ast.procedure.ProcedureNode; -import parser.ast.procedure.ProcedureRetDefNode; +import parser.ast.procedure.*; import parser.ast.select.SelectNode; import parser.ast.trigger.*; import parser.ast.update.UpdateNode; @@ -101,6 +99,9 @@ public class OpenGaussGenerator { else if (node instanceof PLNode) { return GenPLSQL(node); } + else if (node instanceof IFConditionNode) { + return GenIfElseSQL(node); + } else { try { throw new GenerateFailedException("Root node:" + node.getClass() + "(Unsupported node type!)"); @@ -189,6 +190,12 @@ public class OpenGaussGenerator { private String GenPLSQL(ASTNode node) { visitPLSQL(node); +// System.out.println(node.getASTString()); + return node.toQueryString(); + } + + private String GenIfElseSQL(ASTNode node) { + visitIfElse(node); return node.toQueryString(); } @@ -240,6 +247,13 @@ public class OpenGaussGenerator { } } + private void visitIfElse(ASTNode node) { + + for (ASTNode child : node.getChildren()) { + visitIfElse(child); + } + } + private void visitException(ASTNode node) { if (CommonConfig.getSourceDB().equalsIgnoreCase("ORACLE-19C") && CommonConfig.getTargetDB().equalsIgnoreCase("OPENGAUSS-3.0.0")) { @@ -319,6 +333,9 @@ public class OpenGaussGenerator { else if (node instanceof ExceptionNode) { visitException(node); } + else if (node instanceof ProcedurePLStatementNode) { + CommonConvert(node); + } } for (ASTNode child : node.getChildren()) { visitPL(child); @@ -388,8 +405,10 @@ public class OpenGaussGenerator { private void CommonConvert(ASTNode node) { if (node.checkExistsByRegex("(?i)DBMS_OUTPUT.PUT_LINE\\(.*?\\)")) { String printObj = ""; + int index = -1; for (Token token: node.getTokens()) { if (token.getValue().matches("(?i)DBMS_OUTPUT.PUT_LINE\\(.*?\\)")) { + index = node.getTokenIndexByRegex("(?i)DBMS_OUTPUT.PUT_LINE\\(.*?\\)"); Pattern pattern = Pattern.compile("\\(([^()]*)\\)"); Matcher matcher = pattern.matcher(token.getValue()); while (matcher.find()) { @@ -405,8 +424,8 @@ public class OpenGaussGenerator { tokens.add(new Token(Token.TokenType.STRING, "'%'")); tokens.add(new Token(Token.TokenType.SYMBOL, ",")); tokens.add(new Token(Token.TokenType.IDENTIFIER, printObj)); - tokens.add(new Token(Token.TokenType.SYMBOL, ";")); - node.setTokens(tokens); + node.moveTokenByIndex(index); + node.addTokensByIndex(index, tokens); } else { OracleLexer lexer = new OracleLexer(printObj.replace("||", " ")); @@ -433,8 +452,8 @@ public class OpenGaussGenerator { tokens.add(new Token(Token.TokenType.SYMBOL, ",")); tokens.add(token); } - tokens.add(new Token(Token.TokenType.SYMBOL, ";")); - node.setTokens(tokens); + node.moveTokenByIndex(index); + node.addTokensByIndex(index, tokens); } else { List tokens = new ArrayList<>(); @@ -443,8 +462,8 @@ public class OpenGaussGenerator { tokens.add(new Token(Token.TokenType.STRING, "'%'")); tokens.add(new Token(Token.TokenType.SYMBOL, ",")); tokens.add(new Token(Token.TokenType.STRING, "'" + output + "'")); - tokens.add(new Token(Token.TokenType.SYMBOL, ";")); - node.setTokens(tokens); + node.moveTokenByIndex(index); + node.addTokensByIndex(index, tokens); } } diff --git a/sqlTranslate/src/main/java/parser/ast/ASTNode.java b/sqlTranslate/src/main/java/parser/ast/ASTNode.java index f927fe477..5bce8b93a 100644 --- a/sqlTranslate/src/main/java/parser/ast/ASTNode.java +++ b/sqlTranslate/src/main/java/parser/ast/ASTNode.java @@ -4,6 +4,8 @@ import lexer.Token; import java.util.ArrayList; import java.util.List; +import java.util.Optional; +import java.util.regex.Pattern; public abstract class ASTNode { private List tokens; @@ -31,6 +33,37 @@ public abstract class ASTNode { this.tokens = tokens; } + public void modifyTokens(int index, Token token) { + tokens.set(index, token); + } + + public void moveTokenByIndex(int index) { + tokens.remove(index); + } + + public void addTokenByIndex(int index, Token token) { + tokens.add(index, token); + } + + public void addTokensByIndex(int index, List tokens) { + this.tokens.addAll(index, tokens); + } + + public int getTokenIndexByRegex(String regex) { + Pattern pattern = Pattern.compile(regex); + Optional indexOpt = tokens.stream() + .filter(token -> pattern.matcher(token.getValue()).matches()) + .map(token -> tokens.indexOf(token)) + .findFirst(); + if (indexOpt.isPresent()) { + int index = indexOpt.get(); + return index; + } else { + return -1; + } + + } + public boolean checkExistsByRegex (String regex) { return tokens.stream().anyMatch(token -> token.getValue().matches(regex)); } diff --git a/sqlTranslate/src/main/java/parser/ast/function/FunctionRetDefNode.java b/sqlTranslate/src/main/java/parser/ast/function/FunctionRetDefNode.java index 73723d2b0..f46a01e2f 100644 --- a/sqlTranslate/src/main/java/parser/ast/function/FunctionRetDefNode.java +++ b/sqlTranslate/src/main/java/parser/ast/function/FunctionRetDefNode.java @@ -12,6 +12,7 @@ public class FunctionRetDefNode extends ASTNode implements DataType { public FunctionRetDefNode() { super(); setTokens(new ArrayList<>()); + setType(new Token(Token.TokenType.NULL, "")); } public FunctionRetDefNode(ASTNode node) { diff --git a/sqlTranslate/src/main/java/parser/ast/procedure/ProcedureRetDefNode.java b/sqlTranslate/src/main/java/parser/ast/procedure/ProcedureRetDefNode.java index 7d063145e..8164b25f5 100644 --- a/sqlTranslate/src/main/java/parser/ast/procedure/ProcedureRetDefNode.java +++ b/sqlTranslate/src/main/java/parser/ast/procedure/ProcedureRetDefNode.java @@ -12,6 +12,7 @@ public class ProcedureRetDefNode extends ASTNode implements DataType { public ProcedureRetDefNode() { super(); setTokens(new ArrayList<>()); + setType(new Token(Token.TokenType.NULL, "")); } public ProcedureRetDefNode(ASTNode node) { diff --git a/sqlTranslate/src/test/java/testFunction.java b/sqlTranslate/src/test/java/testFunction.java new file mode 100644 index 000000000..94a63d427 --- /dev/null +++ b/sqlTranslate/src/test/java/testFunction.java @@ -0,0 +1,51 @@ +import config.CommonConfig; +import generator.OpenGaussGenerator; +import lexer.OracleLexer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import parser.OracleParser; +import parser.ast.ASTNode; + +import java.util.ArrayList; +import java.util.List; + +public class testFunction { + List testSQL = new ArrayList<>(); + @BeforeEach + public void loadData() + { + testSQL.add("CREATE OR REPLACE FUNCTION string_length (\n" + + " input_string VARCHAR2\n" + + " ) RETURN NUMBER IS\n" + + " BEGIN\n" + + " RETURN LENGTH(input_string);\n" + + " END;"); + System.out.println("===== test of Function ====="); + System.out.println("The source DBMS is: " + CommonConfig.getSourceDB()); + System.out.println("The target DBMS is: " + CommonConfig.getTargetDB()); + System.out.println(); + } + + @Test + public void test() + { + int num = 1; + for (String sql : testSQL) { + System.out.println("===== test the SQL" + num++ + " ====="); + System.out.println("Input SQL: " + sql); + OracleLexer lexer = new OracleLexer(sql); + lexer.printTokens(); + OracleParser parser = new OracleParser(lexer); + ASTNode root = parser.parse(); + System.out.println("The AST of the input SQL: "); + System.out.println(root.getASTString()); + System.out.println("The query String of the AST parsed from the input SQL: "); + System.out.println(root.toQueryString()); + OpenGaussGenerator generator = new OpenGaussGenerator(root); + System.out.println("The converted query String: "); + System.out.println(generator.generate()); + + System.out.println(); + } + } +} diff --git a/sqlTranslate/src/test/java/testIfElse.java b/sqlTranslate/src/test/java/testIfElse.java new file mode 100644 index 000000000..39c930b91 --- /dev/null +++ b/sqlTranslate/src/test/java/testIfElse.java @@ -0,0 +1,53 @@ +import config.CommonConfig; +import generator.OpenGaussGenerator; +import lexer.OracleLexer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import parser.OracleParser; +import parser.ast.ASTNode; + +import java.util.ArrayList; +import java.util.List; + +public class testIfElse { + List testSQL = new ArrayList<>(); + @BeforeEach + public void loadData() + { + testSQL.add("IF v_salary >= 100000 THEN\n" + + " v_bonus := v_salary * 0.1;\n" + + " ELSIF v_salary >= 50000 THEN\n" + + " v_bonus := v_salary * 0.08;\n" + + " ELSIF v_salary >= 30000 THEN\n" + + " v_bonus := v_salary * 0.05;\n" + + " ELSE\n" + + " v_bonus := v_salary * 0.03;\n" + + " END IF;"); + System.out.println("===== test of IfElse ====="); + System.out.println("The source DBMS is: " + CommonConfig.getSourceDB()); + System.out.println("The target DBMS is: " + CommonConfig.getTargetDB()); + System.out.println(); + } + + @Test + public void test() + { + int num = 1; + for (String sql : testSQL) { + System.out.println("===== test the SQL" + num++ + " ====="); + System.out.println("Input SQL: " + sql); + OracleLexer lexer = new OracleLexer(sql); + lexer.printTokens(); + ASTNode root = OracleParser.parseIFELSE(lexer.getTokens()); + System.out.println("The AST of the input SQL: "); + System.out.println(root.getASTString()); + System.out.println("The query String of the AST parsed from the input SQL: "); + System.out.println(root.toQueryString()); + OpenGaussGenerator generator = new OpenGaussGenerator(root); + System.out.println("The converted query String: "); + System.out.println(generator.generate()); + + System.out.println(); + } + } +} diff --git a/sqlTranslate/src/test/java/testInsert.java b/sqlTranslate/src/test/java/testInsert.java new file mode 100644 index 000000000..673cbbfdb --- /dev/null +++ b/sqlTranslate/src/test/java/testInsert.java @@ -0,0 +1,47 @@ +import config.CommonConfig; +import generator.OpenGaussGenerator; +import lexer.OracleLexer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import parser.OracleParser; +import parser.ast.ASTNode; + +import java.util.ArrayList; +import java.util.List; + +public class testInsert { + List testSQL = new ArrayList<>(); + @BeforeEach + public void loadData() + { + testSQL.add("INSERT INTO employees (first_name, last_name, email) VALUES ('Jane', 'Smith', 'janesm@example.com');"); + testSQL.add("INSERT INTO employees VALUES ('Jane', 'Smith', 'janesm@example.com');"); + System.out.println("===== test of Insert ====="); + System.out.println("The source DBMS is: " + CommonConfig.getSourceDB()); + System.out.println("The target DBMS is: " + CommonConfig.getTargetDB()); + System.out.println(); + } + + @Test + public void test() + { + int num = 1; + for (String sql : testSQL) { + System.out.println("===== test the SQL" + num++ + " ====="); + System.out.println("Input SQL: " + sql); + OracleLexer lexer = new OracleLexer(sql); + lexer.printTokens(); + OracleParser parser = new OracleParser(lexer); + ASTNode root = parser.parse(); + System.out.println("The AST of the input SQL: "); + System.out.println(root.getASTString()); + System.out.println("The query String of the AST parsed from the input SQL: "); + System.out.println(root.toQueryString()); + OpenGaussGenerator generator = new OpenGaussGenerator(root); + System.out.println("The converted query String: "); + System.out.println(generator.generate()); + + System.out.println(); + } + } +} diff --git a/sqlTranslate/src/test/java/testLoop.java b/sqlTranslate/src/test/java/testLoop.java new file mode 100644 index 000000000..a31e38887 --- /dev/null +++ b/sqlTranslate/src/test/java/testLoop.java @@ -0,0 +1,56 @@ +import config.CommonConfig; +import generator.OpenGaussGenerator; +import lexer.OracleLexer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import parser.OracleParser; +import parser.ast.ASTNode; + +import java.util.ArrayList; +import java.util.List; + +public class testLoop { + List testSQL = new ArrayList<>(); + @BeforeEach + public void loadData() + { + testSQL.add("LOOP\n" + + " DBMS_OUTPUT.PUT_LINE(v_counter);\n" + + " v_counter := v_counter + 1;\n" + + " EXIT WHEN v_counter > 10;\n" + + " END LOOP;"); + testSQL.add("WHILE v_counter <= 10 LOOP\n" + + " DBMS_OUTPUT.PUT_LINE(v_counter);\n" + + " v_counter := v_counter + 1;\n" + + " END LOOP;"); + testSQL.add("FOR i IN 1..10 LOOP\n" + + " DBMS_OUTPUT.PUT_LINE(i);\n" + + " END LOOP;"); + System.out.println("===== test of Loop ====="); + System.out.println("The source DBMS is: " + CommonConfig.getSourceDB()); + System.out.println("The target DBMS is: " + CommonConfig.getTargetDB()); + System.out.println(); + } + + @Test + public void test() + { + int num = 1; + for (String sql : testSQL) { + System.out.println("===== test the SQL" + num++ + " ====="); + System.out.println("Input SQL: " + sql); + OracleLexer lexer = new OracleLexer(sql); + lexer.printTokens(); + ASTNode root = OracleParser.parseLoop(lexer.getTokens()); + System.out.println("The AST of the input SQL: "); + System.out.println(root.getASTString()); + System.out.println("The query String of the AST parsed from the input SQL: "); + System.out.println(root.toQueryString()); + OpenGaussGenerator generator = new OpenGaussGenerator(root); + System.out.println("The converted query String: "); + System.out.println(generator.generate()); + + System.out.println(); + } + } +} diff --git a/sqlTranslate/src/test/java/testPL.java b/sqlTranslate/src/test/java/testPL.java new file mode 100644 index 000000000..ddeeb6f8e --- /dev/null +++ b/sqlTranslate/src/test/java/testPL.java @@ -0,0 +1,55 @@ +import config.CommonConfig; +import generator.OpenGaussGenerator; +import lexer.OracleLexer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import parser.OracleParser; +import parser.ast.ASTNode; + +import java.util.ArrayList; +import java.util.List; + +public class testPL { + List testSQL = new ArrayList<>(); + @BeforeEach + public void loadData() + { + testSQL.add("DECLARE\n" + + " v_name Varchar2(20);\n" + + " v_salary employees.salary%TYPE;\n" + + " BEGIN\n" + + " SELECT name, salary INTO v_name, v_salary FROM employees WHERE employee_id = 100;\n" + + " DBMS_OUTPUT.PUT_LINE('Name: ' || v_name || ', Salary: ' || v_salary);\n" + + " EXCEPTION\n" + + " WHEN NO_DATA_FOUND THEN\n" + + " DBMS_OUTPUT.PUT_LINE('No data found.');\n" + + " END;"); + System.out.println("===== test of PL ====="); + System.out.println("The source DBMS is: " + CommonConfig.getSourceDB()); + System.out.println("The target DBMS is: " + CommonConfig.getTargetDB()); + System.out.println(); + } + + @Test + public void test() + { + int num = 1; + for (String sql : testSQL) { + System.out.println("===== test the SQL" + num++ + " ====="); + System.out.println("Input SQL: " + sql); + OracleLexer lexer = new OracleLexer(sql); + lexer.printTokens(); + OracleParser parser = new OracleParser(lexer); + ASTNode root = parser.parse(); + System.out.println("The AST of the input SQL: "); + System.out.println(root.getASTString()); + System.out.println("The query String of the AST parsed from the input SQL: "); + System.out.println(root.toQueryString()); + OpenGaussGenerator generator = new OpenGaussGenerator(root); + System.out.println("The converted query String: "); + System.out.println(generator.generate()); + + System.out.println(); + } + } +} diff --git a/sqlTranslate/src/test/java/testProcedure.java b/sqlTranslate/src/test/java/testProcedure.java new file mode 100644 index 000000000..7069351ad --- /dev/null +++ b/sqlTranslate/src/test/java/testProcedure.java @@ -0,0 +1,68 @@ +import config.CommonConfig; +import generator.OpenGaussGenerator; +import lexer.OracleLexer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import parser.OracleParser; +import parser.ast.ASTNode; + +import java.util.ArrayList; +import java.util.List; + +public class testProcedure { + List testSQL = new ArrayList<>(); + @BeforeEach + public void loadData() + { + testSQL.add("CREATE OR REPLACE PROCEDURE update_salary (\n" + + " employee_id IN NUMBER,\n" + + " new_salary IN OUT NUMBER\n" + + " ) IS\n" + + " v_employee employees%ROWTYPE;\n" + + " BEGIN\n" + + " SELECT * INTO v_employee FROM employees WHERE employee_id = employee_id;\n" + + " IF new_salary < 3000 THEN\n" + + " new_salary := new_salary * 1.1;\n" + + " ELSE\n" + + " new_salary := new_salary * 1.05;\n" + + " END IF;\n" + + " UPDATE employees SET salary = new_salary WHERE employee_id = employee_id;\n" + + " COMMIT;\n" + + " DBMS_OUTPUT.PUT_LINE('Updated Salary: ' || new_salary);\n" + + " EXCEPTION\n" + + " WHEN NO_DATA_FOUND THEN\n" + + " DBMS_OUTPUT.PUT_LINE('Employee not found.');\n" + + " WHEN TOO_MANY_ROWS THEN\n" + + " DBMS_OUTPUT.PUT_LINE('Multiple employees found.');\n" + + " WHEN OTHERS THEN\n" + + " DBMS_OUTPUT.PUT_LINE('An error occurred: ' || SQLERRM);\n" + + " END update_salary;"); + System.out.println("===== test of Procedure ====="); + System.out.println("The source DBMS is: " + CommonConfig.getSourceDB()); + System.out.println("The target DBMS is: " + CommonConfig.getTargetDB()); + System.out.println(); + } + + @Test + public void test() + { + int num = 1; + for (String sql : testSQL) { + System.out.println("===== test the SQL" + num++ + " ====="); + System.out.println("Input SQL: " + sql); + OracleLexer lexer = new OracleLexer(sql); + lexer.printTokens(); + OracleParser parser = new OracleParser(lexer); + ASTNode root = parser.parse(); + System.out.println("The AST of the input SQL: "); + System.out.println(root.getASTString()); + System.out.println("The query String of the AST parsed from the input SQL: "); + System.out.println(root.toQueryString()); + OpenGaussGenerator generator = new OpenGaussGenerator(root); + System.out.println("The converted query String: "); + System.out.println(generator.generate()); + + System.out.println(); + } + } +} diff --git a/sqlTranslate/src/test/java/testSelect.java b/sqlTranslate/src/test/java/testSelect.java new file mode 100644 index 000000000..ad319651a --- /dev/null +++ b/sqlTranslate/src/test/java/testSelect.java @@ -0,0 +1,58 @@ +import config.CommonConfig; +import generator.OpenGaussGenerator; +import lexer.OracleLexer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import parser.OracleParser; +import parser.ast.ASTNode; + +import java.util.ArrayList; +import java.util.List; + +public class testSelect { + List testSQL = new ArrayList<>(); + @BeforeEach + public void loadData() + { + testSQL.add("SELECT * FROM employees;"); + testSQL.add("SELECT employee_id, first_name, last_name FROM employees;"); + testSQL.add("SELECT * FROM employees WHERE department_id = 10;"); + testSQL.add("SELECT * FROM employees ORDER BY hire_date DESC;"); + testSQL.add("SELECT COUNT(*), AVG(salary) FROM employees;"); + testSQL.add("SELECT department_id, COUNT(*) FROM employees GROUP BY department_id;"); + testSQL.add("SELECT e.first_name, d.department_name FROM employees e JOIN departments d ON e.department_id = d.department_id;"); + testSQL.add("SELECT\n" + + " column1,\n" + + " CASE WHEN column2 > 0 THEN 'Positive' ELSE 'Non-positive' END as status,\n" + + " SUBSTR(column3, 1, 5) as substring_column3\n" + + " FROM table_name;"); + testSQL.add("SELECT column1, COUNT(column2) FROM table_name GROUP BY column1 HAVING COUNT(column2) > 10;"); + System.out.println("===== test of Select ====="); + System.out.println("The source DBMS is: " + CommonConfig.getSourceDB()); + System.out.println("The target DBMS is: " + CommonConfig.getTargetDB()); + System.out.println(); + } + + @Test + public void test() + { + int num = 1; + for (String sql : testSQL) { + System.out.println("===== test the SQL" + num++ + " ====="); + System.out.println("Input SQL: " + sql); + OracleLexer lexer = new OracleLexer(sql); + lexer.printTokens(); + OracleParser parser = new OracleParser(lexer); + ASTNode root = parser.parse(); + System.out.println("The AST of the input SQL: "); + System.out.println(root.getASTString()); + System.out.println("The query String of the AST parsed from the input SQL: "); + System.out.println(root.toQueryString()); + OpenGaussGenerator generator = new OpenGaussGenerator(root); + System.out.println("The converted query String: "); + System.out.println(generator.generate()); + + System.out.println(); + } + } +} diff --git a/sqlTranslate/src/test/java/testTrigger.java b/sqlTranslate/src/test/java/testTrigger.java new file mode 100644 index 000000000..bc7d067c5 --- /dev/null +++ b/sqlTranslate/src/test/java/testTrigger.java @@ -0,0 +1,51 @@ +import config.CommonConfig; +import generator.OpenGaussGenerator; +import lexer.OracleLexer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import parser.OracleParser; +import parser.ast.ASTNode; + +import java.util.ArrayList; +import java.util.List; + +public class testTrigger { + List testSQL = new ArrayList<>(); + @BeforeEach + public void loadData() + { + testSQL.add("CREATE OR REPLACE TRIGGER log_insert\n" + + " BEFORE INSERT ON employees\n" + + " FOR EACH ROW\n" + + " BEGIN\n" + + " INSERT INTO audit_log (action, employee_id) VALUES ('INSERT', :NEW.id);\n" + + " END;"); + System.out.println("===== test of Trigger ====="); + System.out.println("The source DBMS is: " + CommonConfig.getSourceDB()); + System.out.println("The target DBMS is: " + CommonConfig.getTargetDB()); + System.out.println(); + } + + @Test + public void test() + { + int num = 1; + for (String sql : testSQL) { + System.out.println("===== test the SQL" + num++ + " ====="); + System.out.println("Input SQL: " + sql); + OracleLexer lexer = new OracleLexer(sql); + lexer.printTokens(); + OracleParser parser = new OracleParser(lexer); + ASTNode root = parser.parse(); + System.out.println("The AST of the input SQL: "); + System.out.println(root.getASTString()); + System.out.println("The query String of the AST parsed from the input SQL: "); + System.out.println(root.toQueryString()); + OpenGaussGenerator generator = new OpenGaussGenerator(root); + System.out.println("The converted query String: "); + System.out.println(generator.generate()); + + System.out.println(); + } + } +} diff --git a/sqlTranslate/src/test/java/testUpdate.java b/sqlTranslate/src/test/java/testUpdate.java new file mode 100644 index 000000000..3fe863e6c --- /dev/null +++ b/sqlTranslate/src/test/java/testUpdate.java @@ -0,0 +1,47 @@ +import config.CommonConfig; +import generator.OpenGaussGenerator; +import lexer.OracleLexer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import parser.OracleParser; +import parser.ast.ASTNode; + +import java.util.ArrayList; +import java.util.List; + +public class testUpdate { + List testSQL = new ArrayList<>(); + @BeforeEach + public void loadData() + { + testSQL.add("UPDATE employees e JOIN departments d using e.department_id = d.department_id\n" + + " SET e.salary = e.salary * 1.10, d.budget = d.budget * 1.10 WHERE d.department_name = 'Sales';"); + System.out.println("===== test of Update ====="); + System.out.println("The source DBMS is: " + CommonConfig.getSourceDB()); + System.out.println("The target DBMS is: " + CommonConfig.getTargetDB()); + System.out.println(); + } + + @Test + public void test() + { + int num = 1; + for (String sql : testSQL) { + System.out.println("===== test the SQL" + num++ + " ====="); + System.out.println("Input SQL: " + sql); + OracleLexer lexer = new OracleLexer(sql); + lexer.printTokens(); + OracleParser parser = new OracleParser(lexer); + ASTNode root = parser.parse(); + System.out.println("The AST of the input SQL: "); + System.out.println(root.getASTString()); + System.out.println("The query String of the AST parsed from the input SQL: "); + System.out.println(root.toQueryString()); + OpenGaussGenerator generator = new OpenGaussGenerator(root); + System.out.println("The converted query String: "); + System.out.println(generator.generate()); + + System.out.println(); + } + } +} diff --git a/sqlTranslate/src/test/java/testView.java b/sqlTranslate/src/test/java/testView.java new file mode 100644 index 000000000..b3b36afb1 --- /dev/null +++ b/sqlTranslate/src/test/java/testView.java @@ -0,0 +1,49 @@ +import config.CommonConfig; +import generator.OpenGaussGenerator; +import lexer.OracleLexer; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import parser.OracleParser; +import parser.ast.ASTNode; + +import java.util.ArrayList; +import java.util.List; + +public class testView { + List testSQL = new ArrayList<>(); + @BeforeEach + public void loadData() + { + testSQL.add("CREATE OR REPLACE VIEW employee_details AS SELECT first_name, last_name, salary FROM employees;"); + testSQL.add("CREATE OR REPLACE VIEW emp_info (full_name, pay) AS SELECT first_name || ' ' || last_name AS full_name, salary AS pay FROM employees;"); + testSQL.add("CREATE OR REPLACE VIEW emp_dept_info AS SELECT e.first_name, e.last_name, d.department_name FROM employees e JOIN departments d ON e.department_id = d.department_id;"); + testSQL.add("CREATE OR REPLACE VIEW high_salary_employees AS SELECT first_name, last_name, salary FROM employees WHERE salary > 50000;"); + System.out.println("===== test of View ====="); + System.out.println("The source DBMS is: " + CommonConfig.getSourceDB()); + System.out.println("The target DBMS is: " + CommonConfig.getTargetDB()); + System.out.println(); + } + + @Test + public void test() + { + int num = 1; + for (String sql : testSQL) { + System.out.println("===== test the SQL" + num++ + " ====="); + System.out.println("Input SQL: " + sql); + OracleLexer lexer = new OracleLexer(sql); + lexer.printTokens(); + OracleParser parser = new OracleParser(lexer); + ASTNode root = parser.parse(); + System.out.println("The AST of the input SQL: "); + System.out.println(root.getASTString()); + System.out.println("The query String of the AST parsed from the input SQL: "); + System.out.println(root.toQueryString()); + OpenGaussGenerator generator = new OpenGaussGenerator(root); + System.out.println("The converted query String: "); + System.out.println(generator.generate()); + + System.out.println(); + } + } +}