Commit bfc04ca5 authored by terrymanu's avatar terrymanu
Browse files

fix simple sub-query

parent 4512441d

sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/parsing/parser/statement/select/AbstractSelectParser.java

+1 −1
Original line number Diff line number Diff line
@@ -289,7 +289,7 @@ public abstract class AbstractSelectParser implements SQLStatementParser { 
            selectStatement.setContainStar(false);

            parse();

            sqlParser.accept(Symbol.RIGHT_PAREN);

            if (sqlParser.equalAny(DefaultKeyword.WHERE, Assist.END)) {

            if (!selectStatement.getTables().isEmpty()) {

                return;

            }

        }

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

+16 −16
Original line number Diff line number Diff line
@@ -71,22 +71,22 @@ public abstract class AbstractBaseParseTest { 
    

    private final Conditions expectedConditions;

    

    private final Iterator<OrderItem> orderByColumns;

    private final Iterator<OrderItem> expectedOrderByColumns;

    

    private final Iterator<OrderItem> groupByColumns;

    private final Iterator<OrderItem> expectedGroupByColumns;

    

    private final Iterator<AggregationSelectItem> aggregationSelectItems;

    private final Iterator<AggregationSelectItem> expectedAggregationSelectItems;

    

    private final Limit limit;

    private final Limit expectedLimit;

    

    protected AbstractBaseParseTest(final String testCaseName, final String sql, final Tables expectedTables, final Conditions expectedConditions, final SQLStatement expectedSQLStatement) {

        this.sql = sql;

        this.expectedTables = expectedTables;

        this.expectedConditions = expectedConditions;

        this.orderByColumns = expectedSQLStatement.getOrderByList().iterator();

        this.groupByColumns = expectedSQLStatement.getGroupByList().iterator();

        this.aggregationSelectItems = expectedSQLStatement.getAggregationSelectItems().iterator();

        this.limit = expectedSQLStatement.getLimit();

        this.expectedOrderByColumns = expectedSQLStatement.getOrderByList().iterator();

        this.expectedGroupByColumns = expectedSQLStatement.getGroupByList().iterator();

        this.expectedAggregationSelectItems = expectedSQLStatement.getAggregationSelectItems().iterator();

        this.expectedLimit = expectedSQLStatement.getLimit();

    }

    

    protected static Collection<Object[]> dataParameters(final String path) {
@@ -234,36 +234,36 @@ public abstract class AbstractBaseParseTest { 
    

    private void assertOrderBy(final SQLStatement actual) {

        for (OrderItem each : actual.getOrderByList()) {

            assertTrue(new ReflectionEquals(orderByColumns.next()).matches(each));

            assertTrue(new ReflectionEquals(expectedOrderByColumns.next()).matches(each));

        }

        assertFalse(orderByColumns.hasNext());

        assertFalse(expectedOrderByColumns.hasNext());

    }

    

    private void assertGroupBy(final SQLStatement actual) {

        for (OrderItem each : actual.getGroupByList()) {

            assertTrue(new ReflectionEquals(groupByColumns.next()).matches(each));

            assertTrue(new ReflectionEquals(expectedGroupByColumns.next()).matches(each));

        }

        assertFalse(groupByColumns.hasNext());

        assertFalse(expectedGroupByColumns.hasNext());

    }

    

    private void assertAggregationSelectItem(final SQLStatement actual) {

        for (AggregationSelectItem each : actual.getAggregationSelectItems()) {

            AggregationSelectItem expected = aggregationSelectItems.next();

            AggregationSelectItem expected = expectedAggregationSelectItems.next();

            assertTrue(new ReflectionEquals(expected, "derivedAggregationSelectItems").matches(each));

            for (int i = 0; i < each.getDerivedAggregationSelectItems().size(); i++) {

                assertTrue(new ReflectionEquals(expected.getDerivedAggregationSelectItems().get(i)).matches(each.getDerivedAggregationSelectItems().get(i)));

            }

        }

        assertFalse(aggregationSelectItems.hasNext());

        assertFalse(expectedAggregationSelectItems.hasNext());

    }

    

    private void assertLimit(final SQLStatement actual) {

        if (null != actual.getLimit()) {

            if (null != actual.getLimit().getOffsetLimit()) {

                assertTrue(new ReflectionEquals(limit.getOffsetLimit()).matches(actual.getLimit().getOffsetLimit()));

                assertTrue(new ReflectionEquals(expectedLimit.getOffsetLimit()).matches(actual.getLimit().getOffsetLimit()));

            }

            if (null != actual.getLimit().getRowCountLimit()) {

                assertTrue(new ReflectionEquals(limit.getRowCountLimit()).matches(actual.getLimit().getRowCountLimit()));

                assertTrue(new ReflectionEquals(expectedLimit.getRowCountLimit()).matches(actual.getLimit().getRowCountLimit()));

            }

        }

    }

sharding-jdbc-core/src/test/resources/com/dangdang/ddframe/rdb/sharding/parsing/parser/dialect/mysql/statement/select_sub_query.xml

+9 −10
Original line number Diff line number Diff line 
<?xml version="1.0" encoding="UTF-8"?>

<asserts>

    <!--

    <assert id="assertSelectWithOrderByForAliasAndSubQuery" sql="SELECT price FROM (SELECT o.user_id,o.price FROM order o WHERE o.order_id = 1 ORDER BY o.order_id) order by user_id" expected-sql="SELECT price[sharding_auto_gen_0(, user_id AS sharding_gen_1)] FROM (SELECT [Token(o)].user_id, [Token(o)].price[sharding_auto_gen_1(, o.order_id AS sharding_gen_1)] FROM [Token(order)] o WHERE o.order_id = 1 ORDER BY o.order_id ) ORDER BY user_id">

    

    <assert id="assertSelectWithOrderByForAliasAndSubQuery" sql="SELECT price FROM (SELECT o.user_id,o.price FROM order o WHERE o.order_id = 1 ORDER BY o.order_id)" expected-sql="SELECT price[sharding_auto_gen_0(, user_id AS sharding_gen_1)] FROM (SELECT [Token(o)].user_id, [Token(o)].price[sharding_auto_gen_1(, o.order_id AS sharding_gen_1)] FROM [Token(order)] o WHERE o.order_id = 1 ORDER BY o.order_id ) ORDER BY user_id">

        <tables>

            <table name="order" alias="o" />

        </tables>

        <condition-contexts>

            <condition-context>

        <conditions>

            <condition column-name="order_id" table-name="order" operator="EQUAL">

                <value literal="1" type="java.lang.Integer" />

            </condition>

            </condition-context>

        </condition-contexts>

        </conditions>

        <order-by-columns>

            <order-by-column owner="o" name="user_id" alias="sharding_gen_1" order-by-type="ASC" />

            <order-by-column owner="o" name="order_id" alias="ORDER_BY_DERIVED_0" order-by-type="ASC" />

        </order-by-columns>

    </assert>

    <!--

    <assert id="assertSelectWithGroupByAndSubQuery" sql="SELECT AVG(i.SUM_PRICE) avg FROM (SELECT o.order_id,SUM(o.price) AS SUM_PRICE FROM order o WHERE o.order_id = 1 GROUP BY o.order_id) i" expected-sql="SELECT AVG(i.SUM_PRICE) AS avg[sharding_auto_gen_0(, COUNT(i.SUM_PRICE) AS sharding_gen_1, SUM(i.SUM_PRICE) AS sharding_gen_2)] FROM (SELECT [Token(o)].order_id, SUM(o.price) AS SUM_PRICE FROM [Token(order)] o WHERE o.order_id = 1 GROUP BY o.order_id ) i">

        <tables>

            <table name="order" alias="o" />