| /* |
| * Copyright (c) 2006, 2021 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // Contributors: |
| // Oracle - initial API and implementation |
| // |
| package org.eclipse.persistence.jpa.tests.jpql.parser; |
| |
| import org.eclipse.persistence.jpa.jpql.parser.InternalOrderByItemBNF; |
| import org.eclipse.persistence.jpa.jpql.parser.InternalSimpleSelectExpressionBNF; |
| import org.eclipse.persistence.jpa.jpql.parser.JPQLQueryBNF; |
| import org.eclipse.persistence.jpa.jpql.parser.ScalarExpressionBNF; |
| import org.eclipse.persistence.jpa.jpql.parser.SimpleResultVariableBNF; |
| import org.eclipse.persistence.jpa.jpql.parser.SubqueryBNF; |
| import org.junit.Test; |
| import static org.eclipse.persistence.jpa.jpql.parser.Expression.*; |
| import static org.eclipse.persistence.jpa.tests.jpql.parser.JPQLParserTester.*; |
| |
| @SuppressWarnings("nls") |
| public final class OrderByClauseTest extends JPQLParserTest { |
| |
| private JPQLQueryStringFormatter buildQueryFormatter_01(final String jpqlQuery) { |
| return new JPQLQueryStringFormatter() { |
| @Override |
| public String format(String query) { |
| return jpqlQuery; |
| } |
| }; |
| } |
| |
| private boolean isScalarExpressionSupported() { |
| JPQLQueryBNF queryBNF = getGrammar().getExpressionRegistry().getQueryBNF(InternalOrderByItemBNF.ID); |
| return queryBNF.hasChild(ScalarExpressionBNF.ID); |
| } |
| |
| private boolean isSubqueryResultVariableSupported() { |
| JPQLQueryBNF queryBNF = getGrammar().getExpressionRegistry().getQueryBNF(InternalSimpleSelectExpressionBNF.ID); |
| return queryBNF.getFallbackBNFId() == SimpleResultVariableBNF.ID; |
| } |
| |
| private boolean isSubquerySupported() { |
| JPQLQueryBNF queryBNF = getGrammar().getExpressionRegistry().getQueryBNF(InternalOrderByItemBNF.ID); |
| return queryBNF.hasChild(SubqueryBNF.ID); |
| } |
| |
| @Test |
| public void test_JPQLQuery_01() { |
| |
| String jpqlQuery = "SELECT ORDERe FROM Ordering ORDERe ORDER BY ORDERe.name"; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("ORDERe")), |
| from("Ordering", "ORDERe"), |
| orderBy(orderByItem("ORDERe.name")) |
| ); |
| |
| testQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_02() { |
| |
| String jpqlQuery = "SELECT d FROM DiscountCode d ORDER BY d.rate ORDER"; |
| |
| CollectionExpressionTester items = spacedCollection( |
| path("d.rate"), |
| variable("ORDER") |
| ); |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("d")), |
| from("DiscountCode", "d"), |
| orderBy(orderByItem(items)) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_03() { |
| |
| String jpqlQuery = "SELECT d FROM DiscountCode d ORDER BY d.rate GROUP"; |
| |
| CollectionExpressionTester items = spacedCollection( |
| path("d.rate"), |
| variable("GROUP") |
| ); |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("d")), |
| from("DiscountCode", "d"), |
| orderBy(orderByItem(items)) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_04() { |
| |
| String jpqlQuery = "SELECT d FROM DiscountCode d ORDER BY d.rate ORDER BY"; |
| |
| OrderByItemTester orderBy = orderByItem("d.rate"); |
| orderBy.hasSpaceAfterExpression = true; |
| |
| JPQLExpressionTester jpqlExpression = jpqlExpression( |
| selectStatement( |
| select(variable("d")), |
| from("DiscountCode", "d"), |
| orderBy(orderBy) |
| ), |
| unknown(ORDER_BY) |
| ); |
| |
| testInvalidQuery(jpqlQuery, jpqlExpression); |
| } |
| |
| @Test |
| public void test_JPQLQuery_05() { |
| |
| String jpqlQuery = "SELECT d FROM DiscountCode d ORDER BY d.rate SELECT"; |
| |
| SimpleSelectStatementTester select = subSelectStatement( |
| subSelect(nullExpression()), |
| nullExpression() |
| ); |
| |
| CollectionExpressionTester items = spacedCollection( |
| path("d.rate"), |
| isSubquerySupported() ? select : bad(select) |
| ); |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("d")), |
| from("DiscountCode", "d"), |
| orderBy(orderByItem(items)) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_06() { |
| |
| String jpqlQuery = "SELECT d FROM DiscountCode d ORDER BY d.rate WHERE"; |
| |
| OrderByItemTester orderBy = orderByItem("d.rate"); |
| orderBy.hasSpaceAfterExpression = true; |
| |
| JPQLExpressionTester jpqlExpression = jpqlExpression( |
| selectStatement( |
| select(variable("d")), |
| from("DiscountCode", "d"), |
| orderBy(orderBy) |
| ), |
| unknown(WHERE) |
| ); |
| |
| testInvalidQuery(jpqlQuery, jpqlExpression); |
| } |
| |
| @Test |
| public void test_JPQLQuery_07() { |
| |
| String jpqlQuery = "SELECT d FROM DiscountCode d ORDER BY d.rate SUBSTRING"; |
| |
| SubstringExpressionTester substring = substring(nullExpression(), nullExpression()); |
| substring.hasLeftParenthesis = false; |
| substring.hasRightParenthesis = false; |
| |
| CollectionExpressionTester items = spacedCollection( |
| path("d.rate"), |
| isScalarExpressionSupported() ? substring : bad(substring) |
| ); |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("d")), |
| from("DiscountCode", "d"), |
| orderBy(orderByItem(items)) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_08() { |
| |
| String jpqlQuery = "SELECT e, f, g FROM Employee e, Manager g ORDER BY e.name"; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("f"), variable("g")), |
| from("Employee", "e", "Manager", "g"), |
| orderBy(orderByItem("e.name")) |
| ); |
| |
| testQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_09() { |
| |
| String jpqlQuery = "SELECT e, f, g " + |
| "FROM Employee e, Manager g " + |
| "ORDER BY e.name ASC, f.address DESC, g.phone"; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("f"), variable("g")), |
| from("Employee", "e", "Manager", "g"), |
| orderBy( |
| orderByItemAsc("e.name"), |
| orderByItemDesc("f.address"), |
| orderByItem("g.phone") |
| ) |
| ); |
| |
| testQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_10() { |
| |
| String jpqlQuery = "SELECT e, f, g " + |
| "FROM Employee e, Manager g " + |
| "ORDER BY e.name ASC ORDER, f.address DESC, g.phone"; |
| |
| OrderByItemTester item = orderByItemAsc("e.name"); |
| item.hasSpaceAfterOrdering = true; |
| |
| CollectionExpressionTester items = collection( |
| item, |
| orderByItem(variable("ORDER")), |
| orderByItemDesc("f.address"), |
| orderByItem("g.phone") |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("f"), variable("g")), |
| from("Employee", "e", "Manager", "g"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_11() { |
| |
| String jpqlQuery = "SELECT e, f, g " + |
| "FROM Employee e, Manager g " + |
| "ORDER BY e.name ASC NULLS ORDER, f.address DESC, g.phone"; |
| |
| OrderByItemTester item = orderByItemAscNullsFirst("e.name"); |
| item.nulls = NULLS; |
| item.hasSpaceAfterNulls = true; |
| |
| CollectionExpressionTester items = collection( |
| item, |
| orderByItem(variable("ORDER")), |
| orderByItemDesc("f.address"), |
| orderByItem("g.phone") |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("f"), variable("g")), |
| from("Employee", "e", "Manager", "g"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_12() { |
| |
| String jpqlQuery = "SELECT e, f, g " + |
| "FROM Employee e, Manager g " + |
| "ORDER BY e.name ASC NULLS SELECT, f.address DESC, g.phone"; |
| |
| OrderByItemTester item = orderByItemAscNullsFirst("e.name"); |
| item.nulls = NULLS; |
| item.hasSpaceAfterNulls = true; |
| |
| CollectionExpressionTester selectItems; |
| |
| if (isSubqueryResultVariableSupported()) { |
| selectItems = collection( |
| nullExpression(), |
| resultVariable(path("f.address"), DESC), |
| path("g.phone") |
| ); |
| } |
| else { |
| selectItems = collection( |
| nullExpression(), |
| path("f.address"), |
| variable(DESC), |
| path("g.phone") |
| ); |
| selectItems.commas[1] = false; |
| } |
| |
| SimpleSelectClauseTester subSelect = subSelect(selectItems); |
| subSelect.hasSpaceAfterSelect = false; |
| |
| SimpleSelectStatementTester select = subSelectStatement( |
| subSelect, |
| nullExpression() |
| ); |
| |
| CollectionExpressionTester items = collection( |
| item, |
| orderByItem(isSubquerySupported() ? select : bad(select)) |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("f"), variable("g")), |
| from("Employee", "e", "Manager", "g"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_13() { |
| |
| String jpqlQuery = "SELECT e, f, g " + |
| "FROM Employee e, Manager g " + |
| "ORDER BY e.name ASC NULLS FIRST ORDER, f.address DESC, g.phone"; |
| |
| OrderByItemTester item = orderByItemAscNullsFirst("e.name"); |
| item.hasSpaceAfterNulls = true; |
| |
| CollectionExpressionTester items = collection( |
| item, |
| orderByItem(variable("ORDER")), |
| orderByItemDesc("f.address"), |
| orderByItem("g.phone") |
| ); |
| items.commas[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("f"), variable("g")), |
| from("Employee", "e", "Manager", "g"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_14() { |
| |
| String jpqlQuery = "SELECT e, f, g " + |
| "FROM Employee e, Manager g " + |
| "ORDER BY e.name ASC NULLS ORDER FIRST, f.address DESC, g.phone"; |
| |
| OrderByItemTester item1 = orderByItemAscNullsFirst("e.name"); |
| item1.hasSpaceAfterNulls = true; |
| item1.nulls = NULLS; |
| |
| OrderByItemTester item2 = orderByItem( |
| spacedCollection( |
| variable("ORDER"), |
| variable(FIRST) |
| ) |
| ); |
| |
| CollectionExpressionTester items = collection( |
| item1, |
| item2, |
| orderByItemDesc("f.address"), |
| orderByItem("g.phone") |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("f"), variable("g")), |
| from("Employee", "e", "Manager", "g"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_15() { |
| |
| String jpqlQuery = "SELECT e, f, g " + |
| "FROM Employee e, Manager g " + |
| "ORDER BY e.name ASC ORDER NULLS FIRST, f.address DESC, g.phone"; |
| |
| OrderByItemTester item1 = orderByItemAsc("e.name"); |
| item1.hasSpaceAfterOrdering = true; |
| |
| OrderByItemTester item2 = orderByItemNullsFirst(variable("ORDER")); |
| |
| CollectionExpressionTester items = collection( |
| item1, |
| item2, |
| orderByItemDesc("f.address"), |
| orderByItem("g.phone") |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("f"), variable("g")), |
| from("Employee", "e", "Manager", "g"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_16() { |
| |
| String jpqlQuery = "SELECT e, f, g " + |
| "FROM Employee e, Manager g " + |
| "ORDER BY e.name ASC SUBSTRING NULLS FIRST, f.address DESC, g.phone"; |
| |
| OrderByItemTester item = orderByItemAsc("e.name"); |
| item.hasSpaceAfterOrdering = true; |
| |
| SubstringExpressionTester substring = substring(nullExpression(), nullExpression()); |
| substring.hasLeftParenthesis = false; |
| substring.hasRightParenthesis = false; |
| |
| CollectionExpressionTester items = collection( |
| item, |
| orderByItemNullsFirst(isScalarExpressionSupported() ? substring : bad(substring)), |
| orderByItemDesc("f.address"), |
| orderByItem("g.phone") |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("f"), variable("g")), |
| from("Employee", "e", "Manager", "g"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_17() { |
| |
| String jpqlQuery = "SELECT e, f, g " + |
| "FROM Employee e, Manager g " + |
| "ORDER BY e.name ASC NULLS SUBSTRING FIRST, f.address DESC, g.phone"; |
| |
| OrderByItemTester item1 = orderByItemAscNullsFirst("e.name"); |
| item1.hasSpaceAfterOrdering = true; |
| item1.hasSpaceAfterNulls = true; |
| item1.nulls = NULLS; |
| |
| SubstringExpressionTester substring = substring(nullExpression(), nullExpression()); |
| substring.hasLeftParenthesis = false; |
| substring.hasRightParenthesis = false; |
| |
| OrderByItemTester item2 = orderByItem( |
| spacedCollection( |
| isScalarExpressionSupported() ? substring : bad(substring), |
| variable(FIRST) |
| ) |
| ); |
| |
| CollectionExpressionTester items = collection( |
| item1, |
| item2, |
| orderByItemDesc("f.address"), |
| orderByItem("g.phone") |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| JPQLExpressionTester jpqlExpression = jpqlExpression( |
| selectStatement( |
| select(variable("e"), variable("f"), variable("g")), |
| from("Employee", "e", "Manager", "g"), |
| orderBy(items) |
| ) |
| ); |
| |
| testInvalidQuery(jpqlQuery, jpqlExpression); |
| } |
| |
| @Test |
| public void test_JPQLQuery_18() { |
| |
| if (isJPA1_0()) { |
| return; |
| } |
| |
| String jpqlQuery = "SELECT order AS order FROM Order order ORDER BY order"; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(resultVariableAs(variable("order"), "order")), |
| from("Order", "order"), |
| orderBy(orderByItem(variable("order"))) |
| ); |
| |
| testQuery(jpqlQuery, selectStatement, buildQueryFormatter_01(jpqlQuery)); |
| } |
| |
| @Test |
| public void test_JPQLQuery_19() { |
| |
| String query = "SELECT t,t.name FROM Table1 t ORDER BY NLSSORT(t.name, NLS_SORT=ENGLISH)"; |
| |
| CollectionExpressionTester collection = collection( |
| variable("NLSSORT"), |
| sub( |
| collection( |
| path("t.name"), |
| bad( |
| variable("NLS_SORT").equal(variable("ENGLISH")) |
| ) |
| ) |
| ) |
| ); |
| collection.commas[0] = false; |
| collection.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select( |
| collection( |
| variable("t"), |
| path("t.name") |
| ) |
| ), |
| from("Table1", "t"), |
| orderBy( |
| orderByItem(collection) |
| ) |
| ); |
| |
| testInvalidQuery(query, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_ASC_01() { |
| |
| String jpqlQuery = "SELECT e, m FROM Employee e, Manager m ORDER BY e.name ASC"; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("m")), |
| from("Employee", "e", "Manager", "m"), |
| orderBy(orderByItemAsc("e.name")) |
| ); |
| |
| testQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_ASC_02() { |
| |
| String jpqlQuery = "SELECT e, m FROM Employee e, Manager m ORDER BY e.name ASC ORDER"; |
| |
| OrderByItemTester item1 = orderByItemAsc("e.name"); |
| item1.hasSpaceAfterOrdering = true; |
| |
| CollectionExpressionTester items = collection( |
| item1, |
| orderByItem(variable("ORDER")) |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("m")), |
| from("Employee", "e", "Manager", "m"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_ASC_03() { |
| |
| String jpqlQuery = "SELECT e, m FROM Employee e, Manager m ORDER BY e.name ASC GROUP"; |
| |
| OrderByItemTester item1 = orderByItemAsc("e.name"); |
| item1.hasSpaceAfterOrdering = true; |
| |
| CollectionExpressionTester items = collection( |
| item1, |
| orderByItem(variable("GROUP")) |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("m")), |
| from("Employee", "e", "Manager", "m"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_ASC_04() { |
| |
| String jpqlQuery = "SELECT e, m FROM Employee e, Manager m ORDER BY e.name ASC SELECT"; |
| |
| OrderByItemTester item1 = orderByItemAsc("e.name"); |
| item1.hasSpaceAfterOrdering = true; |
| |
| SimpleSelectClauseTester subSelect = subSelect(nullExpression()); |
| subSelect.hasSpaceAfterSelect = false; |
| |
| SimpleSelectStatementTester select = subSelectStatement( |
| subSelect, |
| nullExpression() |
| ); |
| |
| CollectionExpressionTester items = collection( |
| item1, |
| orderByItem(isSubquerySupported() ? select : bad(select)) |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("m")), |
| from("Employee", "e", "Manager", "m"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_DESC_01() { |
| |
| String jpqlQuery = "SELECT e, m FROM Employee e, Manager m ORDER BY e.name DESC"; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("m")), |
| from("Employee", "e", "Manager", "m"), |
| orderBy(orderByItemDesc("e.name")) |
| ); |
| |
| testQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_DESC_02() { |
| |
| String jpqlQuery = "SELECT e, m FROM Employee e, Manager m ORDER BY e.name DESC ORDER"; |
| |
| OrderByItemTester item1 = orderByItemDesc("e.name"); |
| item1.hasSpaceAfterOrdering = true; |
| |
| CollectionExpressionTester items = collection( |
| item1, |
| orderByItem(variable("ORDER")) |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("m")), |
| from("Employee", "e", "Manager", "m"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_DESC_03() { |
| |
| String jpqlQuery = "SELECT e, m FROM Employee e, Manager m ORDER BY e.name DESC GROUP"; |
| |
| OrderByItemTester item1 = orderByItemDesc("e.name"); |
| item1.hasSpaceAfterOrdering = true; |
| |
| CollectionExpressionTester items = collection( |
| item1, |
| orderByItem(variable("GROUP")) |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("m")), |
| from("Employee", "e", "Manager", "m"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| |
| @Test |
| public void test_JPQLQuery_DESC_04() { |
| |
| String jpqlQuery = "SELECT e, m FROM Employee e, Manager m ORDER BY e.name DESC SELECT"; |
| |
| OrderByItemTester item1 = orderByItemDesc("e.name"); |
| item1.hasSpaceAfterOrdering = true; |
| |
| SimpleSelectClauseTester subSelect = subSelect(nullExpression()); |
| subSelect.hasSpaceAfterSelect = false; |
| |
| SimpleSelectStatementTester select = subSelectStatement( |
| subSelect, |
| nullExpression() |
| ); |
| |
| CollectionExpressionTester items = collection( |
| item1, |
| orderByItem(isSubquerySupported() ? select : bad(select)) |
| ); |
| items.commas[0] = false; |
| items.spaces[0] = false; |
| |
| SelectStatementTester selectStatement = selectStatement( |
| select(variable("e"), variable("m")), |
| from("Employee", "e", "Manager", "m"), |
| orderBy(items) |
| ); |
| |
| testInvalidQuery(jpqlQuery, selectStatement); |
| } |
| } |