| /* |
| * 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.tools; |
| |
| import java.math.BigDecimal; |
| import java.math.BigInteger; |
| import java.util.Collection; |
| import java.util.Date; |
| import java.util.Map; |
| import java.util.Vector; |
| import org.eclipse.persistence.jpa.jpql.tools.AbstractJPQLQueryHelper; |
| import org.eclipse.persistence.jpa.jpql.tools.spi.IEntity; |
| import org.eclipse.persistence.jpa.jpql.tools.spi.IManagedType; |
| import org.eclipse.persistence.jpa.jpql.tools.spi.IManagedTypeProvider; |
| import org.eclipse.persistence.jpa.jpql.tools.spi.IQuery; |
| import org.eclipse.persistence.jpa.jpql.tools.spi.IType; |
| import org.eclipse.persistence.jpa.jpql.tools.spi.ITypeRepository; |
| import org.eclipse.persistence.jpa.tests.jpql.JPQLCoreTest; |
| import org.eclipse.persistence.jpa.tests.jpql.JPQLQueryHelperTestHelper; |
| import org.eclipse.persistence.jpa.tests.jpql.tools.spi.java.JavaQuery; |
| import org.junit.Test; |
| import static org.junit.Assert.*; |
| |
| /** |
| * The unit-tests for {@link AbstractJPQLQueryHelper#getParameterType(String)} and |
| * {@link AbstractJPQLQueryHelper#getResultType()}. |
| * |
| * @version 2.4 |
| * @since 2.3 |
| * @author Pascal Filion |
| */ |
| @SuppressWarnings("nls") |
| public abstract class AbstractJPQLQueryHelperTest extends JPQLCoreTest { |
| |
| @JPQLQueryHelperTestHelper |
| private AbstractJPQLQueryHelper jpqlQueryHelper; |
| |
| protected AbstractJPQLQueryHelper buildQueryHelper(IQuery namedQuery) { |
| jpqlQueryHelper.setQuery(namedQuery); |
| return jpqlQueryHelper; |
| } |
| |
| protected IManagedType entity(IManagedTypeProvider provider, String entityName) { |
| IEntity entity = provider.getEntityNamed(entityName); |
| assertNotNull("The entity " + entityName + " could not be found", entity); |
| return entity; |
| } |
| |
| protected IType getType(IQuery query, Class<?> type) { |
| return typeRepository(query).getType(type); |
| } |
| |
| protected IType getType(IQuery query, String typeName) { |
| return typeRepository(query).getType(typeName); |
| } |
| |
| protected IType mappedType(IQuery query, String entityName) { |
| return query.getProvider().getEntityNamed(entityName).getType(); |
| } |
| |
| protected abstract IQuery namedQuery(String entityName, String queryName) throws Exception; |
| |
| protected IManagedTypeProvider provider(IQuery query) { |
| return query.getProvider(); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| jpqlQueryHelper.dispose(); |
| super.tearDown(); |
| } |
| |
| @Override |
| protected void tearDownClass() throws Exception { |
| jpqlQueryHelper = null; |
| super.tearDownClass(); |
| } |
| |
| @Test |
| public final void test_ParameterType_01() throws Exception { |
| |
| // select ds from Employee ds, Product ci where ds.empId = :conversationId AND ds.state = 0 AND ds.cikey = ci.cikey AND ci.state <> 2 |
| IQuery namedQuery = namedQuery("Employee", "employee.empId"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":conversationId"); |
| |
| assertNotNull( |
| "The type of :conversationId should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :conversationId was retrieved", |
| getType(namedQuery, Long.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_02() throws Exception { |
| |
| // SELECT a.alias FROM Alias AS a WHERE (a.alias IS NULL AND :param1 IS NULL) OR a.alias = :param1 |
| IQuery namedQuery = namedQuery("Alias", "alias.param1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":param1"); |
| |
| assertNotNull( |
| "The type of :param1 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :param1 was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_03() throws Exception { |
| |
| // SELECT Distinct Object(c) From Customer c, IN(c.home.phones) p where p.area LIKE :area |
| IQuery namedQuery = namedQuery("Customer", "customer.area"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":area"); |
| |
| assertNotNull( |
| "The type of :area should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :area was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_04() throws Exception { |
| |
| // select c.firstName FROM Customer c Group By c.firstName HAVING c.firstName = concat(:fname, :lname) |
| IQuery namedQuery = namedQuery("Customer", "customer.name"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":fname"); |
| |
| assertNotNull( |
| "The type of :fname should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :fname was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_05() throws Exception { |
| |
| // select count(c) FROM Customer c JOIN c.aliases a GROUP BY a.alias HAVING a.alias = SUBSTRING(:string1, :int1, :int2) |
| IQuery namedQuery = namedQuery("Customer", "customer.substring"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":int1"); |
| |
| assertNotNull( |
| "The type of :int1 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :int1 was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_06() throws Exception { |
| |
| // select count(c) FROM Customer c JOIN c.aliases a GROUP BY a.alias HAVING a.alias = SUBSTRING(:string1, :int1, :int2) |
| IQuery namedQuery = namedQuery("Customer", "customer.substring"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":int2"); |
| |
| assertNotNull( |
| "The type of :int2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :int2 was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_07() throws Exception { |
| |
| // select c.firstName FROM Customer c Group By c.firstName HAVING c.firstName = concat(:fname, :lname) |
| IQuery namedQuery = namedQuery("Customer", "customer.name"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":lname"); |
| |
| assertNotNull( |
| "The type of :lname should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :lname was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_08() throws Exception { |
| |
| // select count(c) FROM Customer c JOIN c.aliases a GROUP BY a.alias HAVING a.alias = SUBSTRING(:string1, :int1, :int2) |
| IQuery namedQuery = namedQuery("Customer", "customer.substring"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":string1"); |
| |
| assertNotNull( |
| "The type of :string1 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :string1 was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_09() throws Exception { |
| |
| // select o from Dept o where o.dname in (:dname1, :dname2, :dname3) |
| IQuery namedQuery = namedQuery("Dept", "dept.dname"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":dname1"); |
| |
| assertNotNull( |
| "The type of :dname1 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :newdate was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_10() throws Exception { |
| |
| // select o from Dept o where o.dname in (:dname1, :dname2, :dname3) |
| IQuery namedQuery = namedQuery("Dept", "dept.dname"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":dname2"); |
| |
| assertNotNull( |
| "The type of :dname2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :newdate was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_11() throws Exception { |
| |
| // select o from Dept o where o.dname in (:dname1, :dname2, :dname3) |
| IQuery namedQuery = namedQuery("Dept", "dept.dname"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":dname3"); |
| |
| assertNotNull( |
| "The type of :dname3 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :newdate was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_12() throws Exception { |
| |
| // SELECT e FROM Employee e WHERE e.department = :dept AND e.salary > :base |
| IQuery namedQuery = namedQuery("Employee", "employee.deptBase"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":base"); |
| |
| assertNotNull( |
| "The type of :base should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :base was retrieved", |
| getType(namedQuery, Long.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_13() throws Exception { |
| |
| // DELETE FROM Employee e WHERE e.department = :dept |
| IQuery namedQuery = namedQuery("Employee", "employee.delete.dept"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":dept"); |
| |
| assertNotNull( |
| "The type of :dept should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :dept was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_14() throws Exception { |
| |
| // SELECT e FROM Employee e WHERE e.department = :dept AND e.salary > :base |
| IQuery namedQuery = namedQuery("Employee", "employee.deptBase"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":dept"); |
| |
| assertNotNull( |
| "The type of :dept should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :dept was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_15() throws Exception { |
| |
| // SELECT e FROM Employee e WHERE e.name IN :type |
| IQuery namedQuery = namedQuery("Employee", "employee.in"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":type"); |
| |
| assertNotNull( |
| "The type of :type should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :type was retrieved", |
| getType(namedQuery, Collection.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_16() throws Exception { |
| |
| // SELECT e FROM Employee e WHERE e.name = ?1 ORDER BY e.name |
| IQuery namedQuery = namedQuery("Employee", "employee.?1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType("?1"); |
| |
| assertNotNull( |
| "The type of ?1 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for ?1 was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_17() throws Exception { |
| |
| // SELECT e FROM Employee e WHERE e.salary = (SELECT MAX(e.salary) FROM Employee a WHERE a.department = :dept) |
| IQuery namedQuery = namedQuery("Employee", "employee.dept"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":dept"); |
| |
| assertNotNull( |
| "The type of :dept should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :dept was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_18() throws Exception { |
| |
| // UPDATE Employee e SET e.manager = ?1 WHERE e.department = ?2 |
| IQuery namedQuery = namedQuery("Employee", "employee.update.positional"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType("?1"); |
| |
| assertNotNull( |
| "The type of ?1 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for ?1 was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_19() throws Exception { |
| |
| // UPDATE Employee e SET e.manager = ?1 WHERE e.department = ?2 |
| IQuery namedQuery = namedQuery("Employee", "employee.update.positional"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType("?2"); |
| |
| assertNotNull( |
| "The type of ?2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for ?2 was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_20() throws Exception { |
| |
| String jpqlQuery = "SELECT c From Customer c where c.home.city IN(:city)"; |
| IQuery namedQuery = new JavaQuery(getPersistenceUnit(), jpqlQuery); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":city"); |
| |
| assertNotNull("The type of :city should have been found", type); |
| |
| assertEquals( |
| "The wrong type for :city was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_21() throws Exception { |
| |
| // select object(o) FROM Order o Where SQRT(o.totalPrice) > :doubleValue |
| IQuery namedQuery = namedQuery("Order", "order.doubleValue"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":doubleValue"); |
| |
| assertNotNull( |
| "The type of :dept should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :dept was retrieved", |
| getType(namedQuery, Double.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_22() throws Exception { |
| |
| // SELECT DISTINCT p From Product p where p.shelfLife.soldDate NOT BETWEEN :date1 AND :newdate |
| IQuery namedQuery = namedQuery("Product", "product.date"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":date1"); |
| |
| assertNotNull( |
| "The type of :date1 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :date1 was retrieved", |
| getType(namedQuery, Date.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_23() throws Exception { |
| |
| // Select Distinct Object(p) from Product p where (p.quantity > (500 + :int1)) AND (p.partNumber IS NULL)) |
| IQuery namedQuery = namedQuery("Product", "product.int1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":int1"); |
| |
| assertNotNull( |
| "The type of :dept should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :dept was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_24() throws Exception { |
| |
| // SELECT DISTINCT p From Product p where p.shelfLife.soldDate NOT BETWEEN :date1 AND :newdate |
| IQuery namedQuery = namedQuery("Product", "product.date"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":newdate"); |
| |
| assertNotNull( |
| "The type of :newdate should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :newdate was retrieved", |
| getType(namedQuery, Date.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_25() throws Exception { |
| |
| // SELECT e FROM Employee e WHERE EXISTS (SELECT p FROM Project p JOIN p.employees emp WHERE emp = e AND p.name = :name) |
| IQuery namedQuery = namedQuery("Employee", "employee.subquery1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType(":name"); |
| |
| assertNotNull( |
| "The type of :name should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for :name was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ParameterType_26() throws Exception { |
| |
| // SELECT e FROM Employee e WHERE 2 < ALL(SELECT a FROM Address a WHERE 2 < ANY(SELECT d FROM Dept WHERE a.city = ?1) |
| IQuery namedQuery = namedQuery("Address", "address.subquery.subquery"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getParameterType("?1"); |
| |
| assertNotNull( |
| "The type of ?1 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for ?1 was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_01() throws Exception { |
| |
| // SELECT ABS(p.quantity) FROM Product p |
| IQuery namedQuery = namedQuery("Product", "product.abs"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of ABS(p.quantity) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for ABS(p.quantity) was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_02() throws Exception { |
| |
| // SELECT ABS(o.totalPrice) FROM Order o |
| IQuery namedQuery = namedQuery("Order", "order.abs"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of ABS(o.totalPrice) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for ABS(o.totalPrice) was retrieved", |
| getType(namedQuery, Double.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_03() throws Exception { |
| |
| // SELECT ABS(p.id) FROM Project p |
| IQuery namedQuery = namedQuery("Project", "project.abs"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of ABS(p.id) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for ABS(p.id) was retrieved", |
| getType(namedQuery, Float.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_04() throws Exception { |
| |
| // SELECT 2 + 2.2F FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.addition1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of 2 + 2.2F should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for 2 + 2.2F was retrieved", |
| getType(namedQuery, Float.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_05() throws Exception { |
| |
| // SELECT AVG(e.salary) + 2E2 FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.addition2"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of AVG(salary) + 2E2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for AVG(salary) + 2E2 was retrieved", |
| getType(namedQuery, Double.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_06() throws Exception { |
| |
| // SELECT e.salary + 2 FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.addition3"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of e.salary + 2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for e.salary + 2 was retrieved", |
| getType(namedQuery, Long.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_07() throws Exception { |
| |
| // SELECT e.name + 2 FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.addition4"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of e.name + 2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for e.name + 2 was retrieved", |
| getType(namedQuery, Object.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_08() throws Exception { |
| |
| // SELECT AVG(p.quantity) FROM Product p |
| IQuery namedQuery = namedQuery("Product", "product.quantity"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of AVG(p.quantity) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for AVG(p.quantity) was retrieved", |
| getType(namedQuery, Double.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_09() throws Exception { |
| |
| // SELECT CASE WHEN e.name = 'Java Persistence Query Language' THEN 'Java Persistence Query Language' |
| // WHEN 1 + 2 THEN SUBSTRING(e.name, 0, 2) |
| // ELSE e.name |
| // END |
| // FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.case1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of CASE(...) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for CASE(...) was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_10() throws Exception { |
| |
| // SELECT CASE WHEN e.name = 'JPQL' THEN e.working |
| // WHEN 1 + 2 THEN TRUE |
| // ELSE p.completed |
| // END |
| // FROM Employee e, Project p |
| IQuery namedQuery = namedQuery("Employee", "employee.case2"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of CASE(...) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for CASE(...) was retrieved", |
| getType(namedQuery, Boolean.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_11() throws Exception { |
| |
| // SELECT CASE WHEN e.name = 'JPQL' THEN e.working |
| // WHEN 1 + 2 THEN SUBSTRING(e.name, 0, 2) |
| // ELSE e.dept |
| // END |
| // FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.case3"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of CASE(...) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for CASE(...) was retrieved", |
| getType(namedQuery, Object.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_12() throws Exception { |
| |
| // SELECT e FROM Employee E |
| IQuery namedQuery = namedQuery("Employee", "employee.caseInsensitive"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of e should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for e was retrieved", |
| mappedType(namedQuery, "Employee"), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_13() throws Exception { |
| |
| // SELECT COALESCE(o.price, o.price) FROM Order o |
| IQuery namedQuery = namedQuery("Order", "order.coalesce1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of COALESCE(o.price, o.price) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for COALESCE(o.price, o.price) was retrieved", |
| getType(namedQuery, BigInteger.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_14() throws Exception { |
| |
| // SELECT COALESCE(o.totalPrice, SQRT(o.realPrice)) FROM Order o |
| IQuery namedQuery = namedQuery("Order", "order.coalesce2"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of COALESCE(o.totalPrice, SQRT(o.realPrice)) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for COALESCE(o.totalPrice, SQRT(o.realPrice)) was retrieved", |
| getType(namedQuery, Double.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_15() throws Exception { |
| |
| // SELECT COALESCE(o.number, e.name) FROM Order o, Employee e |
| IQuery namedQuery = namedQuery("Order", "order.coalesce3"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of COALESCE(o.number, e.name) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for COALESCE(o.number, e.name) was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_16() throws Exception { |
| |
| // SELECT COALESCE(o.price, o.number) FROM Order o |
| IQuery namedQuery = namedQuery("Order", "order.coalesce4"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of COALESCE(o.price, o.number) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for COALESCE(o.price, o.number) was retrieved", |
| getType(namedQuery, Object.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_17() throws Exception { |
| |
| // SELECT e.name, d.dname FROM Employee e, Dept d |
| IQuery namedQuery = namedQuery("Employee", "employee.collection"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of (e.name, d.dname) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for (e.name, d.dname) was retrieved", |
| getType(namedQuery, Object[].class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_18() throws Exception { |
| |
| // SELECT c FROM Address a JOIN a.customerList c |
| IQuery namedQuery = namedQuery("Address", "address.collection"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of c should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for c was retrieved", |
| mappedType(namedQuery, "Customer"), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_19() throws Exception { |
| |
| // SELECT CONCAT(a.street, a.city) FROM Address a |
| IQuery namedQuery = namedQuery("Address", "address.concat"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of CONCAT(a.street, a.city) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for CONCAT(a.street, a.city) was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_20() throws Exception { |
| |
| // select count(c) FROM Customer c JOIN c.aliases a GROUP BY a.alias HAVING a.alias = SUBSTRING(:string1, :int1, :int2) |
| IQuery namedQuery = namedQuery("Customer", "customer.substring"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of count(c) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for count(c) was retrieved", |
| getType(namedQuery, Long.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_21() throws Exception { |
| |
| // select count(c) FROM Customer c JOIN c.aliases a GROUP BY a.alias HAVING a.alias = SUBSTRING(:string1, :int1, :int2) |
| IQuery namedQuery = namedQuery("Customer", "customer.substring"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of count(c) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for count(c) was retrieved", |
| getType(namedQuery, Long.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_22() throws Exception { |
| |
| // SELECT CURRENT_DATE FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.date1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of CURRENT_DATE should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for CURRENT_DATE was retrieved", |
| getType(namedQuery, java.sql.Date.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_23() throws Exception { |
| |
| // SELECT {d '2008-12-31'} FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.date2"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of {d '2008-12-31'} should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for {d '2008-12-31'} was retrieved", |
| getType(namedQuery, java.sql.Date.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_24() throws Exception { |
| |
| // DELETE FROM Employee e WHERE e.department = :dept |
| IQuery namedQuery = namedQuery("Employee", "employee.delete.dept"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The object type should have been returned", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type was retrieved", |
| getType(namedQuery, Object.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_25() throws Exception { |
| |
| // SELECT 2 / 2.2F FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.division1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of 2 / 2.2F should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for 2 / 2.2F was retrieved", |
| getType(namedQuery, Float.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_26() throws Exception { |
| |
| // SELECT AVG(e.salary) / 2E2 FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.division2"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of AVG(salary) / 2E2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for AVG(salary) / 2E2 was retrieved", |
| getType(namedQuery, Double.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_27() throws Exception { |
| |
| // SELECT e.salary / 2 FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.division3"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of e.salary / 2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for e.salary / 2 was retrieved", |
| getType(namedQuery, Long.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_28() throws Exception { |
| |
| // SELECT e.name / 2 FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.division4"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of e.name / 2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for e.name / 2 was retrieved", |
| getType(namedQuery, Object.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_29() throws Exception { |
| |
| // SELECT ENTRY(e) FROM Alias a JOIN a.ids e |
| IQuery namedQuery = namedQuery("Alias", "alias.entry"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of ENTRY(e) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for ENTRY(e) was retrieved", |
| getType(namedQuery, Map.Entry.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_30() throws Exception { |
| |
| // SELECT CASE WHEN e.name = 'Pascal' THEN jpql.query.EnumType.FIRST_NAME |
| // WHEN e.name = 'JPQL' THEN jpql.query.EnumType.LAST_NAME |
| // ELSE jpql.query.EnumType.NAME |
| // END |
| // FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.enum"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of the case should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for 2 - 2.2F was retrieved", |
| helper.getTypeRepository().getType("jpql.query.EnumType"), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_31() throws Exception { |
| |
| // SELECT INDEX(c) FROM Address a JOIN a.customerList c |
| IQuery namedQuery = namedQuery("Address", "address.index"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of INDEX(e) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for INDEX(c) was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_32() throws Exception { |
| |
| // SELECT c.lastName FROM Address a JOIN a.customerList AS c |
| IQuery namedQuery = namedQuery("Address", "address.stateField"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The object type should have been returned", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_33() throws Exception { |
| |
| // SELECT KEY(k) FROM Alias a JOIN a.ids k |
| IQuery namedQuery = namedQuery("Alias", "alias.key1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of KEY(k) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for KEY(k) was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_34() throws Exception { |
| |
| // SELECT TRUE FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.true"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of TRUE should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for TRUE was retrieved", |
| getType(namedQuery, Boolean.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_35() throws Exception { |
| |
| // SELECT FALSE FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.false"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of FALSE should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for FALSE was retrieved", |
| getType(namedQuery, Boolean.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_36() throws Exception { |
| |
| // SELECT LENGTH(a.street) FROM Address a |
| IQuery namedQuery = namedQuery("Address", "address.length"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of LENGTH(a.street) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for LENGTH(a.street) was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_37() throws Exception { |
| |
| // SELECT LOCATE(a.street, 'Arco Drive') FROM Address a |
| IQuery namedQuery = namedQuery("Address", "address.locate"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of LOCATE(a.street, 'Arco Drive') should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for LOCATE(a.street, 'Arco Drive') was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_38() throws Exception { |
| |
| // SELECT LOWER(e.name) FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.lower"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of LOWER(e.name) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for LOWER(e.name) was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_39() throws Exception { |
| |
| // SELECT MAX(p.quantity) FROM Product p |
| IQuery namedQuery = namedQuery("Product", "product.max"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of MAX(p.quantity) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for MAX(p.quantity) was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_40() throws Exception { |
| |
| // SELECT MAX(e.salary) FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.max"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of MAX(e.salary) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for MAX(e.salary) was retrieved", |
| getType(namedQuery, Long.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_41() throws Exception { |
| |
| // SELECT MIN(p.quantity) FROM Product p |
| IQuery namedQuery = namedQuery("Product", "product.min"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of MIN(p.quantity) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for MIN(p.quantity) was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_42() throws Exception { |
| |
| // SELECT MIN(e.salary) FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.min"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of MIN(e.salary) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for MIN(e.salary) was retrieved", |
| getType(namedQuery, Long.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_43() throws Exception { |
| |
| // SELECT MOD(e.salary, e.empId) FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.mod"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of MOD(e.salary, e.empId) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for MOD(e.salary, e.empId) was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_44() throws Exception { |
| |
| // SELECT 2 * 2.2F FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.multiplication1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of 2 * 2.2F should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for 2 * 2.2F was retrieved", |
| getType(namedQuery, Float.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_45() throws Exception { |
| |
| // SELECT AVG(e.salary) * 2E2 FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.multiplication2"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of AVG(salary) * 2E2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for AVG(salary) * 2E2 was retrieved", |
| getType(namedQuery, Double.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_46() throws Exception { |
| |
| // SELECT e.salary * 2 FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.multiplication3"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of e.salary * 2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for e.salary * 2 was retrieved", |
| getType(namedQuery, Long.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_47() throws Exception { |
| |
| // SELECT e.name * 2 FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.multiplication4"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of e.name * 2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for e.name * 2 was retrieved", |
| getType(namedQuery, Object.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_48() throws Exception { |
| |
| // SELECT NEW java.lang.Vector(d.empList) FROM Dept d |
| IQuery namedQuery = namedQuery("Dept", "dept.new1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of NEW java.lang.Vector(d.empList) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for NEW java.lang.Vector(d.empList) was retrieved", |
| getType(namedQuery, Vector.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_49() throws Exception { |
| |
| // SELECT NULLIF(e.name, 'JPQL') FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.nullif1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of NULLIF(e.name, 'JPQL') should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for NULLIF(e.name, 'JPQL') was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_50() throws Exception { |
| |
| // SELECT NULLIF(2 + 2, 'JPQL') FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.nullif2"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of NULLIF(2 + 2, 'JPQL') should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for NULLIF(2 + 2, 'JPQL') was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_51() throws Exception { |
| |
| // SELECT Distinct Object(c) From Customer c, IN(c.home.phones) p where p.area LIKE :area |
| IQuery namedQuery = namedQuery("Customer", "customer.area"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of Object(c) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for Object(c) was retrieved", |
| getType(namedQuery, "jpql.query.Customer"), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_52() throws Exception { |
| |
| // select object(o) FROM Order o Where SQRT(o.totalPrice) > :doubleValue |
| IQuery namedQuery = namedQuery("Order", "order.doubleValue"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of object(o) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for object(o) was retrieved", |
| getType(namedQuery, "jpql.query.Order"), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_53() throws Exception { |
| |
| // Select Distinct Object(p) from Product p where (p.quantity > (500 + :int1)) AND (p.partNumber IS NULL)) |
| IQuery namedQuery = namedQuery("Product", "product.int1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of Object(p) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for Object(p) was retrieved", |
| getType(namedQuery, "jpql.query.Product"), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_54() throws Exception { |
| |
| // SELECT a.alias FROM Alias AS a WHERE (a.alias IS NULL AND :param1 IS NULL) OR a.alias = :param1 |
| IQuery namedQuery = namedQuery("Alias", "alias.param1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of a.alias should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for a.alias was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_55() throws Exception { |
| |
| // select c.firstName FROM Customer c Group By c.firstName HAVING c.firstName = concat(:fname, :lname) |
| IQuery namedQuery = namedQuery("Customer", "customer.name"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of c.firstName should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for c.firstName was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_56() throws Exception { |
| |
| // select Dept.floorNumber from Dept Dept |
| IQuery namedQuery = namedQuery("Dept", "dept.floorNumber"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of Dept.floorNumber should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for Dept.floorNumber was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_57() throws Exception { |
| |
| // SELECT c from Customer c where c.home.city IN :city |
| IQuery namedQuery = namedQuery("Customer", "customer.city"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of c should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for c was retrieved", |
| getType(namedQuery, "jpql.query.Customer"), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_58() throws Exception { |
| |
| // SELECT DISTINCT p From Product p where p.shelfLife.soldDate NOT BETWEEN :date1 AND :newdate |
| IQuery namedQuery = namedQuery("Product", "product.date"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of p should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for p was retrieved", |
| getType(namedQuery, "jpql.query.Product"), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_59() throws Exception { |
| |
| // SELECT e.name AS n From Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.resultVariable1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of e.name as n should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for e.name as n was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_60() throws Exception { |
| |
| // SELECT e.name n From Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.resultVariable2"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of e.name as n should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for e.name as n was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_61() throws Exception { |
| |
| // SELECT e.salary / 1000D n From Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.resultVariable3"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of e.salary / 1000D n as n should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for e.salary / 1000D n as n was retrieved", |
| getType(namedQuery, Double.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_62() throws Exception { |
| |
| // SELECT SIZE(c) FROM Address a JOIN a.customerList c |
| IQuery namedQuery = namedQuery("Address", "address.size"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of SIZE(c) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for SIZE(c) was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_63() throws Exception { |
| |
| // SELECT SQRT(o.totalPrice) FROM Order o |
| IQuery namedQuery = namedQuery("Order", "order.sqrt"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of SQRT(o.totalPrice) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for SQRT(o.totalPrice) was retrieved", |
| getType(namedQuery, Double.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_64() throws Exception { |
| |
| // SELECT 2 / 2.2F FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.substraction1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of 2 - 2.2F should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for 2 - 2.2F was retrieved", |
| getType(namedQuery, Float.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_65() throws Exception { |
| |
| // SELECT AVG(e.salary) - 2E2 FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.substraction2"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of AVG(salary) / 2E2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for AVG(salary) / 2E2 was retrieved", |
| getType(namedQuery, Double.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_66() throws Exception { |
| |
| // SELECT e.name - 2 FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.substraction3"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of e.name - 2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for e.name - 2 was retrieved", |
| getType(namedQuery, Long.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_67() throws Exception { |
| |
| // SELECT e.salary - 2 FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.substraction4"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of e.salary - 2 should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for e.salary - 2 was retrieved", |
| getType(namedQuery, Object.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_68() throws Exception { |
| |
| // SELECT SUBSTRING(a.state, 0, 1) FROM Address a |
| IQuery namedQuery = namedQuery("Address", "address.length"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of SUBSTRING(a.state, 0, 1) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for SUBSTRING(a.state, 0, 1) was retrieved", |
| getType(namedQuery, Integer.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_69() throws Exception { |
| |
| // SELECT SUM(e.salary) FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.sum"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of SUM(e.salary) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for SUM(p.quantity) was retrieved", |
| getType(namedQuery, Long.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_70() throws Exception { |
| |
| // SELECT SUM(o.totalPrice) FROM Order o |
| IQuery namedQuery = namedQuery("Order", "order.sum1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of SUM(o.totalPrice) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for SUM(o.totalPrice) was retrieved", |
| getType(namedQuery, Double.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_71() throws Exception { |
| |
| // SELECT SUM(o.totalPrice) FROM Order o |
| IQuery namedQuery = namedQuery("Order", "order.sum2"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of SUM(o.price) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for SUM(o.price) was retrieved", |
| getType(namedQuery, BigInteger.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_72() throws Exception { |
| |
| // SELECT SUM(o.realPrice) FROM Order o |
| IQuery namedQuery = namedQuery("Order", "order.sum3"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of SUM(o.realPrice) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for SUM(o.realPrice) was retrieved", |
| getType(namedQuery, BigDecimal.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_73() throws Exception { |
| |
| // SELECT TRIM(e.name) FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.trim"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of TRIM(e.name) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for TRIM(e.name) was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_74() throws Exception { |
| |
| // UPDATE Employee e SET e.manager = ?1 WHERE e.department = ?2 |
| IQuery namedQuery = namedQuery("Employee", "employee.update.positional"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The Object type should have been returned", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type was retrieved", |
| getType(namedQuery, Object.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_75() throws Exception { |
| |
| // SELECT UPPER(e.name) FROM Employee e |
| IQuery namedQuery = namedQuery("Employee", "employee.upper"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of UPPER(e.name) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for UPPER(e.name) was retrieved", |
| getType(namedQuery, String.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_76() throws Exception { |
| |
| // SELECT VALUE(v) FROM Alias a JOIN a.ids v |
| IQuery namedQuery = namedQuery("Alias", "alias.value1"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of VALUE(v) should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for VALUE(v) was retrieved", |
| getType(namedQuery, Date.class), |
| type |
| ); |
| } |
| |
| @Test |
| public final void test_ResultType_77() throws Exception { |
| |
| // SELECT v FROM Alias a JOIN a.ids v |
| IQuery namedQuery = namedQuery("Alias", "alias.value2"); |
| |
| AbstractJPQLQueryHelper helper = buildQueryHelper(namedQuery); |
| IType type = helper.getResultType(); |
| |
| assertNotNull( |
| "The type of v should have been found", |
| type |
| ); |
| |
| assertEquals( |
| "The wrong type for v was retrieved", |
| getType(namedQuery, Date.class), |
| type |
| ); |
| } |
| |
| protected ITypeRepository typeRepository(IQuery query) { |
| return query.getProvider().getTypeRepository(); |
| } |
| } |
