/******************************************************************************* | |
* Copyright (c) 2005, 2009 SAP. All rights reserved. | |
* This program and the accompanying materials are made available under the | |
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 | |
* which accompanies this distribution. | |
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html | |
* and the Eclipse Distribution License is available at | |
* http://www.eclipse.org/org/documents/edl-v10.php. | |
* | |
* Contributors: | |
* SAP - initial API and implementation | |
******************************************************************************/ | |
package org.eclipse.persistence.testing.tests.wdf.jpa1.query; | |
import java.util.Calendar; | |
import java.util.HashSet; | |
import java.util.Set; | |
import javax.persistence.TemporalType; | |
import org.eclipse.persistence.testing.framework.wdf.Bugzilla; | |
import org.eclipse.persistence.testing.framework.wdf.ToBeInvestigated; | |
import org.junit.Test; | |
public class TestConditionalExpressions extends QueryTest { | |
@Test | |
public void testNumericComparisons() { | |
assertValidQuery("SELECT c FROM City c WHERE 5 > 6"); | |
assertValidQuery("SELECT c FROM City c WHERE 5 < 6"); | |
assertValidQuery("SELECT c FROM City c WHERE 5 >= 6"); | |
assertValidQuery("SELECT c FROM City c WHERE 5 <= 6"); | |
assertValidQuery("SELECT c FROM City c WHERE 5 = 6"); | |
assertValidQuery("SELECT c FROM City c WHERE 5 <> 6"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testEnumComparison0() { | |
assertInvalidQuery("SELECT c FROM City c WHERE c.type < org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testEnumComparison1() { | |
assertInvalidQuery("SELECT c FROM City c WHERE c.type >= org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testEnumComparison2() { | |
assertInvalidQuery("SELECT c FROM City c WHERE c.type <= org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY"); | |
} | |
@Test | |
public void testEnumComparison3() { | |
assertValidQuery("SELECT c FROM City c WHERE c.type = org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY"); | |
} | |
@Test | |
public void testEnumComparison4() { | |
assertValidQuery("SELECT c FROM City c WHERE c.type <> org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY"); | |
} | |
@Test | |
public void testEnumComparison5() { | |
assertValidQuery("SELECT c FROM City c WHERE c.id IN (SELECT min(c2.id) FROM City c2 WHERE c2.cityEnum = org.eclipse.persistence.testing.models.wdf.jpa1.jpql.City.CityEnum.BLI)"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testBooleanComparison0() { | |
assertInvalidQuery("SELECT c FROM City c WHERE c.cool > true"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testBooleanComparison1() { | |
assertInvalidQuery("SELECT c FROM City c WHERE c.cool < true"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testBooleanComparison2() { | |
assertInvalidQuery("SELECT c FROM City c WHERE c.cool >= true"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testBooleanComparison3() { | |
assertInvalidQuery("SELECT c FROM City c WHERE c.cool <= true"); | |
} | |
@Test | |
public void testBooleanComparison4() { | |
assertValidQuery("SELECT c FROM City c WHERE c.cool = true"); | |
} | |
@Test | |
public void testBooleanComparison5() { | |
assertValidQuery("SELECT c FROM City c WHERE c.cool <> true"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL, | |
// DatabaseVendor.ORACLE }) | |
public void testCurrentDateTimeComparison() { | |
assertValidQuery("SELECT c FROM City c WHERE current_time > current_time"); | |
assertValidQuery("SELECT c FROM City c WHERE current_time < current_time"); | |
assertValidQuery("SELECT c FROM City c WHERE current_date >= current_date"); | |
assertValidQuery("SELECT c FROM City c WHERE current_timestamp <= current_timestamp"); | |
assertValidQuery("SELECT c FROM City c WHERE current_time = current_time"); | |
assertValidQuery("SELECT c FROM City c WHERE current_time <> current_time"); | |
} | |
@Test | |
public void testPersistentObjectComparison0() { | |
assertInvalidQuery("SELECT c FROM City c WHERE c > c"); | |
} | |
@Test | |
public void testPersistentObjectComparison1() { | |
assertInvalidQuery("SELECT c FROM City c WHERE c < c"); | |
} | |
@Test | |
public void testPersistentObjectComparison2() { | |
assertInvalidQuery("SELECT c FROM City c WHERE c >= c"); | |
} | |
@Test | |
public void testPersistentObjectComparison3() { | |
assertInvalidQuery("SELECT c FROM City c WHERE c <= c"); | |
} | |
@Test | |
public void testPersistentObjectComparison4() { | |
assertValidQuery("SELECT c FROM City c WHERE c = c"); | |
} | |
@Test | |
public void testPersistentObjectComparison5() { | |
assertValidQuery("SELECT c FROM City c WHERE c <> c"); | |
} | |
@Test | |
public void testSimpleTypeComparisonHandling() { | |
Set<InputParameterHolder> par1 = new HashSet<InputParameterHolder>(); | |
par1.add(new InputParameterHolder("parameter1", Calendar.getInstance(), TemporalType.TIMESTAMP)); | |
assertValidQueryWithParameters("SELECT btfa FROM BasicTypesFieldAccess btfa WHERE btfa.utilCalendar = :parameter1", | |
par1); | |
assertValidQuery("SELECT c FROM City c WHERE (1 + (2 + 3) / 1 * 2) - 5 > -1"); | |
assertValidQuery("SELECT c FROM City c WHERE 'bla' = (SELECT p.string FROM Person p)"); | |
assertValidQuery("SELECT c FROM City c WHERE 'bla' = ALL(SELECT p.string FROM Person p)"); | |
assertValidQuery("SELECT p FROM Person p WHERE 'bla' = p.string"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = all.com.sap.ejbqlparser.test.Scale.STILL_ROCK"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = p.integer.p"); | |
assertValidQuery("SELECT p FROM Person p WHERE 'bla' = ?1"); | |
assertValidQuery("SELECT p FROM Person p WHERE 'bla' = :one"); | |
//assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.STILL_ROCK"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.NO_FIELD"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = MAX(p._float)"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = AVG(p.integer)"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = SUM(p.bigInteger)"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = SUM(p.integer)"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = SUM(p._float)"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = COUNT(p._float)"); | |
assertValidQuery("SELECT c FROM City c WHERE (SELECT p.string FROM Person p) = 'bla'"); | |
assertValidQuery("SELECT p FROM Person p HAVING 'bla' = MIN(p.string)"); | |
assertValidQuery("SELECT p FROM Person p WHERE p.string = 'bla'"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE all.com.sap.ejbqlparser.test.Scale.STILL_ROCK = 'bla'"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE p.integer.p = 'bla'"); | |
assertValidQuery("SELECT p FROM Person p WHERE ?1 = 'bla'"); | |
assertValidQuery("SELECT p FROM Person p WHERE :one = 'bla'"); | |
//assertInvalidQuery("SELECT p FROM Person p WHERE org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.STILL_ROCK = 'bla'"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.NO_FIELD = 'bla'"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE MAX(p._float) = 'bla'"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE AVG(p.integer) = 'bla'"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE SUM(p.bigInteger) = 'bla'"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE SUM(p.integer) = 'bla'"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE SUM(p._float) = 'bla'"); | |
assertInvalidQuery("SELECT p FROM Person p WHERE COUNT(p._float) = 'bla'"); | |
// TODO mapper: boolean literal in comparison with subquery | |
// assertValidQuery("SELECT c FROM City c WHERE (SELECT p._boolean FROM Person p) = true"); | |
// assertValidQuery("SELECT c FROM City c WHERE (SELECT p._Boolean FROM Person p) = true"); | |
// assertValidQuery("SELECT c FROM City c WHERE ALL(SELECT p._Boolean FROM Person p) = true"); | |
// assertValidQuery("SELECT c FROM City c WHERE SOME(SELECT p._boolean FROM Person p) = true"); | |
// TODO: mapper/parser: boolean comparison with input parameter | |
// assertValidQuery("SELECT p FROM Person p WHERE true = ?1"); | |
// assertValidQuery("SELECT p FROM Person p WHERE true = :one"); | |
assertValidQuery("SELECT p FROM Person p WHERE true = p._boolean"); | |
assertValidQuery("SELECT p FROM Person p WHERE true = p._Boolean"); | |
// assertValidQuery("SELECT p FROM Person p WHERE ?1 = false"); | |
// assertValidQuery("SELECT p FROM Person p WHERE :one = false"); | |
assertValidQuery("SELECT p FROM Person p WHERE p._boolean = false"); | |
assertValidQuery("SELECT p FROM Person p WHERE p._Boolean = false"); | |
assertValidQuery("SELECT p FROM Person p WHERE (SELECT p1.integer FROM Person p1) + 1 = 2"); | |
assertValidQuery("SELECT p FROM Person p WHERE 1 + (SELECT p1.integer FROM Person p1) = 2"); | |
//assertInvalidQuery("SELECT p FROM Person p WHERE -(SELECT p1.integer FROM Person p1) > 2"); | |
// TODO fix enum-handling in mapper | |
// assertValidQuery("SELECT c FROM City c WHERE org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY <> ALL(SELECT c1.type FROM City c1)"); | |
// assertValidQuery("SELECT c FROM City c WHERE org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY <> (SELECT c1.type FROM City c1)"); | |
// assertValidQuery("SELECT c FROM City c WHERE org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY <> c.type"); | |
// assertValidQuery("SELECT c FROM City c WHERE org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY <> ?1"); | |
// assertValidQuery("SELECT c FROM City c WHERE org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY <> :one"); | |
// assertValidQuery("SELECT c FROM City c WHERE (SELECT c1.type FROM City c1) <> org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY"); | |
assertValidQuery("SELECT c FROM City c WHERE c.type <> org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY"); | |
// TODO check input-parameter and enum-handling of mapper | |
// assertValidQuery("SELECT c FROM City c WHERE org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY <> ?1"); | |
// assertValidQuery("SELECT c FROM City c WHERE :one <> org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY"); | |
// assertValidQuery("SELECT c FROM City c WHERE org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY <> :one"); | |
// assertValidQuery("SELECT c FROM City c WHERE ?1 <> org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY"); | |
assertValidQuery("SELECT p FROM Person p WHERE p.sqlTime >= (SELECT p1.sqlTime FROM Person p1)"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testSimpleTypeComparisonHandling1() { | |
assertInvalidQuery("SELECT c FROM City c WHERE 'bla' = (SELECT p.integer FROM Person p)"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testSimpleTypeComparisonHandling2() { | |
assertInvalidQuery("SELECT c FROM City c WHERE 'bla' = ANY(SELECT p.integer FROM Person p)"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testSimpleTypeComparisonHandling3() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = p.integer"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testSimpleTypeComparisonHandling4() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = -(2 + 3)"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testSimpleTypeComparisonHandling5() { | |
assertInvalidQuery("SELECT c FROM City c WHERE (SELECT p.integer FROM Person p) = 'bla'"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testSimpleTypeComparisonHandling6() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE p.integer = 'bla'"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testSimpleTypeComparisonHandling7() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE -(2 + 3) = 'bla'"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testSimpleTypeComparisonHandling8() { | |
assertValidQuery("SELECT p FROM Person p WHERE MIN(p.string) = 'bla'"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL }) | |
public void testSimpleComparisonHandlingExcludingOpenSQL() { | |
assertValidQuery("SELECT p FROM Person p WHERE CURRENT_TIMESTAMP >= ALL(SELECT p1.sqlTimestamp FROM Person p1)"); | |
assertValidQuery("SELECT p FROM Person p WHERE CURRENT_DATE >= SOME(SELECT p1.sqlDate FROM Person p1)"); | |
assertValidQuery("SELECT p FROM Person p WHERE p.sqlTimestamp <= CURRENT_TIMESTAMP"); | |
assertValidQuery("SELECT p FROM Person p WHERE 'bla' = LOWER('BLA')"); | |
assertValidQuery("SELECT p FROM Person p WHERE CURRENT_TIMESTAMP >= p.sqlTimestamp"); | |
assertValidQuery("SELECT p FROM Person p WHERE CURRENT_TIMESTAMP >= ?1"); | |
assertValidQuery("SELECT p FROM Person p WHERE CURRENT_TIMESTAMP >= :one"); | |
assertValidQuery("SELECT p FROM Person p WHERE LOWER('BLA') = 'bla'"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL }) | |
@ToBeInvestigated | |
public void testSimpleComparisonHandlingExcludingOpenSQL1() { | |
assertValidQuery("SELECT p FROM Person p WHERE +p.integer + -5 * -(p.integer + 5) / -LENGTH(p.string) * -MAX(p._float) + +?1 = +p.integer + -5 * -(p.integer + 5) / -LOCATE(p.string, 'bla') * -AVG(p._float) + +?1"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL }) | |
@ToBeInvestigated | |
public void testSimpleComparisonHandlingExcludingOpenSQL2() { | |
assertValidQuery("SELECT p FROM Person p WHERE MAX(p.sqlDate) <= CURRENT_DATE"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL }) | |
@ToBeInvestigated | |
public void testSimpleComparisonHandlingExcludingOpenSQL3() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' = CURRENT_DATE"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL }) | |
@ToBeInvestigated | |
public void testSimpleComparisonHandlingExcludingOpenSQL4() { | |
assertValidQuery("SELECT p FROM Person p WHERE CURRENT_TIMESTAMP >= MAX(p.sqlTimestamp)"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL }) | |
@ToBeInvestigated | |
public void testSimpleComparisonHandlingExcludingOpenSQL5() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE CURRENT_DATE = 'bla'"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL, | |
// DatabaseVendor.ORACLE }) | |
public void testSimpleComparisonHandlingExcludingOpenSQLAndOracle0() { | |
assertValidQuery("SELECT p FROM Person p WHERE ?1 <= CURRENT_TIME"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL, | |
// DatabaseVendor.ORACLE }) | |
public void testSimpleComparisonHandlingExcludingOpenSQLAndOracle1() { | |
assertValidQuery("SELECT p FROM Person p WHERE :one <= CURRENT_TIME"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL, | |
// DatabaseVendor.ORACLE }) | |
@ToBeInvestigated | |
public void testSimpleComparisonHandlingExcludingOpenSQLAndOracle2() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE CURRENT_TIME = false"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL, | |
// DatabaseVendor.ORACLE }) | |
@ToBeInvestigated | |
public void testSimpleComparisonHandlingExcludingOpenSQLAndOracle3() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE true = CURRENT_TIME"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL, | |
// DatabaseVendor.ORACLE }) | |
public void testSimpleComparisonHandlingExcludingOpenSQLAndOracle4() { | |
assertValidQuery("SELECT p FROM Person p WHERE (SELECT p1.sqlTime FROM Person p1) <= CURRENT_TIME"); | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL, | |
// DatabaseVendor.ORACLE }) | |
public void testSimpleComparisonHandlingExcludingOpenSQLAndOracle5() { | |
assertValidQuery("SELECT p FROM Person p WHERE CURRENT_TIME >= ANY(SELECT p1.sqlTime FROM Person p1)"); | |
} | |
@Test | |
public void testBeanComparisonHandling() { | |
assertValidQuery("SELECT p FROM Person p WHERE p.city = ALL(Select c FROM City c)"); | |
assertValidQuery("SELECT p FROM Person p WHERE p.city = (Select c FROM City c)"); | |
assertValidQuery("SELECT p FROM Person p, City c WHERE p.city = c"); | |
assertValidQuery("SELECT p FROM Person p WHERE p.city = ?1"); | |
assertValidQuery("SELECT p FROM Person p WHERE ?1 = p.city"); | |
assertValidQuery("SELECT p FROM Person p WHERE p.city = :one"); | |
assertValidQuery("SELECT p FROM Person p WHERE :one = p.city"); | |
assertValidQuery("SELECT p FROM Person p, City c WHERE c = p.city"); | |
assertValidQuery("SELECT p FROM Person p WHERE (Select c FROM City c) = p.city"); | |
assertValidQuery("SELECT p FROM Person p, City c WHERE p.city = (c) and true = true or (false = true and 5 = 6)"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testBetweenHandling0() { | |
assertValidQuery("SELECT p FROM Person p WHERE p.id BETWEEN (SELECT p1.integer FROM Person p1) AND AVG(p._float)"); | |
} | |
@Test | |
public void testBetweenHandling1() { | |
assertValidQuery("SELECT p FROM Person p WHERE 5 BETWEEN 'bla' AND 'bla'"); | |
} | |
@Test | |
public void testBetweenHandling2() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE p BETWEEN 'bla' AND 'bla'"); | |
} | |
@Test | |
public void testBetweenHandling3() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE p.city.type BETWEEN 'bla' AND 'bla'"); | |
} | |
@Test | |
public void testBetweenHandling4() { | |
assertValidQuery("SELECT p FROM Person p WHERE org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY BETWEEN 'bla' AND 'bla'"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testBetweenHandling5() { | |
assertValidQuery("SELECT p FROM Person p WHERE 5 BETWEEN 2 AND MIN(p.integer)"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testBetweenHandling6() { | |
assertValidQuery("SELECT p FROM Person p WHERE MAX(p.string) BETWEEN ?1 AND (SELECT p1.string FROM Person p1)"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testBetweenHandling7() { | |
assertValidQuery("SELECT p FROM Person p WHERE p.id NOT BETWEEN (SELECT p1.integer FROM Person p1) AND AVG(p._float)"); | |
} | |
@Test | |
public void testBetweenHandling8() { | |
assertValidQuery("SELECT p FROM Person p WHERE 5 NOT BETWEEN 'bla' AND 'bla'"); | |
} | |
@Test | |
public void testBetweenHandling9() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE p NOT BETWEEN 'bla' AND 'bla'"); | |
} | |
@Test | |
public void testBetweenHandling10() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE p.city.type NOT BETWEEN 'bla' AND 'bla'"); | |
} | |
@Test | |
public void testBetweenHandling11() { | |
assertValidQuery("SELECT p FROM Person p WHERE org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY NOT BETWEEN 'bla' AND 'bla'"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testBetweenHandling12() { | |
assertValidQuery("SELECT p FROM Person p WHERE 5 NOT BETWEEN 2 AND MIN(p.integer)"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testBetweenHandling13() { | |
assertValidQuery("SELECT p FROM Person p WHERE MAX(p.string) NOT BETWEEN ?1 AND (SELECT p1.string FROM Person p1)"); | |
} | |
@Test | |
public void testPlatformDependendBetweenHandling0() { | |
assertValidQuery("SELECT p FROM Person p WHERE 2 + 3 BETWEEN LENGTH('bla') AND ?1"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testPlatformDependendBetweenHandling1() { | |
assertValidQuery("SELECT p FROM Person p WHERE p.sqlTimestamp BETWEEN CURRENT_TIMESTAMP AND p.sqlTimestamp"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testPlatformDependendBetweenHandling2() { | |
assertValidQuery("SELECT p FROM Person p WHERE (SELECT p1.string FROM Person p1) BETWEEN MIN(p.string) AND LOWER('bla')"); | |
} | |
@Test | |
public void testPlatformDependendBetweenHandling3() { | |
assertValidQuery("SELECT p FROM Person p WHERE p.sqlTimestamp NOT BETWEEN CURRENT_TIMESTAMP AND p.sqlTimestamp"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testPlatformDependendBetweenHandling4() { | |
assertValidQuery("SELECT p FROM Person p WHERE (SELECT p1.string FROM Person p1) NOT BETWEEN MIN(p.string) AND LOWER('bla')"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testLikeHandling00() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE 5 LIKE 'bla' ESCAPE 'c'"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testLikeHandling01() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE p.city.type LIKE 'bla' ESCAPE 'c'"); | |
} | |
@Test | |
public void testLikeHandling02() { | |
assertValidQuery("SELECT p FROM Person p WHERE p.string LIKE 'bla' ESCAPE 'c'"); | |
} | |
@Test | |
public void testLikeHandling03() { | |
assertValidQuery("SELECT p FROM Person p WHERE (SELECT p1.string FROM Person p1) LIKE 'bla' ESCAPE 'c'"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testLikeHandling04() { | |
assertValidQuery("SELECT p FROM Person p WHERE MAX(p.string) LIKE 'bla'"); | |
} | |
@Test | |
public void testLikeHandling05() { | |
assertValidQuery("SELECT p FROM Person p WHERE 'bla' LIKE ?1"); | |
} | |
@Test | |
public void testLikeHandling06() { | |
assertValidQuery("SELECT p FROM Person p WHERE 'bla' LIKE ?1"); | |
} | |
@Test | |
public void testLikeHandling07() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' LIKE 'bla' ESCAPE 'bla'"); | |
} | |
@Test | |
public void testLikeHandling08() { | |
assertValidQuery("SELECT p FROM Person p WHERE 'bla' LIKE 'bla' ESCAPE ?1"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testLikeHandling09() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE 5 NOT LIKE 'bla' ESCAPE 'c'"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testLikeHandling10() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE p.city.type NOT LIKE 'bla' ESCAPE 'c'"); | |
} | |
@Test | |
public void testLikeHandling11() { | |
assertValidQuery("SELECT p FROM Person p WHERE p.string NOT LIKE 'bla' ESCAPE 'c'"); | |
} | |
@Test | |
public void testLikeHandling12() { | |
assertValidQuery("SELECT p FROM Person p WHERE (SELECT p1.string FROM Person p1) NOT LIKE 'bla' ESCAPE 'c'"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testLikeHandling13() { | |
assertValidQuery("SELECT p FROM Person p WHERE MAX(p.string) NOT LIKE 'bla'"); | |
} | |
@Test | |
public void testLikeHandling14() { | |
assertValidQuery("SELECT p FROM Person p WHERE 'bla' NOT LIKE ?1"); | |
} | |
@Test | |
public void testLikeHandling15() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE 'bla' NOT LIKE 'bla' ESCAPE 'bla'"); | |
} | |
@Test | |
public void testLikeHandling16() { | |
assertValidQuery("SELECT p FROM Person p WHERE 'bla' NOT LIKE 'bla' ESCAPE ?1"); | |
} | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL, | |
// DatabaseVendor.SAPDB }) | |
public void testLikeHandlingExcludingOpenSQL() { | |
assertInvalidQuery("SELECT p FROM Person p WHERE LOWER(p.string) LIKE UPPER(p.string)"); | |
assertValidQuery("SELECT p FROM Person p WHERE LOWER(p.string) LIKE '%foobar%'"); | |
} | |
@Test | |
public void testInHandling() { | |
assertInvalidQuery("select p from Person as p where p.city in (2, 3, 4)"); | |
assertInvalidQuery("select p from Person as p where CURRENT_DATE in (2, 3, 4)"); | |
assertValidQuery("select p from Person as p where p._float in (2, 3, 4.4, :one)"); | |
//assertInvalidQuery("select p from Person as p where p._float in (2, 'bla', 4.4)"); | |
//assertInvalidQuery("select p from Person as p where p.city.type in (org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Metal.DEATH)"); | |
assertValidQuery("select p from Person as p where p.city.type in (select c.type from City as c)"); | |
assertValidQuery("select p from Person as p where p.string in ('2', '3', '4.4', :one)"); | |
assertValidQuery("select p from Person as p where p.string in ('2', '3', '4.4', :one)"); | |
//assertInvalidQuery("select p from Person as p where p.city NOT in (2, 3, 4)"); | |
//assertInvalidQuery("select p from Person as p where CURRENT_DATE Not in (2, 3, 4)"); | |
assertValidQuery("select p from Person as p where p._float nOt in (2, 3, 4.4, :one)"); | |
//assertInvalidQuery("select p from Person as p where p._float noT in (2, 'bla', 4.4)"); | |
//assertInvalidQuery("select p from Person as p where p.city.type not in (org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Metal.DEATH)"); | |
assertValidQueryExecution("select p from Person as p where p.city.type not in (select c.type from City as c)"); | |
assertValidQuery("select p from Person as p where p.string not in ('2', '3', '4.4', :one)"); | |
} | |
@Test | |
public void testInBinary() { | |
byte[] byteArr1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; | |
byte[] byteArr2 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8 }; | |
assertValidQueryExecutionWithArgs("SELECT b FROM BasicTypesFieldAccess b WHERE b.primitiveByteArray2Binary IN(?1,?2)", | |
new Object[] { byteArr1, byteArr2 }); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testInHandling0() { | |
assertInvalidQuery("select p from Person as p where 2 in (2, 3, 4)"); | |
} | |
@Test | |
public void testInHandling1() { | |
assertValidQuery("select p from Person as p where p.city.type in (org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY, org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.STUCK_TURTLE, org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUNNING_ELEPHAN, :one)"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testInHandling2() { | |
assertInvalidQuery("select p from Person as p where 2 not in (2, 3, 4)"); | |
} | |
@Test | |
public void testInHandling3() { | |
assertValidQuery("select p from Person as p where p.city.type not in (org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUSH_PIGSTY, org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.STUCK_TURTLE, org.eclipse.persistence.testing.models.wdf.jpa1.jpql.Scale.RUNNING_ELEPHAN, :one)"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testInHandling4() { | |
byte[] byteArr1 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8 }; | |
byte[] byteArr2 = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8 }; | |
String queryString = "SELECT p FROM PrincipalEntity p WHERE p.taskInstance.taskInstanceId IN (?1,?2)"; | |
assertValidQueryExecutionWithArgs(queryString, new Object[] { byteArr1, byteArr2 }); | |
} | |
@Test | |
public void testIsNullHandling0() { | |
assertValidQuery("select p from Person as p where p.city is null"); | |
} | |
@Test | |
public void testIsNullHandling1() { | |
assertValidQuery("select p from Person as p where :one is null"); | |
} | |
@Test | |
public void testIsNullHandling2() { | |
assertValidQuery("select p from Person as p where p is null"); | |
} | |
@Test | |
public void testIsNullHandling3() { | |
assertInvalidQuery("select p from Person as p where p.city.cops is null"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testIsNullHandling4() { | |
assertInvalidQuery("select p from Person as p where 2 + 3 is null"); | |
} | |
@Test | |
public void testIsNullHandling5() { | |
assertValidQuery("select p from Person as p where p.city is not null"); | |
} | |
@Test | |
public void testIsNullHandling6() { | |
assertValidQuery("select p from Person as p where :one is not null"); | |
} | |
@Test | |
public void testIsNullHandling7() { | |
assertValidQuery("select p from Person as p where p is not null"); | |
} | |
@Test | |
public void testIsNullHandling8() { | |
assertInvalidQuery("select p from Person as p where p.city.cops is NOT null"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testIsNullHandling9() { | |
assertInvalidQuery("select p from Person as p where 2 + 3 is not null"); | |
} | |
@Test | |
public void testIsEmptyHandling0() { | |
assertInvalidQuery("select p from Person p where p.city is empty"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testIsEmptyHandling1() { | |
assertInvalidQuery("select p from Person p where p is empty"); | |
} | |
@Test | |
public void testIsEmptyHandling2() { | |
assertValidQuery("select c from Criminal c where c.attachedCop.partner.partner.partner.attachedCriminals is empty"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testIsEmptyHandling3() { | |
assertInvalidQuery("select p from Person p where (2 * 4) is empty"); | |
} | |
@Test | |
public void testIsEmptyHandling4() { | |
assertInvalidQuery("select p from Person p where p.city.rivers is empty"); | |
} | |
@Test | |
public void testIsEmptyHandling5() { | |
assertInvalidQuery("select p from Person p where p.city is not empty"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testIsEmptyHandling6() { | |
assertInvalidQuery("select p from Person p where p is NOT empty"); | |
} | |
@Test | |
public void testIsEmptyHandling7() { | |
assertValidQuery("select c from Criminal c where c.attachedCop.partner.partner.partner.informers is not empty"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testIsEmptyHandling8() { | |
assertInvalidQuery("select p from Person p where (2 * 4) is not empty"); | |
} | |
@Test | |
public void testIsEmptyHandling9() { | |
assertInvalidQuery("select p from Person p where p.city.rivers is not empty"); | |
} | |
@Test | |
public void testMemberOfHandling() { | |
assertInvalidQuery("select cri from Criminal cri, City c where cri.attachedCop member c.criminals"); | |
assertInvalidQuery("select cri from Criminal cri, City c where cri member c.rivers"); | |
assertInvalidQuery("select cri from Criminal cri, City c where 5 member c.rivers"); | |
assertInvalidQuery("select p from City c, Person p where p.integer member c.criminals"); | |
assertValidQuery("select c from City c where :one member OF c.criminals"); | |
assertInvalidQuery("select c from City c where (select p from Person p) member OF c.criminals"); | |
assertInvalidQuery("select c from City c where avg(c.id) member OF c.criminals"); | |
assertValidQuery("select cri from Criminal cri, City c where cri.attachedCop not member of c.cops"); | |
assertInvalidQuery("select cri from Criminal cri, City c where cri.attachedCop not member c.criminals"); | |
assertValidQuery("select cri from Criminal cri, City c where cri not member c.criminals"); | |
assertInvalidQuery("select cri from Criminal cri, City c where cri not member c.rivers"); | |
assertInvalidQuery("select cri from Criminal cri, City c where 5 NOT member c.rivers"); | |
assertInvalidQuery("select p from City c, Person p where p.integer not member c.criminals"); | |
assertValidQuery("select c from City c where :one not member OF c.criminals"); | |
assertInvalidQuery("select c from City c where (select p from Person p) not member OF c.criminals"); | |
assertInvalidQuery("select c from City c where avg(c.id) not member OF c.criminals"); | |
} | |
@Test | |
public void testMemberOfHandling0() { | |
assertValidQuery("select cri from Criminal cri, City c where cri.attachedCop member of c.cops"); | |
} | |
@Test | |
public void testMemberOfHandling4() { | |
assertValidQuery("select cri from Criminal cri, City c where cri member c.criminals"); | |
} | |
@Test | |
@ToBeInvestigated | |
public void testMemberOfHandling1() { | |
assertInvalidQuery("select p from City c, Person p where p.city.criminals member OF c.criminals"); | |
} | |
@Test | |
public void testMemberOfHandling2() { | |
assertInvalidQuery("select p from City c, Person p where p.city.criminals not member OF c.criminals"); | |
} | |
@Test | |
public void testExistsHandling() { | |
assertValidQuery("select c from City c where exists (select p from Person p)"); | |
assertValidQuery("select c from City c where not exists (select p from Person p)"); | |
} | |
} |