Refactor parser test case packages 16th.

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/common/jaxb/helper/SQLStatementHelper.java

@@ -10,6 +10,7 @@ import javax.xml.bind.JAXBContext;
 import javax.xml.bind.JAXBException;
 import java.io.File;
 import java.net.URL;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
@@ -18,39 +19,47 @@ import java.util.Set;
 
 public class SQLStatementHelper {
     
-    private static Map<String, SQLStatement> statementMap = new HashMap<>();
+    private static final Map<String, SQLStatement> statementMap;
+    
+    private static final Map<String, SQLStatement> unsuppportedStatementMap;
     
     static {
-        loadSqlStatements();
+        statementMap = loadSqlStatements("sql");
+        unsuppportedStatementMap = loadSqlStatements("sql/unsupported");
     }
     
-    private static void loadSqlStatements() {
-        URL url = SQLAssertJAXBHelper.class.getClassLoader().getResource("sql");
+    private static Map<String, SQLStatement> loadSqlStatements(final String directory) {
+        Map<String, SQLStatement> result = new HashMap<>();
+        URL url = SQLAssertJAXBHelper.class.getClassLoader().getResource(directory);
         if (url == null) {
-            return;
+            return result;
         }
         File filePath = new File(url.getPath());
         if (!filePath.exists()) {
-            return;
+            return result;
         }
         File[] files = filePath.listFiles();
         if (null == files) {
-            return;
+            return result;
         }
         for (File each : files) {
+            if (each.isDirectory()) {
+                continue;
+            }
             try {
                 SQLStatements statements = (SQLStatements) JAXBContext.newInstance(SQLStatements.class).createUnmarshaller().unmarshal(each);
                 for (SQLStatement statement : statements.getSqls()) {
-                    String id = statement.getId();
-                    if (statementMap.containsKey(id)) {
-                        throw new RuntimeException("Existed sql assert id with:" + id);
-                    }
-                    statementMap.put(id, statement);
+                    result.put(statement.getId(), statement);
                 }
             } catch (final JAXBException ex) {
                 throw new RuntimeException(ex);
             }
         }
+        return result;
+    }
+    
+    public static Collection<SQLStatement> getUnsupportedSqlStatements() {
+        return unsuppportedStatementMap.values();
     }
     
     public static String getSql(final String sqlId) {

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/AllParsingTests.java

@@ -19,7 +19,6 @@ package com.dangdang.ddframe.rdb.sharding.parsing;
 
 import com.dangdang.ddframe.rdb.sharding.parsing.lexer.AllLexerTests;
 import com.dangdang.ddframe.rdb.sharding.parsing.lexer.analyzer.TokenizerTest;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.dialect.SQLParserTest;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.AllStatementParserTests;
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
@@ -29,9 +28,9 @@ import org.junit.runners.Suite;
         TokenizerTest.class,
         AllLexerTests.class,
         AllStatementParserTests.class,
-        SQLParserTest.class,
         SQLParsingEngineTest.class,
-        UnsupportedParseTest.class
+        UnsupportedSQLParsingEngineTest.class,
+        SQLJudgeEngineTest.class
     })
 public class AllParsingTests {
 }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/ParameterTestUnit.java

+package com.dangdang.ddframe.rdb.sharding.parsing;
+
+/**
+ * Created by caohao on 2017/8/10.
+ */
+public class ParameterTestUnit {
+}

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/SQLJudgeEngineTest.java

+package com.dangdang.ddframe.rdb.sharding.parsing;
+
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.exception.SQLParsingException;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.dml.DMLStatement;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.dql.DQLStatement;
+import org.junit.Test;
+
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.junit.Assert.assertThat;
+
+public final class SQLJudgeEngineTest {
+    
+    @Test
+    public void assertPrepareParseForSelect() {
+        assertThat(new SQLJudgeEngine(" /*COMMENT*/  \t \n  \r \fsElecT\t\n  * from table  ").judge(), instanceOf(DQLStatement.class));
+    }
+    
+    @Test
+    public void assertPrepareParseForInsert() {
+        assertThat(new SQLJudgeEngine(" - - COMMENT  \t \n  \r \fInsert\t\n  into table  ").judge(), instanceOf(DMLStatement.class));
+    }
+    
+    @Test
+    public void assertPrepareParseForUpdate() {
+        assertThat(new SQLJudgeEngine(" /*+ HINT SELECT * FROM TT*/  \t \n  \r \fuPdAte\t\n  table  ").judge(), instanceOf(DMLStatement.class));
+    }
+    
+    @Test
+    public void assertPrepareParseForDelete() {
+        assertThat(new SQLJudgeEngine(" /*+ HINT SELECT * FROM TT*/  \t \n  \r \fdelete\t\n  table  ").judge(), instanceOf(DMLStatement.class));
+    }
+    
+    @Test(expected = SQLParsingException.class)
+    public void assertPrepareParseForInvalidSQL() {
+        new SQLJudgeEngine("int i = 0").judge();
+    }
+}

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/SQLParsingEngineTest.java

+/*
+ * Copyright 1999-2015 dangdang.com.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * </p>
+ */
+
 package com.dangdang.ddframe.rdb.sharding.parsing;
 
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.exception.SQLParsingException;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.dml.DMLStatement;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.dql.DQLStatement;
+import com.dangdang.ddframe.rdb.common.jaxb.helper.SQLStatementHelper;
+import com.dangdang.ddframe.rdb.common.util.SqlPlaceholderUtil;
+import com.dangdang.ddframe.rdb.sharding.api.fixture.ShardingRuleMockBuilder;
+import com.dangdang.ddframe.rdb.sharding.constant.DatabaseType;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.base.AbstractBaseParseSQLTest;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.base.AbstractBaseParseTest;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Tables;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.jaxb.Conditions;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.jaxb.Limit;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
 
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.junit.Assert.assertThat;
+import java.util.Collection;
 
-public final class SQLParsingEngineTest {
+@RunWith(Parameterized.class)
+public final class SQLParsingEngineTest extends AbstractBaseParseSQLTest {
     
-    @Test
-    public void assertPrepareParseForSelect() {
-        assertThat(new SQLJudgeEngine(" /*COMMENT*/  \t \n  \r \fsElecT\t\n  * from table  ").judge(), instanceOf(DQLStatement.class));
+    public SQLParsingEngineTest(
+            final String testCaseName, final String[] parameters, final Tables expectedTables, 
+            final Conditions expectedConditions, final SQLStatement expectedSQLStatement, final Limit expectedLimit) {
+        super(testCaseName, parameters, expectedTables, expectedConditions, expectedSQLStatement, expectedLimit);
     }
     
-    @Test
-    public void assertPrepareParseForInsert() {
-        assertThat(new SQLJudgeEngine(" - - COMMENT  \t \n  \r \fInsert\t\n  into table  ").judge(), instanceOf(DMLStatement.class));
+    @Parameters(name = "{0}")
+    public static Collection<Object[]> dataParameters() {
+        return AbstractBaseParseTest.dataParameters();
     }
     
     @Test
-    public void assertPrepareParseForUpdate() {
-        assertThat(new SQLJudgeEngine(" /*+ HINT SELECT * FROM TT*/  \t \n  \r \fuPdAte\t\n  table  ").judge(), instanceOf(DMLStatement.class));
+    public void assertStatement() {
+        for (DatabaseType each : SQLStatementHelper.getTypes(getTestCaseName())) {
+            assertStatement(new SQLParsingEngine(each, SqlPlaceholderUtil.replaceStatement(SQLStatementHelper.getSql(getTestCaseName()), getParameters()),
+                    new ShardingRuleMockBuilder().addShardingColumns("user_id").addShardingColumns("order_id").addShardingColumns("state")
+                            .addGenerateKeyColumn("order", "order_id").addGenerateKeyColumn("payment", "order_id").addGenerateKeyColumn("payment", "pay_no").build()).parse());
+        }
     }
     
     @Test
-    public void assertPrepareParseForDelete() {
-        assertThat(new SQLJudgeEngine(" /*+ HINT SELECT * FROM TT*/  \t \n  \r \fdelete\t\n  table  ").judge(), instanceOf(DMLStatement.class));
-    }
-    
-    @Test(expected = SQLParsingException.class)
-    public void assertPrepareParseForInvalidSQL() {
-        new SQLJudgeEngine("int i = 0").judge();
+    public void assertPreparedStatement() {
+        for (DatabaseType each : SQLStatementHelper.getTypes(getTestCaseName())) {
+            assertPreparedStatement(new SQLParsingEngine(each, SqlPlaceholderUtil.replacePreparedStatement(SQLStatementHelper.getSql(getTestCaseName())),
+                    new ShardingRuleMockBuilder().addShardingColumns("user_id").addShardingColumns("order_id").addShardingColumns("state")
+                            .addGenerateKeyColumn("order", "order_id").addGenerateKeyColumn("payment", "order_id").addGenerateKeyColumn("payment", "pay_no").build()).parse());
+        }
     }
 }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/UnsupportedParseTest.java

-/*
- * Copyright 1999-2015 dangdang.com.
- * <p>
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * </p>
- */
-
-package com.dangdang.ddframe.rdb.sharding.parsing;
-
-import com.dangdang.ddframe.rdb.sharding.api.fixture.ShardingRuleMockBuilder;
-import com.dangdang.ddframe.rdb.sharding.constant.DatabaseType;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.exception.SQLParsingUnsupportedException;
-import org.junit.Test;
-
-public final class UnsupportedParseTest {
-    
-    @Test(expected = SQLParsingUnsupportedException.class)
-    public void assertGrant() {
-        new SQLParsingEngine(DatabaseType.MySQL, "GRANT ALL ON * TO 'root'@'localhost'", new ShardingRuleMockBuilder().build()).parse();
-    }
-}

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/dialect/SQLParserTest.java → sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/UnsupportedSQLParsingEngineTest.java

@@ -15,55 +15,78 @@
  * </p>
  */
 
-package com.dangdang.ddframe.rdb.sharding.parsing.parser.dialect;
+package com.dangdang.ddframe.rdb.sharding.parsing;
 
+import com.dangdang.ddframe.rdb.common.jaxb.SQLStatement;
 import com.dangdang.ddframe.rdb.common.jaxb.helper.SQLStatementHelper;
-import com.dangdang.ddframe.rdb.common.util.SqlPlaceholderUtil;
 import com.dangdang.ddframe.rdb.sharding.api.fixture.ShardingRuleMockBuilder;
 import com.dangdang.ddframe.rdb.sharding.constant.DatabaseType;
-import com.dangdang.ddframe.rdb.sharding.parsing.SQLParsingEngine;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.base.AbstractBaseParseSQLTest;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.base.AbstractBaseParseTest;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Tables;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.jaxb.Conditions;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.jaxb.Limit;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.statement.SQLStatement;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.exception.SQLParsingUnsupportedException;
+import com.google.common.collect.Sets;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
 
+import java.util.ArrayList;
 import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+import static junit.framework.Assert.fail;
+import static org.junit.Assert.assertTrue;
 
 @RunWith(Parameterized.class)
-public final class SQLParserTest extends AbstractBaseParseSQLTest {
+public final class UnsupportedSQLParsingEngineTest {
+    
+    private String testcaseName;
+    
+    private String sql;
+    
+    private Set<DatabaseType> types;
     
-    public SQLParserTest(
-            final String testCaseName, final String[] parameters, final Tables expectedTables, 
-            final Conditions expectedConditions, final SQLStatement expectedSQLStatement, final Limit expectedLimit) {
-        super(testCaseName, parameters, expectedTables, expectedConditions, expectedSQLStatement, expectedLimit);
+    public UnsupportedSQLParsingEngineTest(final String testCaseName, final String sql, Set<DatabaseType> types) {
+        this.testcaseName = testCaseName;
+        this.sql = sql;
+        this.types = types;
     }
     
-    @Parameters(name = "{0}")
+    @Parameterized.Parameters(name = "{0}")
     public static Collection<Object[]> dataParameters() {
-        return AbstractBaseParseTest.dataParameters();
+        Collection<Object[]> result = new ArrayList<>();
+        for (SQLStatement each : SQLStatementHelper.getUnsupportedSqlStatements()) {
+            Object[] object = new Object[3];
+            object[0] = each.getId();
+            object[1] = each.getSql();
+            object[2] = getTypes(each.getTypes());
+            result.add(object);
+        }
+        return result;
     }
     
-    @Test
-    public void assertStatement() {
-        for (DatabaseType each : SQLStatementHelper.getTypes(getTestCaseName())) {
-            assertStatement(new SQLParsingEngine(each, SqlPlaceholderUtil.replaceStatement(SQLStatementHelper.getSql(getTestCaseName()), getParameters()),
-                    new ShardingRuleMockBuilder().addShardingColumns("user_id").addShardingColumns("order_id").addShardingColumns("state")
-                            .addGenerateKeyColumn("order", "order_id").addGenerateKeyColumn("payment", "order_id").addGenerateKeyColumn("payment", "pay_no").build()).parse());
+    private static Set<DatabaseType> getTypes(final String types) {
+        if (types == null || types.isEmpty()) {
+            return Sets.newHashSet(DatabaseType.values());
+        }
+        Set<DatabaseType> result = new HashSet<>();
+        for (String each : types.split(",")) {
+            result.add(DatabaseType.valueOf(each));
         }
+        return result;
     }
     
     @Test
-    public void assertPreparedStatement() {
-        for (DatabaseType each : SQLStatementHelper.getTypes(getTestCaseName())) {
-            assertPreparedStatement(new SQLParsingEngine(each, SqlPlaceholderUtil.replacePreparedStatement(SQLStatementHelper.getSql(getTestCaseName())),
-                    new ShardingRuleMockBuilder().addShardingColumns("user_id").addShardingColumns("order_id").addShardingColumns("state")
-                            .addGenerateKeyColumn("order", "order_id").addGenerateKeyColumn("payment", "order_id").addGenerateKeyColumn("payment", "pay_no").build()).parse());
+    public void assertUnsupportedStatement() {
+        for (DatabaseType each : types) {
+            try {
+                new SQLParsingEngine(each, sql,
+                        new ShardingRuleMockBuilder().addShardingColumns("user_id").addShardingColumns("order_id").addShardingColumns("state")
+                                .addGenerateKeyColumn("order", "order_id").addGenerateKeyColumn("payment", "order_id").addGenerateKeyColumn("payment", "pay_no").build()).parse();
+                fail(String.format("Should have thrown an SQLParsingUnsupportedException because %s is invalid!", sql));
+                //CHECKSTYLE:OFF
+            } catch (final Exception exception) {
+                //CHECKSTYLE:ON
+                assertTrue(exception instanceof SQLParsingUnsupportedException);
+            }
         }
     }
 }

sharding-jdbc-core/src/test/resources/parser/select.xml

@@ -175,4 +175,9 @@
             <aggregation-select-item inner-expression="(*)" aggregation-type="COUNT" alias="items_count"/>
         </aggregation-select-items>
     </assert>
+    <assert id="assertSelectIntoWithSingleTableInPostgreSQL">
+        <!--<tables>-->
+            <!--<table name="t_order" />-->
+        <!--</tables>-->
+    </assert>
 </asserts>

sharding-jdbc-core/src/test/resources/sql/select.xml

@@ -11,4 +11,5 @@
     <sql id="assertSelectWithBindingTableAndConfigTable" value="SELECT i.* FROM t_order o JOIN t_order_item i ON o.user_id = i.user_id AND o.order_id = i.order_id JOIN t_config c ON o.status = c.status WHERE o.user_id IN (%s, %s) AND o.order_id BETWEEN %s AND %s AND c.status = %s ORDER BY i.item_id" />
     <sql id="assertSelectCountWithBindingTable" value="SELECT COUNT(*) AS items_count FROM t_order o, t_order_item i WHERE o.user_id = i.user_id AND o.order_id = i.order_id AND o.user_id IN (%s, %s) AND o.order_id BETWEEN %s AND %s" />
     <sql id="assertSelectCountWithBindingTableWithJoin" value="SELECT COUNT(*) AS items_count FROM t_order o JOIN t_order_item i ON o.user_id = i.user_id AND o.order_id = i.order_id WHERE o.user_id IN (%s, %s) AND o.order_id BETWEEN %s AND %s" />
+    <sql id="assertSelectIntoWithSingleTableInPostgreSQL" value="SELECT * INTO t_order_new FROM t_order" type="PostgreSQL"/>
 </sqls>

sharding-jdbc-core/src/test/resources/sql/unsupported/common.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<sqls>
+    <sql id="assertSelectDistinctWithSingleTable" value="SELECT DISTINCT item_id FROM t_order_item ORDER BY item_id" />
+    <sql id="assertSelectWindowInPostgreSQL" value="SELECT * FROM t_order WINDOW w AS (PARTITION BY order_id)" type="PostgreSQL"/>
+    <sql id="assertSelectFetchInPostgreSQL" value="SELECT * FROM t_order FETCH NEXT 1 ROW ONLY" type="PostgreSQL"/>
+    <sql id="assertSelectForInPostgreSQL" value="SELECT * FROM t_order FOR UPDATE OF t_order" type="PostgreSQL"/>
+</sqls>