Refactor parser test case packages 12th.

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/base/AbstractBaseParseSQLTest.java

@@ -6,6 +6,8 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.OrderItem;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.condition.Column;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.condition.Condition;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.condition.Conditions;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.limit.Limit;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.limit.LimitValue;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.selectitem.AggregationSelectItem;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Tables;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.expression.SQLExpression;
@@ -29,8 +31,9 @@ public abstract class AbstractBaseParseSQLTest extends AbstractBaseParseTest {
     
     protected AbstractBaseParseSQLTest(
             final String testCaseName, final String sql, final String[] parameters, final Set<DatabaseType> types, 
-            final Tables expectedTables, final com.dangdang.ddframe.rdb.sharding.parsing.parser.jaxb.Conditions expectedConditions, final SQLStatement expectedSQLStatement) {
-        super(testCaseName, sql, parameters, types, expectedTables, expectedConditions, expectedSQLStatement);
+            final Tables expectedTables, final com.dangdang.ddframe.rdb.sharding.parsing.parser.jaxb.Conditions expectedConditions, 
+            final SQLStatement expectedSQLStatement, final com.dangdang.ddframe.rdb.sharding.parsing.parser.jaxb.Limit expectedLimit) {
+        super(testCaseName, sql, parameters, types, expectedTables, expectedConditions, expectedSQLStatement, expectedLimit);
     }
     
     protected final void assertStatement(final SQLStatement actual) {
@@ -48,7 +51,7 @@ public abstract class AbstractBaseParseSQLTest extends AbstractBaseParseTest {
             assertOrderBy((SelectStatement) actual);
             assertGroupBy((SelectStatement) actual);
             assertAggregationSelectItem((SelectStatement) actual);
-            assertLimit((SelectStatement) actual);
+            assertLimit((SelectStatement) actual, isPreparedStatement);
         }
     }
     
@@ -100,6 +103,32 @@ public abstract class AbstractBaseParseSQLTest extends AbstractBaseParseTest {
         return result;
     }
     
+    private Limit buildExpectedLimit(final boolean isPreparedStatement) {
+        com.dangdang.ddframe.rdb.sharding.parsing.parser.jaxb.Limit limit = getExpectedLimit();
+        if (null == limit) {
+            return null;
+        }
+        Limit result = new Limit(true);
+        if (isPreparedStatement) {
+            if (null != limit.getOffsetParameterIndex()) {
+                result.setOffset(new LimitValue(-1, limit.getOffsetParameterIndex()));
+            }
+            if (null != limit.getRowCountParameterIndex()) {
+                result.setRowCount(new LimitValue(-1, limit.getRowCountParameterIndex()));
+            }
+        } else {
+            if (null != limit.getOffset()) {
+                result.setOffset(new LimitValue(limit.getOffset(), -1));
+                
+            }
+            if (null != limit.getRowCount()) {
+                result.setRowCount(new LimitValue(limit.getRowCount(), -1));
+            }
+        }
+        return result;
+    }
+    
+    
     private void assertOrderBy(final SelectStatement actual) {
         Iterator<OrderItem> orderByColumns = getExpectedOrderByColumns().iterator();
         for (OrderItem each : actual.getOrderByItems()) {
@@ -128,13 +157,13 @@ public abstract class AbstractBaseParseSQLTest extends AbstractBaseParseTest {
         assertFalse(aggregationSelectItems.hasNext());
     }
     
-    private void assertLimit(final SelectStatement actual) {
+    private void assertLimit(final SelectStatement actual, final boolean isPreparedStatement) {
         if (null != actual.getLimit()) {
             if (null != actual.getLimit().getOffset()) {
-                assertTrue(new ReflectionEquals(getExpectedLimit().getOffset()).matches(actual.getLimit().getOffset()));
+                assertTrue(new ReflectionEquals(buildExpectedLimit(isPreparedStatement).getOffset()).matches(actual.getLimit().getOffset()));
             }
             if (null != actual.getLimit().getRowCount()) {
-                assertTrue(new ReflectionEquals(getExpectedLimit().getRowCount()).matches(actual.getLimit().getRowCount()));
+                assertTrue(new ReflectionEquals(buildExpectedLimit(isPreparedStatement).getRowCount()).matches(actual.getLimit().getRowCount()));
             }
         }
     }

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/base/AbstractBaseParseTest.java

@@ -20,7 +20,7 @@ package com.dangdang.ddframe.rdb.sharding.parsing.parser.base;
 import com.dangdang.ddframe.rdb.common.jaxb.helper.SQLStatementHelper;
 import com.dangdang.ddframe.rdb.sharding.constant.DatabaseType;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.OrderItem;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.limit.Limit;
+import com.dangdang.ddframe.rdb.sharding.parsing.parser.jaxb.Limit;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.selectitem.AggregationSelectItem;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Tables;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.jaxb.Assert;
@@ -72,22 +72,21 @@ public abstract class AbstractBaseParseTest {
     
     protected AbstractBaseParseTest(
             final String testCaseName, final String sql, final String[] parameters, final Set<DatabaseType> types, 
-            final Tables expectedTables, final Conditions expectedConditions, final SQLStatement expectedSQLStatement) {
+            final Tables expectedTables, final Conditions expectedConditions, final SQLStatement expectedSQLStatement, final Limit expectedLimit) {
         this.sql = sql;
         this.parameters = parameters;
         this.types = types;
         this.expectedTables = expectedTables;
         this.expectedConditions = expectedConditions;
+        this.expectedLimit = expectedLimit;
         if (expectedSQLStatement instanceof SelectStatement) {
             expectedOrderByColumns = ((SelectStatement) expectedSQLStatement).getOrderByItems();
             expectedGroupByColumns = ((SelectStatement) expectedSQLStatement).getGroupByItems();
             expectedAggregationSelectItems = ((SelectStatement) expectedSQLStatement).getAggregationSelectItems();
-            expectedLimit = ((SelectStatement) expectedSQLStatement).getLimit();
         } else {
             expectedOrderByColumns = null;
             expectedGroupByColumns = null;
             expectedAggregationSelectItems = null;
-            expectedLimit = null;
         }
     }
     
@@ -117,7 +116,7 @@ public abstract class AbstractBaseParseTest {
     }
     
     private static Object[] getDataParameter(final Assert assertObj) {
-        final Object[] result = new Object[7];
+        final Object[] result = new Object[8];
         result[0] = assertObj.getId();
         result[1] = SQLStatementHelper.getSql(assertObj.getId());
         result[2] = ParserJAXBHelper.getParameters(assertObj);
@@ -125,6 +124,7 @@ public abstract class AbstractBaseParseTest {
         result[4] = ParserJAXBHelper.getTables(assertObj);
         result[5] = assertObj.getConditions();
         result[6] = ParserJAXBHelper.getSelectStatement(assertObj);
+        result[7] = assertObj.getLimit();
         return result;
     }
 }

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

@@ -25,6 +25,7 @@ import com.dangdang.ddframe.rdb.sharding.parsing.parser.base.AbstractBaseParseSQ
 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;
@@ -39,8 +40,8 @@ public final class SQLParserTest extends AbstractBaseParseSQLTest {
     
     public SQLParserTest(
             final String testCaseName, final String sql, final String[] parameters, final Set<DatabaseType> types,
-            final Tables expectedTables, final Conditions expectedConditions, final SQLStatement expectedSQLStatement) {
-        super(testCaseName, sql, parameters, types, expectedTables, expectedConditions, expectedSQLStatement);
+            final Tables expectedTables, final Conditions expectedConditions, final SQLStatement expectedSQLStatement, final Limit expectedLimit) {
+        super(testCaseName, sql, parameters, types, expectedTables, expectedConditions, expectedSQLStatement, expectedLimit);
     }
     
     @Parameters(name = "{0}")

sharding-jdbc-core/src/test/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/jaxb/helper/ParserJAXBHelper.java

@@ -4,8 +4,6 @@ import com.dangdang.ddframe.rdb.sharding.constant.AggregationType;
 import com.dangdang.ddframe.rdb.sharding.constant.DatabaseType;
 import com.dangdang.ddframe.rdb.sharding.constant.OrderType;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.OrderItem;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.limit.Limit;
-import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.limit.LimitValue;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.selectitem.AggregationSelectItem;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Table;
 import com.dangdang.ddframe.rdb.sharding.parsing.parser.context.table.Tables;
@@ -104,16 +102,6 @@ public class ParserJAXBHelper {
                     });
             result.getItems().addAll(selectItems);
         }
-        if (null != assertObj.getLimit()) {
-            Limit limit = new Limit(true);
-            if (null != assertObj.getLimit().getOffset() && null != assertObj.getLimit().getOffsetParameterIndex()) {
-                limit.setRowCount(new LimitValue(assertObj.getLimit().getRowCount(), assertObj.getLimit().getRowCountParameterIndex()));
-                limit.setOffset(new LimitValue(assertObj.getLimit().getOffset(), assertObj.getLimit().getOffsetParameterIndex()));
-            } else {
-                limit.setRowCount(new LimitValue(assertObj.getLimit().getRowCount(), assertObj.getLimit().getRowCountParameterIndex()));
-            }
-            result.setLimit(limit);
-        }
         return result;
     }
 }

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

+<?xml version="1.0" encoding="UTF-8"?>
+<asserts>
+    <assert id="assertSelectPaginationWithOffsetInPostgreSQL" parameters="1,2,9,10,5">
+        <tables>
+            <table name="t_order" alias="o" />
+            <table name="t_order_item" alias="i" />
+        </tables>
+        <conditions>
+            <condition column-name="user_id" table-name="t_order" operator="IN">
+                <value index="0" literal="1" type="int" />
+                <value index="1" literal="2" type="int" />
+            </condition>
+            <condition column-name="order_id" table-name="t_order" operator="BETWEEN">
+                <value index="2" literal="9" type="int" />
+                <value index="3" literal="10" type="int" />
+            </condition>
+        </conditions>
+        <order-by-columns>
+            <order-by-column name="item_id" alias="ORDER_BY_DERIVED_0" owner="i" order-by-type="DESC" />
+        </order-by-columns>
+        <limit offset="5" offset-index="4" />
+    </assert>
+    <assert id="assertSelectPaginationWithRowCount" parameters="1,2,9,10,5">
+        <tables>
+            <table name="t_order" alias="o" />
+            <table name="t_order_item" alias="i" />
+        </tables>
+        <conditions>
+            <condition column-name="user_id" table-name="t_order" operator="IN">
+                <value index="0" literal="1" type="int" />
+                <value index="1" literal="2" type="int" />
+            </condition>
+            <condition column-name="order_id" table-name="t_order" operator="BETWEEN">
+                <value index="2" literal="9" type="int" />
+                <value index="3" literal="10" type="int" />
+            </condition>
+        </conditions>
+        <order-by-columns>
+            <order-by-column name="item_id" alias="ORDER_BY_DERIVED_0" owner="i" order-by-type="DESC" />
+        </order-by-columns>
+        <limit row-count="5" row-count-index="4" />
+    </assert>
+    <!--<assert id="assertSelectPaginationWithOffsetAndRowCount" parameters="1,2,9,10,5,3">-->
+        <!--<tables>-->
+            <!--<table name="t_order" alias="o" />-->
+            <!--<table name="t_order_item" alias="i" />-->
+        <!--</tables>-->
+        <!--<conditions>-->
+            <!--<condition column-name="user_id" table-name="t_order" operator="IN">-->
+                <!--<value index="0" literal="1" type="int" />-->
+                <!--<value index="1" literal="2" type="int" />-->
+            <!--</condition>-->
+            <!--<condition column-name="order_id" table-name="t_order" operator="BETWEEN">-->
+                <!--<value index="2" literal="9" type="int" />-->
+                <!--<value index="3" literal="10" type="int" />-->
+            <!--</condition>-->
+        <!--</conditions>-->
+        <!--<order-by-columns>-->
+            <!--<order-by-column name="item_id" alias="ORDER_BY_DERIVED_0" owner="i" order-by-type="DESC" />-->
+        <!--</order-by-columns>-->
+        <!--<limit offset="5" offset-index="4" row-count="3" row-count-index="5" />-->
+    <!--</assert>-->
+</asserts>

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

@@ -15,4 +15,47 @@
             <order-by-column name="order_id" owner="t" order-by-type="ASC" />
         </order-by-columns>
     </assert>
+    <assert id="assertSelectSubQueryMultiTableWithParentheses" parameters="1,2">
+        <tables>
+            <table name="t_order" alias="o" />
+            <table name="t_order_item" alias="i" />
+            <table name="t" />
+        </tables>
+        <conditions>
+            <condition column-name="order_id" table-name="t_order" operator="IN">
+                <value index="0" literal="1" type="int" />
+                <value index="1" literal="2" type="int" />
+            </condition>
+        </conditions>
+        <order-by-columns>
+            <order-by-column name="item_id" owner="t" order-by-type="ASC" />
+        </order-by-columns>
+    </assert>
+    <assert id="assertSelectSubQueryWithOrderBy">
+        <tables>
+            <table name="t_order"/>
+            <table name="t" />
+        </tables>
+        <aggregation-select-items>
+            <aggregation-select-item inner-expression="(1)" aggregation-type="COUNT" alias="orders_count"/>
+        </aggregation-select-items>
+        <order-by-columns>
+            <order-by-column name="order_id" order-by-type="DESC" />
+        </order-by-columns>
+    </assert>
+    <assert id="assertSelectSubQueryWithGroupBy">
+        <tables>
+            <table name="t_order_item"/>
+            <table name="t" />
+        </tables>
+        <aggregation-select-items>
+            <aggregation-select-item inner-expression="(1)" aggregation-type="COUNT" alias="order_items_count"/>
+        </aggregation-select-items>
+        <group-by-columns>
+            <group-by-column name="order_id" order-by-type="ASC" />
+        </group-by-columns>
+        <order-by-columns>
+            <order-by-column name="order_id" order-by-type="ASC" />
+        </order-by-columns>
+    </assert>
 </asserts>