| /* |
| * Copyright (c) 2005, 2021 Oracle and/or its affiliates. All rights reserved. |
| * Copyright (c) 2005, 2015 SAP. 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: |
| // 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 jakarta.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)", |
| 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, 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)"); |
| } |
| |
| } |
