/******************************************************************************* | |
* Copyright (c) 2005, 2009 SAP. All rights reserved. | |
* This program and the accompanying materials are made available under the | |
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 | |
* which accompanies this distribution. | |
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html | |
* and the Eclipse Distribution License is available at | |
* http://www.eclipse.org/org/documents/edl-v10.php. | |
* | |
* Contributors: | |
* SAP - initial API and implementation | |
******************************************************************************/ | |
package org.eclipse.persistence.testing.tests.wdf.jpa1.query; | |
import static org.junit.Assert.assertTrue; | |
import java.math.BigDecimal; | |
import java.math.BigInteger; | |
import java.sql.SQLException; | |
import java.util.ArrayList; | |
import java.util.Calendar; | |
import java.util.Date; | |
import java.util.HashSet; | |
import java.util.Iterator; | |
import java.util.List; | |
import java.util.Random; | |
import java.util.Set; | |
import javax.persistence.EntityManager; | |
import javax.persistence.Query; | |
import javax.persistence.TemporalType; | |
import org.eclipse.persistence.testing.framework.wdf.JPAEnvironment; | |
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Car; | |
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Cubicle; | |
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.CubiclePrimaryKeyClass; | |
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Department; | |
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Department.KrassDep; | |
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Employee; | |
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Employee.KrassEmp; | |
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.MotorVehicle; | |
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.TransmissionType; | |
import org.eclipse.persistence.testing.models.wdf.jpa1.employee.Truck; | |
import org.eclipse.persistence.testing.models.wdf.jpa1.types.UserDefinedEnum; | |
import org.junit.Test; | |
public class TestArguments extends QueryTest { | |
private final Set<Department> ALL_DEPARTMENTS = new HashSet<Department>(); | |
private final Department dep10 = new Department(10, "ten"); | |
private final Department dep20 = new Department(20, "twenty"); | |
private void init() throws SQLException { | |
clearAllTables(); | |
ALL_DEPARTMENTS.add(dep10); | |
ALL_DEPARTMENTS.add(dep20); | |
JPAEnvironment env = getEnvironment(); | |
EntityManager em = env.getEntityManager(); | |
try { | |
env.beginTransaction(em); | |
Employee knut = new Employee(1, "Knut", "Maier", dep10); | |
Employee fred = new Employee(2, "Fred", "Schmidt", null); | |
Cubicle green = new Cubicle(Integer.valueOf(1), Integer.valueOf(2), "green", knut); | |
knut.setCubicle(green); | |
em.persist(dep10); | |
em.persist(dep20); | |
em.persist(green); | |
em.persist(knut); | |
em.persist(fred); | |
env.commitTransactionAndClear(em); | |
} finally { | |
closeEntityManager(em); | |
} | |
} | |
@Test | |
// @TestProperties(unsupportedDatabaseVendors = { DatabaseVendor.OPEN_SQL}) | |
public void testArgumentInArithmeticExpr() throws SQLException { | |
init(); | |
EntityManager em = getEnvironment().getEntityManager(); | |
try { | |
getEnvironment().beginTransaction(em); | |
Query updateQuery = em | |
.createQuery("UPDATE Employee e SET e.salary = e.salary*(1+(:percent/100)) WHERE EXISTS (SELECT p FROM e.projects p WHERE p.name LIKE :projectName)"); | |
updateQuery.setParameter("percent", new Integer(15)); | |
updateQuery.setParameter("projectName", "testing project"); | |
updateQuery.executeUpdate(); | |
getEnvironment().commitTransaction(em); | |
} catch (Exception ex) { | |
getEnvironment().rollbackTransaction(em); | |
throw new RuntimeException(ex); | |
} finally { | |
closeEntityManager(em); | |
} | |
} | |
@Test | |
public void testLongVarBinaryParameters() { | |
EntityManager em = getEnvironment().getEntityManager(); | |
try { | |
// the mapped query is not executable on DB hence it will only be created and the parameter is set to test type | |
// validation | |
Query q1 = em | |
.createQuery("SELECT bfa.primitiveByteArray2Blob FROM BasicTypesFieldAccess bfa WHERE bfa.wrapperByteArray2Longvarbinary IS NULL AND (?1) IS NULL AND (?2) IS NULL"); | |
q1.setParameter(1, new Byte[10]); | |
q1.setParameter(2, new byte[10]); | |
} finally { | |
closeEntityManager(em); | |
} | |
} | |
@Test | |
public void testSinglePk() throws SQLException { | |
init(); | |
EntityManager em = getEnvironment().getEntityManager(); | |
try { | |
Query query = em.createQuery("select e from Employee e where e.department = :dep"); | |
query.setParameter("dep", dep10); | |
List<?> result = query.getResultList(); | |
Iterator<?> iter = result.iterator(); | |
verify(iter.hasNext(), "no results"); | |
Object object = iter.next(); | |
verify(object instanceof Employee, "wrong instance: " + object.getClass().getName()); | |
Employee employee = (Employee) object; | |
verify(employee.getId() == 1, "wrong id: " + employee.getId()); | |
verify(!iter.hasNext(), "too many rows"); | |
} finally { | |
closeEntityManager(em); | |
} | |
} | |
@SuppressWarnings("boxing") | |
@Test | |
public void testCompoundPk() throws SQLException { | |
init(); | |
EntityManager em = getEnvironment().getEntityManager(); | |
try { | |
Cubicle cubicle = em.find(Cubicle.class, new CubiclePrimaryKeyClass(1, 2)); | |
Query query = em.createQuery("select e from Employee e where e.cubicle = :cub"); | |
query.setParameter("cub", cubicle); | |
List<?> result = query.getResultList(); | |
Iterator<?> iter = result.iterator(); | |
verify(iter.hasNext(), "no results"); | |
Object object = iter.next(); | |
verify(object instanceof Employee, "wrong instance: " + object.getClass().getName()); | |
Employee employee = (Employee) object; | |
verify(employee.getId() == 1, "wrong id: " + employee.getId()); | |
verify(!iter.hasNext(), "too many rows"); | |
} finally { | |
closeEntityManager(em); | |
} | |
} | |
@Test | |
public void testInvalidParameterHandling() { | |
assertInvalidQuery("SELECT e FROM Employee e WHERE e.id = ?"); | |
} | |
@Test | |
public void testSubclassParameter() { | |
EntityManager em = getEnvironment().getEntityManager(); | |
try { | |
Query q = em.createQuery("SELECT e FROM Employee e WHERE e.department=?1"); | |
q.setParameter(1, new KrassDep("foo")); | |
q.getResultList(); | |
} finally { | |
closeEntityManager(em); | |
} | |
} | |
@Test | |
public void testIllegalSubclassParameter() { | |
boolean errorCaught = false; | |
EntityManager em = getEnvironment().getEntityManager(); | |
try { | |
Query q = em.createQuery("SELECT e FROM Employee e WHERE e.department=?1"); | |
q.setParameter(1, new KrassEmp("foo")); | |
q.getResultList(); | |
} catch (IllegalArgumentException iaex) { | |
errorCaught = true; | |
} finally { | |
closeEntityManager(em); | |
} | |
assertTrue("Unable to detect illegal typed input parameter.", errorCaught); | |
} | |
@SuppressWarnings("boxing") | |
@Test | |
public void testEnumParameters() throws SQLException { | |
init(); | |
EntityManager em = getEnvironment().getEntityManager(); | |
try { | |
getEnvironment().beginTransaction(em); | |
MotorVehicle motorVehicle = new MotorVehicle(); | |
motorVehicle.setTransmissionType(TransmissionType.AUTOMATIC); | |
Truck truck = new Truck(); | |
truck.setTransmissionType(TransmissionType.STICK_SHIFT); | |
Car car = new Car(); | |
em.persist(motorVehicle); | |
em.persist(truck); | |
em.persist(car); | |
getEnvironment().commitTransactionAndClear(em); | |
short mvId = motorVehicle.getId(); | |
short truckId = truck.getId(); | |
Query query = em.createQuery("select m from MotorVehicle m where m.transmissionType = :tr"); | |
query.setParameter("tr", TransmissionType.AUTOMATIC); | |
List<?> result = query.getResultList(); | |
Iterator<?> iter = result.iterator(); | |
verify(iter.hasNext(), "no results"); | |
Object object = iter.next(); | |
verify(object instanceof MotorVehicle, "wrong instance: " + object.getClass().getName()); | |
MotorVehicle vehicle = (MotorVehicle) object; | |
verify(vehicle.getId() == mvId, "wrong id: " + vehicle.getId()); | |
verify(!iter.hasNext(), "too many rows"); | |
query.setParameter("tr", TransmissionType.STICK_SHIFT); | |
result = query.getResultList(); | |
iter = result.iterator(); | |
verify(iter.hasNext(), "no results"); | |
object = iter.next(); | |
verify(object instanceof MotorVehicle, "wrong instance: " + object.getClass().getName()); | |
vehicle = (MotorVehicle) object; | |
verify(vehicle.getId() == truckId, "wrong id: " + vehicle.getId()); | |
verify(!iter.hasNext(), "too many rows"); | |
} finally { | |
closeEntityManager(em); | |
} | |
} | |
protected void assertValidParameterForBasicTypesFieldAccess(final String fieldname, Object value) { | |
EntityManager em = getEnvironment().getEntityManager(); | |
// queries | |
List<Query> orderedParamQueries = new ArrayList<Query>(); | |
List<Query> namedParamQueries = new ArrayList<Query>(); | |
orderedParamQueries | |
.add(em.createQuery("SELECT btfa FROM BasicTypesFieldAccess btfa WHERE btfa." + fieldname + " = ?1")); | |
orderedParamQueries.add(em.createQuery("UPDATE BasicTypesFieldAccess btfa SET btfa." + fieldname | |
+ " = ?1 WHERE btfa.id=1")); | |
namedParamQueries.add(em.createQuery("SELECT btfa FROM BasicTypesFieldAccess btfa WHERE btfa." + fieldname | |
+ " = :param1")); | |
namedParamQueries.add(em.createQuery("UPDATE BasicTypesFieldAccess btfa SET btfa." + fieldname | |
+ " = :param1 WHERE btfa.id=1")); | |
for (Query q : orderedParamQueries) { | |
if (Calendar.class.isAssignableFrom(value.getClass())) { | |
q.setParameter(1, (Calendar) value, TemporalType.TIMESTAMP); | |
} else if (value.getClass().isAssignableFrom(Date.class)) { | |
q.setParameter(1, (Date) value, TemporalType.TIMESTAMP); | |
} else { | |
q.setParameter(1, value); | |
} | |
} | |
for (Query q : namedParamQueries) { | |
if (Calendar.class.isAssignableFrom(value.getClass())) { | |
q.setParameter("param1", (Calendar) value, TemporalType.TIMESTAMP); | |
} else if (value.getClass().isAssignableFrom(Date.class)) { | |
q.setParameter("param1", (Date) value, TemporalType.TIMESTAMP); | |
} else { | |
q.setParameter("param1", value); | |
} | |
} | |
} | |
// primitive types | |
@Test | |
public void testPrimitiveBoolean() { | |
assertValidParameterForBasicTypesFieldAccess("primitiveBoolean", true); | |
} | |
@Test | |
public void testPrimitiveByte() { | |
assertValidParameterForBasicTypesFieldAccess("primititveByte", new Byte((byte) 2)); | |
} | |
@Test | |
public void testPrimitiveChar() { | |
assertValidParameterForBasicTypesFieldAccess("primitiveChar", 'c'); | |
} | |
@Test | |
public void testPrimitiveShort() { | |
assertValidParameterForBasicTypesFieldAccess("primitiveShort", (short) 2); | |
} | |
@Test | |
public void testPrimitiveInt() { | |
assertValidParameterForBasicTypesFieldAccess("primitiveInt", 1); | |
} | |
@Test | |
public void testPrimitiveLong() { | |
assertValidParameterForBasicTypesFieldAccess("primitiveLong", 1L); | |
} | |
@Test | |
public void testPrimitiveFloat() { | |
assertValidParameterForBasicTypesFieldAccess("primitiveFloat", 0.2F); | |
} | |
@Test | |
public void testPrimitiveDouble() { | |
assertValidParameterForBasicTypesFieldAccess("primitiveDouble", 0.1234); | |
} | |
// wrappers of primitive types | |
@Test | |
public void testWrapperBoolean() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperBoolean", new Boolean(true)); | |
} | |
@Test | |
public void testWrapperByte() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperByte", new Byte((byte) 2)); | |
} | |
@Test | |
public void testWrapperCharacter() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperCharacter", new Character('c')); | |
} | |
@Test | |
public void testWrapperShort() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperShort", new Short((short) 1)); | |
} | |
@Test | |
public void testWrapperInteger() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperInteger", new Integer(1)); | |
} | |
@Test | |
public void testWrapperLong() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperLong", new Long(1L)); | |
} | |
@Test | |
public void testWrapperDouble() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperDouble", new Double(0.00)); | |
} | |
@Test | |
public void testWrapperFloat() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperFloat", new Float(1F)); | |
} | |
// immutable reference types | |
@Test | |
public void testString2Varchar() { | |
assertValidParameterForBasicTypesFieldAccess("string2Varchar", "foo"); | |
} | |
@Test | |
public void testString2Clob() { | |
assertValidParameterForBasicTypesFieldAccess("string2Clob", "bar"); | |
} | |
@Test | |
public void testBigDecimal() { | |
assertValidParameterForBasicTypesFieldAccess("bigDecimal", new BigDecimal(1)); | |
} | |
@Test | |
public void testBigInteger() { | |
assertValidParameterForBasicTypesFieldAccess("bigInteger", new BigInteger(1, new Random(10L))); | |
} | |
// mutable types | |
@Test | |
public void testUtilDate() { | |
assertValidParameterForBasicTypesFieldAccess("utilDate", new Date(System.currentTimeMillis())); | |
} | |
@Test | |
public void testUtilCalendar() { | |
assertValidParameterForBasicTypesFieldAccess("utilCalendar", Calendar.getInstance()); | |
} | |
@Test | |
public void testSqlDate() { | |
assertValidParameterForBasicTypesFieldAccess("sqlDate", new java.sql.Date(System.currentTimeMillis())); | |
} | |
@Test | |
public void testSqlTime() { | |
assertValidParameterForBasicTypesFieldAccess("sqlTime", new java.sql.Time(System.currentTimeMillis())); | |
} | |
@Test | |
public void testSqlTimestamp() { | |
assertValidParameterForBasicTypesFieldAccess("sqlTimestamp", new java.sql.Timestamp(System.currentTimeMillis())); | |
} | |
// arrays | |
@Test | |
public void testPrimitiveByteArray2Binary() { | |
assertValidParameterForBasicTypesFieldAccess("primitiveByteArray2Binary", new byte[] { (byte) 1, (byte) 1 }); | |
} | |
@Test | |
public void testPrimitiveByteArray2Longvarbinary() { | |
assertValidParameterForBasicTypesFieldAccess("primitiveByteArray2Longvarbinary", new byte[] { (byte) 1, (byte) 1 }); | |
} | |
@Test | |
public void testPrimitiveByteArray2Blob() { | |
assertValidParameterForBasicTypesFieldAccess("primitiveByteArray2Blob", new byte[] { (byte) 1, (byte) 1 }); | |
} | |
@Test | |
public void testPrimitiveCharArray2Varchar() { | |
assertValidParameterForBasicTypesFieldAccess("primitiveCharArray2Varchar", new char[] { 'c', 'b' }); | |
} | |
@Test | |
public void testPrimitiveCharArray2Clob() { | |
assertValidParameterForBasicTypesFieldAccess("primitiveCharArray2Clob", new char[] { 'c', 'b' }); | |
} | |
@Test | |
public void testWrapperByteArray2Binary() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperByteArray2Binary", new Byte[] { 'c', 'b' }); | |
} | |
@Test | |
public void testWrapperByteArray2Longvarbinary() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperByteArray2Longvarbinary", new Byte[] { 'c', 'b' }); | |
} | |
@Test | |
public void testWrapperByteArray2Blob() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperByteArray2Blob", new Byte[] { 'c', 'b' }); | |
} | |
@Test | |
public void testWrapperCharArray2Varchar() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperCharacterArray2Varchar", new Character[] { 'c', 'b' }); | |
} | |
@SuppressWarnings("boxing") | |
@Test | |
public void testWrapperCharArray2Clob() { | |
assertValidParameterForBasicTypesFieldAccess("wrapperCharacterArray2Clob", new Character[] { 'c', 'b' }); | |
} | |
@Test | |
public void testEnumString() { | |
assertValidParameterForBasicTypesFieldAccess("enumString", UserDefinedEnum.EMIL); | |
} | |
@Test | |
public void testEnumOrdinal() { | |
assertValidParameterForBasicTypesFieldAccess("enumOrdinal", UserDefinedEnum.HUGO); | |
} | |
} |