You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openjpa.apache.org by pp...@apache.org on 2009/06/10 02:41:38 UTC
svn commit: r783166 [2/3] - in /openjpa/trunk:
openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/kernel/exps/
openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/schema/
openjpa-kernel/src/main/java/org/apache/openjpa/kernel/exps/
openjpa-kernel/src/ma...
Modified: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestCriteria.java
URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestCriteria.java?rev=783166&r1=783165&r2=783166&view=diff
==============================================================================
--- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestCriteria.java (original)
+++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestCriteria.java Wed Jun 10 00:41:35 2009
@@ -56,28 +56,43 @@
public void setUp() {
super.setUp(CLEAR_TABLES,
- Account.class,
- Address.class,
- CompUser.class,
- Contact.class,
- Contractor.class,
- Course.class,
- CreditCard.class,
- Customer.class,
- Department.class,
- Employee.class,
- Exempt.class,
- FrequentFlierPlan.class,
- Item.class,
- LineItem.class,
- Manager.class,
- Person.class,
- Order.class,
- Phone.class,
- Photo.class,
- Student.class,
- Transaction.class,
- VideoStore.class);
+ "openjpa.DynamicEnhancementAgent", "false",
+ Account.class,
+ Address.class,
+ A.class,
+ B.class,
+ CompUser.class,
+ Contact.class,
+ Contractor.class,
+ Course.class,
+ CreditCard.class,
+ Customer.class,
+ C.class,
+ Department.class,
+ DependentId.class,
+ Dependent.class,
+ D.class,
+ Employee.class,
+ Exempt.class,
+ FemaleUser.class,
+ FrequentFlierPlan.class,
+ Item.class,
+ LineItem.class,
+ Magazine.class,
+ MaleUser.class,
+ Manager.class,
+ Movie.class,
+ Order.class,
+ Person.class,
+ Phone.class,
+ Photo.class,
+ Product.class,
+ Publisher.class,
+ Semester.class,
+ Student.class,
+ TransactionHistory.class,
+ Transaction.class,
+ VideoStore.class);
qb = (QueryBuilderImpl)emf.getDynamicQueryBuilder();
emf.createEntityManager();
}
Added: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestJoinCondition.java
URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestJoinCondition.java?rev=783166&view=auto
==============================================================================
--- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestJoinCondition.java (added)
+++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestJoinCondition.java Wed Jun 10 00:41:35 2009
@@ -0,0 +1,146 @@
+package org.apache.openjpa.persistence.criteria;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+import javax.persistence.criteria.CollectionJoin;
+import javax.persistence.criteria.CriteriaQuery;
+import javax.persistence.criteria.Join;
+import javax.persistence.criteria.JoinType;
+import javax.persistence.criteria.ListJoin;
+import javax.persistence.criteria.Root;
+import javax.persistence.criteria.SetJoin;
+
+import org.apache.openjpa.persistence.test.AllowFailure;
+
+/**
+ * Tests Criteria Queries that use Join.
+ *
+ * @author Pinaki Poddar
+ *
+ */
+public class TestJoinCondition extends CriteriaTest {
+
+ public void testSingleAttributeJoinModel() {
+ CriteriaQuery cq = cb.create();
+ Root<A> a = cq.from(A.class);
+ Join<A,B> b = a.join(A_.b);
+ assertSame(B.class, b.getJavaType());
+ assertSame(B.class, b.getMember().getMemberJavaType());
+ }
+
+ public void testCollectionJoinModel() {
+ CriteriaQuery cq = cb.create();
+ Root<C> c = cq.from(C.class);
+ CollectionJoin<C,D> d = c.join(C_.coll);
+ assertSame(Collection.class, d.getJavaType());
+ assertSame(D.class, d.getMember().getMemberJavaType());
+ }
+
+ public void testSetJoinModel() {
+ CriteriaQuery cq = cb.create();
+ Root<C> c = cq.from(C.class);
+ SetJoin<C,D> d = c.join(C_.set);
+ assertSame(Set.class, d.getJavaType());
+ assertSame(D.class, d.getMember().getMemberJavaType());
+ }
+
+ public void testListJoinModel() {
+ CriteriaQuery cq = cb.create();
+ Root<C> c = cq.from(C.class);
+ ListJoin<C,D> d = c.join(C_.list);
+ assertSame(List.class, d.getJavaType());
+ assertSame(D.class, d.getMember().getMemberJavaType());
+ }
+
+ public void testInnerJoinSingleAttributeWithoutCondition() {
+ String jpql = "select a from A a INNER JOIN a.b b";
+ CriteriaQuery c = cb.create();
+ c.from(A.class).join(A_.b, JoinType.INNER);
+
+ assertEquivalence(c, jpql);
+ }
+
+ public void testCrossJoinWithoutCondition() {
+ String jpql = "select a from A a, C c";
+ CriteriaQuery cq = cb.create();
+ Root<A> a = cq.from(A.class);
+ Root<C> c = cq.from(C.class);
+
+ assertEquivalence(cq, jpql);
+ }
+
+ @AllowFailure(message="Missing where clause")
+ public void testCrossJoin() {
+ String jpql = "select a from A a, C c where a.name=c.name";
+ CriteriaQuery cq = cb.create();
+ Root<A> a = cq.from(A.class);
+ Root<C> c = cq.from(C.class);
+ cq.where(cb.equal(a.get(A_.name), c.get(C_.name)));
+
+ assertEquivalence(cq, jpql);
+ }
+
+ public void testInnerJoinSingleAttribute() {
+ String jpql = "select a from A a INNER JOIN a.b b WHERE a.id=b.age";
+ CriteriaQuery cq = cb.create();
+ Root<A> a = cq.from(A.class);
+ Join<A,B> b = a.join(A_.b);
+ cq.where(cb.equal(a.get(A_.id), b.get(B_.age)));
+
+ assertEquivalence(cq, jpql);
+ }
+
+ public void testOuterJoinSingleAttributeWithoutCondition() {
+ String jpql = "select a from A a LEFT JOIN a.b b";
+ CriteriaQuery cq = cb.create();
+ Root<A> a = cq.from(A.class);
+ Join<A,B> b = a.join(A_.b, JoinType.LEFT);
+
+ assertEquivalence(cq, jpql);
+ }
+
+ public void testOuterJoinSingleAttribute() {
+ String jpql = "select a from A a LEFT JOIN a.b b where a.id=b.age";
+ CriteriaQuery cq = cb.create();
+ Root<A> a = cq.from(A.class);
+ Join<A,B> b = a.join(A_.b, JoinType.LEFT);
+ cq.where(cb.equal(a.get(A_.id), b.get(B_.age)));
+
+ assertEquivalence(cq, jpql);
+ }
+
+ public void testSetJoinWithoutCondition() {
+ String jpql = "select c from C c JOIN c.set d";
+ CriteriaQuery c = cb.create();
+ c.from(C.class).join(C_.set);
+
+ assertEquivalence(c, jpql);
+ }
+
+ public void testListJoinWithoutCondition() {
+ String jpql = "select c from C c JOIN c.list d";
+ CriteriaQuery c = cb.create();
+ c.from(C.class).join(C_.list);
+
+ assertEquivalence(c, jpql);
+ }
+
+ public void testCollectionJoinWithoutCondition() {
+ String jpql = "select c from C c JOIN c.coll d";
+ CriteriaQuery c = cb.create();
+ c.from(C.class).join(C_.coll);
+
+ assertEquivalence(c, jpql);
+ }
+
+ public void testMapJoinWithoutCondition() {
+ String jpql = "select c from C c JOIN c.map d";
+ CriteriaQuery c = cb.create();
+ c.from(C.class).join(C_.map);
+
+ assertEquivalence(c, jpql);
+ }
+
+}
Propchange: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestJoinCondition.java
------------------------------------------------------------------------------
svn:eol-style = native
Modified: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestMetaModelTypesafeCriteria.java
URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestMetaModelTypesafeCriteria.java?rev=783166&r1=783165&r2=783166&view=diff
==============================================================================
--- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestMetaModelTypesafeCriteria.java (original)
+++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestMetaModelTypesafeCriteria.java Wed Jun 10 00:41:35 2009
@@ -17,10 +17,10 @@
* under the License.
*/
package org.apache.openjpa.persistence.criteria;
+
import java.math.BigDecimal;
import java.util.List;
-import javax.persistence.EntityManager;
import javax.persistence.Parameter;
import javax.persistence.Query;
import javax.persistence.criteria.CriteriaQuery;
@@ -34,390 +34,364 @@
import javax.persistence.metamodel.Entity;
import javax.persistence.metamodel.Metamodel;
-import org.apache.openjpa.jdbc.conf.JDBCConfiguration;
-import org.apache.openjpa.jdbc.sql.DBDictionary;
import org.apache.openjpa.persistence.test.AllowFailure;
public class TestMetaModelTypesafeCriteria extends CriteriaTest {
- protected Entity<Account> account_ = null;
- protected Embeddable<Address> address_ = null;
- protected Embeddable<Contact> contact_ = null;
- protected Entity<Course> course_ = null;
- protected Entity<CreditCard> creditCard_ = null;
- protected Entity<Customer> customer_ = null;
- protected Entity<Department> department_ = null;
- protected Entity<Employee> employee_ = null;
- protected Entity<Exempt> exempt_ = null;
- protected Entity<Item> item_ = null;
- protected Entity<LineItem> lineItem_ = null;
- protected Entity<Manager> manager_ = null;
- protected Entity<Movie> movie_ = null;
+ protected Entity<Account> account_ = null;
+ protected Embeddable<Address> address_ = null;
+ protected Embeddable<Contact> contact_ = null;
+ protected Entity<Course> course_ = null;
+ protected Entity<CreditCard> creditCard_ = null;
+ protected Entity<Customer> customer_ = null;
+ protected Entity<Department> department_ = null;
+ protected Entity<Employee> employee_ = null;
+ protected Entity<Exempt> exempt_ = null;
+ protected Entity<Item> item_ = null;
+ protected Entity<LineItem> lineItem_ = null;
+ protected Entity<Manager> manager_ = null;
+ protected Entity<Movie> movie_ = null;
protected Entity<Order> order_ = null;
protected Entity<Person> person_ = null;
protected Entity<Phone> phone_ = null;
protected Entity<Photo> photo_ = null;
- protected Entity<Product> product_ = null;
- protected Entity<Semester> semester_ = null;
- protected Entity<Student> student_ = null;
- protected Entity<TransactionHistory> transactionHistory_ = null;
- protected Entity<VideoStore> videoStore_ = null;
- CriteriaBuilder cb;
- EntityManager em;
-
-
+ protected Entity<Product> product_ = null;
+ protected Entity<Semester> semester_ = null;
+ protected Entity<Student> student_ = null;
+ protected Entity<TransactionHistory> transactionHistory_ = null;
+ protected Entity<VideoStore> videoStore_ = null;
+
public void setUp() {
- super.setUp((Object[])null); // super will initialize domain
-
- setDictionary();
-
- cb = (CriteriaBuilder)emf.getQueryBuilder();
- em = emf.createEntityManager();
- Metamodel mm = em.getMetamodel();
- account_ = mm.entity(Account.class);
- address_ = mm.embeddable(Address.class);
- contact_ = mm.embeddable(Contact.class);
- course_ = mm.entity(Course.class);
- creditCard_ = mm.entity(CreditCard.class);
- customer_ = mm.entity(Customer.class);
- department_ = mm.entity(Department.class);
- employee_ = mm.entity(Employee.class);
- exempt_ = mm.entity(Exempt.class);
- item_ = mm.entity(Item.class);
- lineItem_ = mm.entity(LineItem.class);
- manager_ = mm.entity(Manager.class);
- movie_ = mm.entity(Movie.class);
- order_ = mm.entity(Order.class);
- person_ = mm.entity(Person.class);
- phone_ = mm.entity(Phone.class);
- photo_ = mm.entity(Photo.class);
- product_ = mm.entity(Product.class);
- semester_ = mm.entity(Semester.class);
- student_ = mm.entity(Student.class);
- transactionHistory_ = mm.entity(TransactionHistory.class);
- videoStore_ = mm.entity(VideoStore.class);
-
- }
-
- void setDictionary() {
- JDBCConfiguration conf = (JDBCConfiguration)emf.getConfiguration();
- DBDictionary dict = conf.getDBDictionaryInstance();
- dict.requiresCastForComparisons = false;
- dict.requiresCastForMathFunctions = false;
- }
-
- public void createObj() {
+ super.setUp();
+
+ Metamodel mm = em.getMetamodel();
+ account_ = mm.entity(Account.class);
+ address_ = mm.embeddable(Address.class);
+ contact_ = mm.embeddable(Contact.class);
+ course_ = mm.entity(Course.class);
+ creditCard_ = mm.entity(CreditCard.class);
+ customer_ = mm.entity(Customer.class);
+ department_ = mm.entity(Department.class);
+ employee_ = mm.entity(Employee.class);
+ exempt_ = mm.entity(Exempt.class);
+ item_ = mm.entity(Item.class);
+ lineItem_ = mm.entity(LineItem.class);
+ manager_ = mm.entity(Manager.class);
+ movie_ = mm.entity(Movie.class);
+ order_ = mm.entity(Order.class);
+ person_ = mm.entity(Person.class);
+ phone_ = mm.entity(Phone.class);
+ photo_ = mm.entity(Photo.class);
+ product_ = mm.entity(Product.class);
+ semester_ = mm.entity(Semester.class);
+ student_ = mm.entity(Student.class);
+ transactionHistory_ = mm.entity(TransactionHistory.class);
+ videoStore_ = mm.entity(VideoStore.class);
}
-
- @AllowFailure
+
public void testCriteria() {
- String jpql = "select c from Customer c where c.name='Autowest Toyota'";
+ String jpql = "select c from Customer c "
+ + "where c.name='Autowest Toyota'";
CriteriaQuery q = cb.create();
Root<Customer> customer = q.from(Customer.class);
- q = cb.create();
- q.select(customer).where(cb.equal(
- customer.get(customer_.getAttribute("name", String.class)),
- "Autowest Toyota"));
-
+ q.select(customer).where(
+ cb.equal(customer.get(customer_.getAttribute("name",
+ String.class)), "Autowest Toyota"));
+
assertEquivalence(q, jpql);
}
-
+
@AllowFailure
public void testJoins() {
- String jpql = "SELECT c.name FROM Customer c JOIN c.orders o " +
- "JOIN o.lineItems i WHERE i.product.productType = 'printer'";
+ String jpql = "SELECT c.name FROM Customer c JOIN c.orders o "
+ + "JOIN o.lineItems i WHERE i.product.productType = 'printer'";
CriteriaQuery q = cb.create();
Root<Customer> cust = q.from(Customer.class);
- Join<Customer, Order> order = cust.join(customer_.getSet("orders",
- Order.class));
- Join<Order, LineItem> item = order.join(order_.getList("lineItems",
- LineItem.class));
- q.select(cust.get(Customer_.name))
- .where(cb.equal(
- item.get(lineItem_.getAttribute("product", Product.class)).
- get(product_.getAttribute("productType", String.class)),
- "printer"));
-
+ Join<Customer, Order> order = cust.join(customer_.getSet("orders",
+ Order.class));
+ Join<Order, LineItem> item = order.join(order_.getList("lineItems",
+ LineItem.class));
+ q.select(cust.get(Customer_.name)).where(
+ cb.equal(item.get(
+ lineItem_.getAttribute("product", Product.class)).get(
+ product_.getAttribute("productType", String.class)),
+ "printer"));
+
assertEquivalence(q, jpql);
-
- jpql = "SELECT c FROM Customer c LEFT JOIN c.orders o WHERE " +
- "c.status = 1";
+
+ jpql = "SELECT c FROM Customer c LEFT JOIN c.orders o WHERE "
+ + "c.status = 1";
q = cb.create();
Root<Customer> cust1 = q.from(Customer.class);
- Join<Customer, Order> order1 = cust1.join(customer_.getSet("orders",
- Order.class), JoinType.LEFT);
- q.where(cb.equal(cust1.get(customer_.getAttribute("status",
- Integer.class)), 1)).select(cust1);
-
+ Join<Customer, Order> order1 = cust1.join(customer_.getSet("orders",
+ Order.class), JoinType.LEFT);
+ q.where(
+ cb.equal(cust1.get(customer_.getAttribute("status",
+ Integer.class)), 1)).select(cust1);
+
assertEquivalence(q, jpql);
}
-
+
@AllowFailure
public void testFetchJoins() {
- String jpql =
- "SELECT d FROM Department LEFT JOIN FETCH d.employees "
+ String jpql = "SELECT d FROM Department LEFT JOIN FETCH d.employees "
+ "WHERE d.deptNo = 1";
CriteriaQuery q = cb.create();
Root<Department> d = q.from(Department.class);
d.fetch(department_.getSet("employees", Employee.class), JoinType.LEFT);
- q.where(cb.equal(d.get(department_.getAttribute("deptNo",
- Integer.class)), 1)).select(d);
-
+ q.where(
+ cb.equal(d.get(department_
+ .getAttribute("deptNo", Integer.class)), 1)).select(d);
+
assertEquivalence(q, jpql);
}
-
+
@AllowFailure
public void testPathNavigation() {
- String jpql = "SELECT p.vendor FROM Employee e " +
- "JOIN e.contactInfo.phones p WHERE e.contactInfo.address.zipCode ="
- + " '95054'";
+ String jpql = "SELECT p.vendor FROM Employee e "
+ + "JOIN e.contactInfo.phones p "
+ + "WHERE e.contactInfo.address.zipCode = '95054'";
CriteriaQuery q = cb.create();
Root<Employee> emp = q.from(Employee.class);
Join<Contact, Phone> phone = emp.join(
- employee_.getAttribute("contactInfo", Contact.class)).
- join(contact_.getList("phones", Phone.class));
+ employee_.getAttribute("contactInfo", Contact.class)).join(
+ contact_.getList("phones", Phone.class));
q.where(cb.equal(emp.get(
- employee_.getAttribute("contactInfo", Contact.class)).get(
- contact_.getAttribute("address", Address.class)).get(
- address_.getAttribute("zipCode", String.class)), "95054"));
+ employee_.getAttribute("contactInfo", Contact.class)).get(
+ contact_.getAttribute("address", Address.class)).get(
+ address_.getAttribute("zipCode", String.class)), "95054"));
q.select(phone.get(phone_.getAttribute("vendor", String.class)));
-
+
assertEquivalence(q, jpql);
-
- jpql = "SELECT i.name, p FROM Item i JOIN i.photos p WHERE KEY(p) " +
- "LIKE '%egret%'";
-
+
+ jpql = "SELECT i.name, p FROM Item i JOIN i.photos p WHERE KEY(p) "
+ + "LIKE '%egret%'";
+
q = cb.create();
Root<Item> item = q.from(Item.class);
- MapJoin<Item, String, Photo> photo = item.join(item_.getMap("photos",
- String.class, Photo.class));
- q.select(item.get(item_.getAttribute("name", String.class)), photo).
- where(cb.like(photo.key(), "%egret%"));
-
+ MapJoin<Item, String, Photo> photo = item.join(item_.getMap("photos",
+ String.class, Photo.class));
+ q.select(item.get(item_.getAttribute("name", String.class)), photo)
+ .where(cb.like(photo.key(), "%egret%"));
+
assertEquivalence(q, jpql);
}
-
+
@AllowFailure
public void testRestrictQueryResult() {
- String jpql = "SELECT t FROM CreditCard c JOIN c.transactionHistory t "
- + "WHERE c.customer.accountNum = 321987 AND INDEX(t) BETWEEN 0 "
- + "AND 9";
- CriteriaQuery q = cb.create();
- Root<CreditCard> c = q.from(CreditCard.class);
- ListJoin<CreditCard, TransactionHistory> t =
- c.join(creditCard_.getList("transactionHistory",
- TransactionHistory.class));
- q.select(t).where(cb.equal(
- c.get(creditCard_.getAttribute("customer", Customer.class)).
- get(customer_.getAttribute("accountNum", Long.class)), 321987),
- cb.between(t.index(), 0, 9));
-
- assertEquivalence(q, jpql);
+ String jpql = "SELECT t FROM CreditCard c JOIN c.transactionHistory t "
+ + "WHERE c.customer.accountNum = 321987 AND INDEX(t) BETWEEN 0 "
+ + "AND 9";
+
+ CriteriaQuery cq = cb.create();
+ Root<CreditCard> c = cq.from(CreditCard.class);
+ ListJoin<CreditCard, TransactionHistory> t = c.join(creditCard_
+ .getList("transactionHistory", TransactionHistory.class));
+ cq.select(t).where(
+ cb.equal(c.get(
+ creditCard_.getAttribute("customer", Customer.class))
+ .get(customer_.getAttribute("accountNum", Long.class)),
+ 321987), cb.between(t.index(), 0, 9));
-/*
-
- jpql = "SELECT o FROM Order o WHERE o.lineItems IS EMPTY";
- q = cb.create();
- Root<Order> order = q.from(Order.class);
- Join<Order,LineItem> lineItems = order.join(order_.getList("lineItems",
- LineItem.class));
- q.where(cb.isEmpty(lineItems));
- q.select(order);
-
- assertEquivalence(q, jpql);
-*/
+ assertEquivalence(cq, jpql);
+
+ /*
+ *
+ * jpql = "SELECT o FROM Order o WHERE o.lineItems IS EMPTY"; q =
+ * cb.create(); Root<Order> order = q.from(Order.class);
+ * Join<Order,LineItem> lineItems =
+ * order.join(order_.getList("lineItems", LineItem.class));
+ * q.where(cb.isEmpty(lineItems)); q.select(order);
+ *
+ * assertEquivalence(q, jpql);
+ */
}
@AllowFailure
public void testExpressions() {
- String jpql = "SELECT o.quantity, o.totalCost*1.08 AS taxedCost, "
- + "a.zipCode FROM Customer c JOIN c.orders o JOIN c.address a "
- + "WHERE a.state = 'CA' AND a.county = 'Santa Clara";
+ String jpql = "SELECT o.quantity, o.totalCost*1.08 AS taxedCost, "
+ + "a.zipCode FROM Customer c JOIN c.orders o JOIN c.address a "
+ + "WHERE a.state = 'CA' AND a.county = 'Santa Clara'";
CriteriaQuery q = cb.create();
Root<Customer> cust = q.from(Customer.class);
- Join<Customer, Order> order = cust.join(customer_.getSet("orders",
- Order.class));
+ Join<Customer, Order> order = cust.join(customer_.getSet("orders",
+ Order.class));
Join<Customer, Address> address = cust.join(customer_.getAttribute(
- "address", Address.class));
- q.where(cb.equal(address.get(address_.getAttribute("state",
- String.class)), "CA"),
- cb.equal(address.get(address_.getAttribute("county",
- String.class)), "Santa Clara"));
- q.select(order.get(order_.getAttribute("quantity", Integer.class)),
- cb.prod(order.get(order_.getAttribute("totalCost", Double.class)),
- 1.08),
- address.get(address_.getAttribute("zipCode", String.class)));
-
+ "address", Address.class));
+ q.where(cb.equal(address.get(address_.getAttribute("state",
+ String.class)), "CA"), cb.equal(address.get(address_
+ .getAttribute("county", String.class)), "Santa Clara"));
+ q.select(order.get(order_.getAttribute("quantity", Integer.class)),
+ cb.prod(order.get(order_
+ .getAttribute("totalCost", Double.class)), 1.08),
+ address.get(address_.getAttribute("zipCode", String.class)));
+
assertEquivalence(q, jpql);
-
+
jpql = "SELECT TYPE(e) FROM Employee e WHERE TYPE(e) <> Exempt";
q = cb.create();
Root<Employee> emp = q.from(Employee.class);
q.select(emp.type()).where(cb.notEqual(emp.type(), Exempt.class));
-
+
assertEquivalence(q, jpql);
-
- jpql = "SELECT w.name FROM Course c JOIN c.studentWaitList w " +
- "WHERE c.name = 'Calculus' AND INDEX(w) = 0";
+
+ jpql = "SELECT w.name FROM Course c JOIN c.studentWaitList w "
+ + "WHERE c.name = 'Calculus' AND INDEX(w) = 0";
q = cb.create();
Root<Course> course = q.from(Course.class);
ListJoin<Course, Student> w = course.join(course_.getList(
- "studentWaitList", Student.class));
- q.where(cb.equal(course.get(course_.getAttribute("name",
- String.class)), "Calculus"),
- cb.equal(w.index(), 0)).select(w.get(student_.getAttribute("name",
- String.class)));
-
+ "studentWaitList", Student.class));
+ q.where(
+ cb.equal(
+ course.get(course_.getAttribute("name", String.class)),
+ "Calculus"), cb.equal(w.index(), 0)).select(
+ w.get(student_.getAttribute("name", String.class)));
+
assertEquivalence(q, jpql);
-
- jpql = "SELECT SUM(i.price) FROM Order o JOIN o.lineItems i JOIN " +
- "o.customer c WHERE c.lastName = 'Smith' AND c.firstName = 'John'";
+
+ jpql = "SELECT SUM(i.price) "
+ + "FROM Order o JOIN o.lineItems i JOIN o.customer c "
+ + "WHERE c.lastName = 'Smith' AND c.firstName = 'John'";
q = cb.create();
Root<Order> o = q.from(Order.class);
- Join<Order, LineItem> i = o.join(order_.getList("lineItems",
- LineItem.class));
- Join<Order, Customer> c = o.join(order_.getAttribute("customer",
- Customer.class));
- q.where(cb.equal(c.get(customer_.getAttribute("lastName",
- String.class)), "Smith"),
- cb.equal(c.get(customer_.getAttribute("firstName",
- String.class)), "John"));
- q.select(cb.sum(i.get(lineItem_.getAttribute("price",
- Double.class))));
-
- assertEquivalence(q, jpql);
-/*
- jpql = "SELECT SIZE(d.employees) FROM Department d " +
- "WHERE d.name = 'Sales'";
- q = cb.create();
- Root<Department> d = q.from(Department.class);
- q.where(cb.equal(d.get(department_.getAttribute("name",
- String.class)), "Sales"));
- q.select(cb.size(d.get(department_.getSet("employees",
- Employee.class))));
-
+ Join<Order, LineItem> i = o.join(order_.getList("lineItems",
+ LineItem.class));
+ Join<Order, Customer> c = o.join(order_.getAttribute("customer",
+ Customer.class));
+ q.where(cb
+ .equal(c.get(customer_.getAttribute("lastName", String.class)),
+ "Smith"), cb.equal(c.get(customer_.getAttribute(
+ "firstName", String.class)), "John"));
+ q.select(cb.sum(i.get(lineItem_.getAttribute("price", Double.class))));
+
assertEquivalence(q, jpql);
-*/
- jpql = "SELECT e.name, CASE WHEN e.rating = 1 THEN e.salary * 1.1 " +
- "WHEN e.rating = 2 THEN e.salary * 1.2 ELSE e.salary * 1.01 END " +
- "FROM Employee e WHERE e.department.name = 'Engineering'";
+ /*
+ * jpql = "SELECT SIZE(d.employees) FROM Department d " +
+ * "WHERE d.name = 'Sales'"; q = cb.create(); Root<Department> d =
+ * q.from(Department.class);
+ * q.where(cb.equal(d.get(department_.getAttribute("name",
+ * String.class)), "Sales"));
+ * q.select(cb.size(d.get(department_.getSet("employees",
+ * Employee.class))));
+ *
+ * assertEquivalence(q, jpql);
+ */
+ jpql = "SELECT e.name, CASE WHEN e.rating = 1 THEN e.salary * 1.1 "
+ + "WHEN e.rating = 2 THEN e.salary * 1.2 ELSE e.salary * 1.01 END "
+ + "FROM Employee e WHERE e.department.name = 'Engineering'";
q = cb.create();
Root<Employee> e = q.from(Employee.class);
- q.where(cb.equal(e.get(employee_.getAttribute("department",
- Department.class)).
- get(department_.getAttribute("name", String.class)),
- "Engineering"));
- q.select(e.get(employee_.getAttribute("name", String.class)),
- cb.selectCase()
- .when(cb.equal(e.get(employee_.getAttribute("rating",
- Integer.class)), 1),
- cb.prod(e.get(employee_.getAttribute("salary",
- Long.class)), 1.1))
- .when(cb.equal(e.get(employee_.getAttribute("rating",
- Integer.class)), 2),
- cb.prod(e.get(employee_.getAttribute("salary",
- Long.class)), 1.2))
- .otherwise(cb.prod(e.get(employee_.getAttribute("salary",
- Long.class)), 1.01)));
-
- assertEquivalence(q, jpql);
- }
-/*
- @AllowFailure
- public void testLiterals() {
- String jpql = "SELECT p FROM Person p where 'Joe' MEMBER OF " +
- "p.nickNames";
- CriteriaQuery q = cb.create();
- Root<Person> p = q.from(Person.class);
- q.select(p).where(cb.isMember(cb.literal("Joe"), p.get(person_.
- getSet("nickNames", String.class))));
-
+ q
+ .where(cb.equal(e.get(
+ employee_.getAttribute("department", Department.class))
+ .get(department_.getAttribute("name", String.class)),
+ "Engineering"));
+ q.select(e.get(employee_.getAttribute("name", String.class)), cb
+ .selectCase().when(
+ cb.equal(e.get(employee_.getAttribute("rating",
+ Integer.class)), 1),
+ cb.prod(e.get(employee_.getAttribute("salary",
+ Long.class)), 1.1)).when(
+ cb.equal(e.get(employee_.getAttribute("rating",
+ Integer.class)), 2),
+ cb.prod(e.get(employee_.getAttribute("salary",
+ Long.class)), 1.2)).otherwise(
+ cb.prod(e.get(employee_.getAttribute("salary",
+ Long.class)), 1.01)));
+
assertEquivalence(q, jpql);
}
-*/
-
+
+ /*
+ * @AllowFailure public void testLiterals() { String jpql =
+ * "SELECT p FROM Person p where 'Joe' MEMBER OF " + "p.nickNames";
+ * CriteriaQuery q = cb.create(); Root<Person> p = q.from(Person.class);
+ * q.select(p).where(cb.isMember(cb.literal("Joe"), p.get(person_.
+ * getSet("nickNames", String.class))));
+ *
+ * assertEquivalence(q, jpql); }
+ */
+
@AllowFailure
public void testParameters() {
String jpql = "SELECT c FROM Customer c Where c.status = :stat";
CriteriaQuery q = cb.create();
Root<Customer> c = q.from(Customer.class);
Parameter<Integer> param = cb.parameter(Integer.class);
- q.select(c).where(cb.equal(c.get(customer_.getAttribute("status",
- Integer.class)), param));
-
- assertEquivalence(q, jpql, new String[]{"stat"}, new Object[] {1});
+ q.select(c).where(
+ cb.equal(
+ c.get(customer_.getAttribute("status", Integer.class)),
+ param));
+
+ assertEquivalence(q, jpql, new String[] { "stat" }, new Object[] { 1 });
}
-
+
@AllowFailure
public void testSelectList() {
- String jpql =
- "SELECT v.location.street, KEY(i).title, VALUE(i) FROM "
+ String jpql = "SELECT v.location.street, KEY(i).title, VALUE(i) FROM "
+ "VideoStore v JOIN v.videoInventory i "
+ "WHERE v.location.zipCode = " + "'94301' AND VALUE(i) > 0";
CriteriaQuery q = cb.create();
Root<VideoStore> v = q.from(VideoStore.class);
MapJoin<VideoStore, Movie, Integer> inv = v.join(videoStore_.getMap(
- "videoInventory", Movie.class, Integer.class));
- q.where(cb.equal(v.get(videoStore_.getAttribute("location",
- Address.class)).
- get(address_.getAttribute("zipCode", String.class)), "94301"),
- cb.gt(inv.value(), 0));
- q.select(v.get(videoStore_.getAttribute("location", Address.class)).
- get(address_.getAttribute("street", String.class)),
- inv.key().get(movie_.getAttribute("title", String.class)),
- inv.value());
-
+ "videoInventory", Movie.class, Integer.class));
+ q.where(cb.equal(v.get(
+ videoStore_.getAttribute("location", Address.class)).get(
+ address_.getAttribute("zipCode", String.class)), "94301"), cb
+ .gt(inv.value(), 0));
+ q.select(v.get(videoStore_.getAttribute("location", Address.class))
+ .get(address_.getAttribute("street", String.class)), inv.key()
+ .get(movie_.getAttribute("title", String.class)), inv.value());
+
assertEquivalence(q, jpql);
-
- jpql = "SELECT NEW CustomerDetails(c.id, c.status, o.quantity) FROM " +
- "Customer c JOIN c.orders o WHERE o.quantity > 100";
+
+ jpql = "SELECT NEW CustomerDetails(c.id, c.status, o.quantity) FROM "
+ + "Customer c JOIN c.orders o WHERE o.quantity > 100";
q = cb.create();
Root<Customer> c = q.from(Customer.class);
- Join<Customer, Order> o =
- c.join(customer_.getSet("orders", Order.class));
+ Join<Customer, Order> o = c.join(customer_
+ .getSet("orders", Order.class));
q.where(cb.gt(o.get(order_.getAttribute("quantity", Integer.class)),
- 100));
- q.select(cb.select(CustomerDetails.class,
- c.get(customer_.getAttribute("id", Integer.class)),
- c.get(customer_.getAttribute("status", Integer.class)),
- o.get(order_.getAttribute("quantity", Integer.class))));
-
+ 100));
+ q.select(cb.select(CustomerDetails.class, c.get(customer_.getAttribute(
+ "id", Integer.class)), c.get(customer_.getAttribute("status",
+ Integer.class)), o.get(order_.getAttribute("quantity",
+ Integer.class))));
+
assertEquivalence(q, jpql);
}
@AllowFailure
public void testSubqueries() {
- String jpql = "SELECT goodCustomer FROM Customer goodCustomer WHERE " +
- "goodCustomer.balanceOwed < (SELECT AVG(c.balanceOwed) FROM " +
- "Customer c)";
+ String jpql = "SELECT goodCustomer FROM Customer goodCustomer WHERE "
+ + "goodCustomer.balanceOwed < (SELECT AVG(c.balanceOwed) FROM "
+ + "Customer c)";
CriteriaQuery q = cb.create();
Root<Customer> goodCustomer = q.from(Customer.class);
Subquery<Double> sq = q.subquery(Double.class);
Root<Customer> c = sq.from(Customer.class);
- q.where(cb.lt(goodCustomer.get(customer_.getAttribute("balanceOwed",
- Integer.class)),
- sq.select(cb.avg(c.get(customer_.getAttribute("balanceOwed",
- Integer.class))))));
+ q.where(cb.lt(goodCustomer.get(customer_.getAttribute("balanceOwed",
+ Integer.class)), sq.select(cb.avg(c.get(customer_.getAttribute(
+ "balanceOwed", Integer.class))))));
q.select(goodCustomer);
-
+
assertEquivalence(q, jpql);
-
- jpql = "SELECT DISTINCT emp FROM Employee emp WHERE EXISTS (" +
- "SELECT spouseEmp FROM Employee spouseEmp WHERE spouseEmp = " +
- "emp.spouse)";
+
+ jpql = "SELECT DISTINCT emp FROM Employee emp WHERE EXISTS ("
+ + "SELECT spouseEmp FROM Employee spouseEmp WHERE spouseEmp = "
+ + "emp.spouse)";
q = cb.create();
Root<Employee> emp = q.from(Employee.class);
Subquery<Employee> sq1 = q.subquery(Employee.class);
Root<Employee> spouseEmp = sq1.from(Employee.class);
sq1.select(spouseEmp);
- sq1.where(cb.equal(spouseEmp, emp.get(employee_.getAttribute("spouse",
- Employee.class))));
+ sq1.where(cb.equal(spouseEmp, emp.get(employee_.getAttribute("spouse",
+ Employee.class))));
q.where(cb.exists(sq));
q.select(emp).distinct(true);
-
+
assertEquivalence(q, jpql);
-
- jpql =
- "SELECT emp FROM Employee emp WHERE emp.salary > ALL ("
+
+ jpql = "SELECT emp FROM Employee emp WHERE emp.salary > ALL ("
+ "SELECT m.salary FROM Manager m WHERE m.department ="
+ " emp.department)";
q = cb.create();
@@ -426,180 +400,137 @@
Subquery<BigDecimal> sq2 = q.subquery(BigDecimal.class);
Root<Manager> m = sq2.from(Manager.class);
sq2.select(m.get(manager_.getAttribute("salary", BigDecimal.class)));
- sq2.where(cb.equal(m.get(manager_.getAttribute("department",
- Department.class)),
- emp1.get(employee_.getAttribute("department",
- Department.class))));
- q.where(cb.gt(emp.get(employee_.getAttribute("salary", Long.class)),
- cb.all(sq)));
-
+ sq2.where(cb.equal(m.get(manager_.getAttribute("department",
+ Department.class)), emp1.get(employee_.getAttribute(
+ "department", Department.class))));
+ q.where(cb.gt(emp.get(employee_.getAttribute("salary", Long.class)), cb
+ .all(sq)));
+
assertEquivalence(q, jpql);
-
- jpql = "SELECT c FROM Customer c WHERE " +
- "(SELECT COUNT(o) FROM c.orders o) > 10";
+
+ jpql = "SELECT c FROM Customer c WHERE "
+ + "(SELECT COUNT(o) FROM c.orders o) > 10";
q = cb.create();
Root<Customer> c1 = q.from(Customer.class);
q.select(c1);
Subquery<Long> sq3 = q.subquery(Long.class);
- Root<Customer> c2 = sq3.correlate(c1);
- Join<Customer,Order> o = c2.join(customer_.getSet("orders",
- Order.class));
+ Root<Customer> c2 = sq3.correlate(c1);
+ Join<Customer, Order> o = c2.join(customer_.getSet("orders",
+ Order.class));
q.where(cb.gt(sq3.select(cb.count(o)), 10));
-
+
assertEquivalence(q, jpql);
-
- jpql = "SELECT o FROM Order o WHERE 10000 < ALL (" +
- "SELECT a.balance FROM o.customer c JOIN c.accounts a)";
+
+ jpql = "SELECT o FROM Order o WHERE 10000 < ALL ("
+ + "SELECT a.balance FROM o.customer c JOIN c.accounts a)";
q = cb.create();
Root<Order> o1 = q.from(Order.class);
q.select(o1);
Subquery<Integer> sq4 = q.subquery(Integer.class);
Root<Order> o2 = sq4.correlate(o1);
- Join<Order,Customer> c3 = o2.join(order_.getAttribute("customer",
- Customer.class));
- Join<Customer,Account> a = c3.join(customer_.getList("accounts",
- Account.class));
+ Join<Order, Customer> c3 = o2.join(order_.getAttribute("customer",
+ Customer.class));
+ Join<Customer, Account> a = c3.join(customer_.getList("accounts",
+ Account.class));
sq4.select(a.get(account_.getAttribute("balance", Integer.class)));
q.where(cb.lt(cb.literal(10000), cb.all(sq4)));
-
+
assertEquivalence(q, jpql);
- jpql = "SELECT o FROM Order o JOIN o.customer c WHERE 10000 < " +
- "ALL (SELECT a.balance FROM c.accounts a)";
+ jpql = "SELECT o FROM Order o JOIN o.customer c WHERE 10000 < "
+ + "ALL (SELECT a.balance FROM c.accounts a)";
q = cb.create();
Root<Order> o3 = q.from(Order.class);
q.select(o3);
- Join<Order,Customer> c4 = o3.join(Order_.customer);
+ Join<Order, Customer> c4 = o3.join(Order_.customer);
Subquery<Integer> sq5 = q.subquery(Integer.class);
- Join<Order,Customer> c5 = sq5.correlate(c4);
- Join<Customer,Account> a2 = c5.join(customer_.getList("accounts",
- Account.class));
+ Join<Order, Customer> c5 = sq5.correlate(c4);
+ Join<Customer, Account> a2 = c5.join(customer_.getList("accounts",
+ Account.class));
sq5.select(a.get(account_.getAttribute("balance", Integer.class)));
q.where(cb.lt(cb.literal(10000), cb.all(sq5)));
-
+
assertEquivalence(q, jpql);
}
-
+
@AllowFailure
public void testGroupByAndHaving() {
String jpql = "SELECT c.status, AVG(c.filledOrderCount), COUNT(c) FROM "
- + "Customer c GROUP BY c.status HAVING c.status IN (1, 2)";
+ + "Customer c GROUP BY c.status HAVING c.status IN (1, 2)";
CriteriaQuery q = cb.create();
Root<Customer> c = q.from(Customer.class);
q.groupBy(c.get(customer_.getAttribute("status", Integer.class)));
- q.having(cb.in(c.get(customer_.getAttribute("status", Integer.class))).
- value(1).value(2));
- q.select(c.get(customer_.getAttribute("status", Integer.class)),
- cb.avg(c.get(customer_.getAttribute("filledOrderCount",
- Integer.class))),
- cb.count(c));
-
+ q.having(cb.in(c.get(customer_.getAttribute("status", Integer.class)))
+ .value(1).value(2));
+ q.select(c.get(customer_.getAttribute("status", Integer.class)), cb
+ .avg(c.get(customer_.getAttribute("filledOrderCount",
+ Integer.class))), cb.count(c));
+
assertEquivalence(q, jpql);
}
-
+
@AllowFailure
public void testOrdering() {
- String jpql = "SELECT o FROM Customer c JOIN c.orders o "
- + "JOIN c.address a WHERE a.state = 'CA' ORDER BY o.quantity DESC, "
- + "o.totalCost";
+ String jpql = "SELECT o FROM Customer c JOIN c.orders o "
+ + "JOIN c.address a WHERE a.state = 'CA' "
+ + "ORDER BY o.quantity DESC, o.totalCost";
CriteriaQuery q = cb.create();
Root<Customer> c = q.from(Customer.class);
- Join<Customer,Order> o = c.join(customer_.getSet("orders",
- Order.class));
- Join<Customer,Address> a = c.join(customer_.getAttribute("address",
- Address.class));
- q.where(cb.equal(a.get(address_.getAttribute("state", String.class)),
- "CA"));
- q.orderBy(cb.desc(o.get(order_.getAttribute("quantity",
- Integer.class))),
- cb.asc(o.get(order_.getAttribute("totalCost", Double.class))));
+ Join<Customer, Order> o = c.join(customer_
+ .getSet("orders", Order.class));
+ Join<Customer, Address> a = c.join(customer_.getAttribute("address",
+ Address.class));
+ q.where(cb.equal(a.get(address_.getAttribute("state", String.class)),
+ "CA"));
+ q.orderBy(cb
+ .desc(o.get(order_.getAttribute("quantity", Integer.class))),
+ cb.asc(o.get(order_.getAttribute("totalCost", Double.class))));
q.select(o);
-
+
assertEquivalence(q, jpql);
-
- jpql = "SELECT o.quantity, a.zipCode FROM Customer c JOIN c.orders " +
- "JOIN c.address a WHERE a.state = 'CA' ORDER BY o.quantity, " +
- "a.zipCode";
- q = cb.create();
- Root<Customer> c1 = q.from(Customer.class);
- Join<Customer,Order> o1 = c1.join(customer_.getSet("orders",
- Order.class));
- Join<Customer,Address> a1 = c1.join(customer_.getAttribute("address",
- Address.class));
- q.where(cb.equal(a1.get(address_.getAttribute("state", String.class)),
- "CA"));
- q.orderBy(cb.asc(o1.get(order_.getAttribute("quantity",
- Integer.class))),
- cb.asc(a1.get(address_.getAttribute("zipCode",
- String.class))));
- q.select(o1.get(order_.getAttribute("quantity",
- Integer.class)),
- a1.get(address_.getAttribute("zipCode", String.class)));
-
+
+ jpql = "SELECT o.quantity, a.zipCode FROM Customer c JOIN c.orders "
+ + "JOIN c.address a WHERE a.state = 'CA' ORDER BY o.quantity, "
+ + "a.zipCode";
+ q = cb.create();
+ Root<Customer> c1 = q.from(Customer.class);
+ Join<Customer, Order> o1 = c1.join(customer_.getSet("orders",
+ Order.class));
+ Join<Customer, Address> a1 = c1.join(customer_.getAttribute("address",
+ Address.class));
+ q.where(cb.equal(a1.get(address_.getAttribute("state", String.class)),
+ "CA"));
+ q.orderBy(cb
+ .asc(o1.get(order_.getAttribute("quantity", Integer.class))),
+ cb.asc(a1.get(address_.getAttribute("zipCode", String.class))));
+ q.select(o1.get(order_.getAttribute("quantity", Integer.class)), a1
+ .get(address_.getAttribute("zipCode", String.class)));
+
assertEquivalence(q, jpql);
-
- jpql = "SELECT o.quantity, o.cost * 1.08 AS taxedCost, a.zipCode " +
- "FROM Customer c JOIN c.orders o JOIN c.address a " +
- "WHERE a.state = 'CA' AND a.county = 'Santa Clara' " +
- "ORDER BY o.quantity, taxedCost, a.zipCode";
+
+ jpql = "SELECT o.quantity, o.cost * 1.08 AS taxedCost, a.zipCode "
+ + "FROM Customer c JOIN c.orders o JOIN c.address a "
+ + "WHERE a.state = 'CA' AND a.county = 'Santa Clara' "
+ + "ORDER BY o.quantity, taxedCost, a.zipCode";
q = cb.create();
Root<Customer> c2 = q.from(Customer.class);
- Join<Customer,Order> o2 = c2.join(customer_.getSet("orders",
- Order.class));
- Join<Customer,Address> a2 = c2.join(customer_.getAttribute("address",
- Address.class));
- q.where(cb.equal(a.get(address_.getAttribute("state", String.class)),
- "CA"),
- cb.equal(a.get(address_.getAttribute("county", String.class)),
- "Santa Clara"));
- q.orderBy(cb.asc(o.get(order_.getAttribute("quantity",
- Integer.class))),
- cb.asc(cb.prod(o.get(order_.getAttribute("totalCost",
- Double.class)), 1.08)),
- cb.asc(a.get(address_.getAttribute("zipCode", String.class))));
- q.select(o.get(order_.getAttribute("quantity", Integer.class)),
- cb.prod(o.get(order_.getAttribute("totalCost", Double.class)),
- 1.08),
- a.get(address_.getAttribute("zipCode", String.class)));
-
- assertEquivalence(q, jpql);
- }
+ Join<Customer, Order> o2 = c2.join(customer_.getSet("orders",
+ Order.class));
+ Join<Customer, Address> a2 = c2.join(customer_.getAttribute("address",
+ Address.class));
+ q.where(cb.equal(a.get(address_.getAttribute("state", String.class)),
+ "CA"), cb.equal(a.get(address_.getAttribute("county",
+ String.class)), "Santa Clara"));
+ q.orderBy(
+ cb.asc(o.get(order_.getAttribute("quantity", Integer.class))),
+ cb.asc(cb.prod(o.get(order_.getAttribute("totalCost",
+ Double.class)), 1.08)), cb.asc(a.get(address_
+ .getAttribute("zipCode", String.class))));
+ q.select(o.get(order_.getAttribute("quantity", Integer.class)), cb
+ .prod(o.get(order_.getAttribute("totalCost", Double.class)),
+ 1.08), a.get(address_.getAttribute("zipCode",
+ String.class)));
- void assertEquivalence(CriteriaQuery c, String jpql) {
- sql.clear();
- List cList = em.createQuery(c).getResultList();
- assertEquals(1, sql.size());
- String cSQL = sql.get(0);
-
- sql.clear();
- List jList = em.createQuery(jpql).getResultList();
- assertEquals(1, sql.size());
- String jSQL = sql.get(0);
-
- assertEquals(jSQL, cSQL);
- }
-
- void assertEquivalence(CriteriaQuery c, String jpql, String[] paramNames,
- Object[] params) {
- sql.clear();
- Query q = em.createQuery(c);
- for (int i = 0; i < paramNames.length; i++) {
- q.setParameter(paramNames[i], params[i]);
- }
- List cList = q.getResultList();
- assertEquals(1, sql.size());
- String cSQL = sql.get(0);
-
- sql.clear();
- q = em.createQuery(jpql);
- for (int i = 0; i < paramNames.length; i++) {
- q.setParameter(paramNames[i], params[i]);
- }
- List jList = q.getResultList();
- assertEquals(1, sql.size());
- String jSQL = sql.get(0);
-
- assertEquals(jSQL, cSQL);
+ assertEquivalence(q, jpql);
}
-
}
Modified: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestTypeSafeCondExpression.java
URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestTypeSafeCondExpression.java?rev=783166&r1=783165&r2=783166&view=diff
==============================================================================
--- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestTypeSafeCondExpression.java (original)
+++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestTypeSafeCondExpression.java Wed Jun 10 00:41:35 2009
@@ -61,75 +61,27 @@
*/
public class TestTypeSafeCondExpression extends CriteriaTest {
-
- private int userid1, userid2, userid3, userid4, userid5;
- public void setUp() {
- // super setUp() initializes a fixed domain model
- super.setUp((Object[])null);
- createData();
- }
- void createData() {
- Address[] add =
- new Address[]{ new Address("43 Sansome", "SF", "USA", "94104"),
- new Address("24 Mink", "ANTIOCH", "USA", "94513"),
- new Address("23 Ogbete", "CoalCamp", "NIGERIA", "00000"),
- new Address("10 Wilshire", "Worcester", "CANADA", "80080"),
- new Address("23 Bellflower", "Ogui", "NIGERIA", "02000") };
-
- CompUser user1 = createUser("Seetha", "MAC", add[0], 40, true);
- CompUser user2 = createUser("Shannon", "PC", add[1], 36, false);
- CompUser user3 = createUser("Ugo", "PC", add[2], 19, true);
- CompUser user4 = createUser("Jacob", "LINUX", add[3], 10, true);
- CompUser user5 = createUser("Famzy", "UNIX", add[4], 29, false);
-
- startTx(em);
- em.persist(user1);
- userid1 = user1.getUserid();
- em.persist(user2);
- userid2 = user2.getUserid();
- em.persist(user3);
- userid3 = user3.getUserid();
- em.persist(user4);
- userid4 = user4.getUserid();
- em.persist(user5);
- userid5 = user5.getUserid();
-
- endTx(em);
- em.clear();
- }
-
public void testNothingUsingCriteria() {
String query = "SELECT o FROM CompUser o";
+
CriteriaQuery c = cb.create();
c.from(CompUser.class);
assertEquivalence(c, query);
- List result = em.createQuery(c).getResultList();
-
- assertNotNull("the list is null", result);
- assertEquals("the size of the list is not 5", 5, result.size());
-
- em.clear();
}
public void testBetweenExprUsingCriteria() {
String query =
"SELECT o.name FROM CompUser o WHERE o.age BETWEEN 19 AND 40 AND " +
"o.computerName = 'PC'";
- CriteriaQuery q = cb.create();
- Root<CompUser> c = q.from(CompUser.class);
- q.where(cb.and(cb.between(c.get(CompUser_.age), 19, 40),
- cb.equal(c.get(CompUser_.computerName), "PC")));
- q.select(c.get(CompUser_.name));
- assertEquivalence(q, query);
- List result = em.createQuery(q).getResultList();
-
- assertNotNull("the list is null", result);
- assertEquals("they are not equal", 2, result.size());
- assertTrue("result dont contain shannon", result.contains("Shannon"));
- assertTrue("result dont contain ugo", result.contains("Ugo"));
-
- em.clear();
+
+ CriteriaQuery cq = cb.create();
+ Root<CompUser> o = cq.from(CompUser.class);
+ cq.where(cb.and(cb.between(o.get(CompUser_.age), 19, 40),
+ cb.equal(o.get(CompUser_.computerName), "PC")));
+ cq.select(o.get(CompUser_.name));
+
+ assertEquivalence(cq, query);
}
public void testNotBetweenExprUsingCriteria() {
@@ -142,13 +94,8 @@
q.where(cb.and(cb.between(c.get(CompUser_.age), 19, 40).negate(),
cb.equal(c.get(CompUser_.computerName), "PC")));
q.select(c.get(CompUser_.name));
+
assertEquivalence(q, query);
- List result = em.createQuery(q).getResultList();
-
- assertNotNull("the list is null", result);
- assertEquals("they are not equal", 0, result.size());
-
- em.clear();
}
public void testInExprUsingCriteria() {
@@ -158,16 +105,8 @@
Root<CompUser> c = q.from(CompUser.class);
q.where(cb.in(c.get(CompUser_.age)).value(29).value(40).value(10));
q.select(c.get(CompUser_.name));
+
assertEquivalence(q, query);
- List result = em.createQuery(q).getResultList();
-
- assertNotNull("the list is null", result);
- assertEquals(3, result.size());
- assertTrue("seetha is not in the list", result.contains("Seetha"));
- assertTrue("jacob is not in the list", result.contains("Jacob"));
- assertTrue("famzy is not in the list", result.contains("Famzy"));
-
- em.clear();
}
public void testNotInUsingCriteria() {
@@ -179,22 +118,14 @@
q.where(cb.in(c.get(CompUser_.age)).value(29).value(40).value(10)
.negate());
q.select(c.get(CompUser_.name));
+
assertEquivalence(q, query);
- List result = em.createQuery(q).getResultList();
-
- assertNotNull(result);
- assertEquals(2, result.size());
- assertTrue(result.contains("Ugo"));
- assertTrue(result.contains("Shannon"));
-
- em.clear();
}
public void testLikeExprUsingCriteria1() {
String query =
"SELECT o.computerName FROM CompUser o WHERE o.name LIKE 'Sha%'" +
- " AND " +
- "o.computerName NOT IN ('PC')";
+ " AND o.computerName NOT IN ('PC')";
CriteriaQuery q = cb.create();
Root<CompUser> c = q.from(CompUser.class);
@@ -204,12 +135,8 @@
));
q.select(c.get(CompUser_.computerName));
- assertEquivalence(q, query);
- List result = em.createQuery(q).getResultList();
- assertNotNull(result);
- assertEquals(0, result.size());
- em.clear();
+ assertEquivalence(q, query);
}
public void testLikeExprUsingCriteria2() {
@@ -225,12 +152,8 @@
cb.in(c.get(CompUser_.computerName)).value("UNIX").negate()
));
q.select(c.get(CompUser_.computerName));
+
assertEquivalence(q, query);
- List result = em.createQuery(q).getResultList();
-
- assertNotNull(result);
- assertEquals(1, result.size());
- em.clear();
}
public void testLikeExprUsingCriteria3() {
@@ -240,12 +163,8 @@
Root<CompUser> c = q.from(CompUser.class);
q.where(cb.like(c.get(CompUser_.name),"_J%"));
q.select(c.get(CompUser_.name));
+
assertEquivalence(q, query);
- List result = em.createQuery(q).getResultList();
-
- assertNotNull(result);
- assertEquals(0, result.size());
- em.clear();
}
@AllowFailure(message="Parameter processing is broken")
@@ -257,13 +176,8 @@
Parameter<String> param = cb.parameter(String.class);
q.where(cb.like(c.get(CompUser_.name), param, '|'));
q.select(c.get(CompUser_.name));
+
assertEquivalence(q, query, new Object[] {"%|_%"});
- List result = em.createQuery(q).setParameter(1, "%|_%").getResultList();
-
- assertNotNull(result);
- assertEquals(0, result.size());
-
- em.clear();
}
public void testNullExprUsingCriteria() {
@@ -276,16 +190,8 @@
q.where(cb.and(cb.notEqual(c.get(CompUser_.age), null),
cb.equal(c.get(CompUser_.computerName), "PC")));
q.select(c.get(CompUser_.name));
+
assertEquivalence(q, query);
- List result = em.createQuery(q).getResultList();
-
- assertNotNull("the list is null", result);
- assertEquals("the list size is not 2", 2, result.size());
- assertTrue("the result doesnt contain ugo", result.contains("Ugo"));
- assertTrue("the result doesnt contain shannon",
- result.contains("Shannon"));
-
- em.clear();
}
public void testNullExpr2UsingCriteria() {
@@ -298,13 +204,8 @@
q.where(cb.equal(c.get(CompUser_.address).get(Address_.country),
null));
q.select(c.get(CompUser_.name));
+
assertEquivalence(q, query);
- List result = em.createQuery(q).getResultList();
-
- assertNotNull("the list is null", result);
- assertEquals("they are not equal", 0, result.size());
-
- em.clear();
}
// do not support isEmpty for array fields
@@ -313,20 +214,15 @@
String query =
"SELECT o.name FROM CompUser o WHERE o.nicknames IS NOT EMPTY";
- CriteriaQuery q = cb.create();
- Root<CompUser> c = q.from(CompUser.class);
- //q.where(cb.isNotEmpty(c.get(CompUser_.nicknames)));
- q.select(c);
- assertEquivalence(q, query);
- List result = em.createQuery(q).getResultList();
-
- assertNotNull("the list is null", result);
- assertEquals("they are not equal", 0, result.size());
-
- em.clear();
+ CriteriaQuery cq = cb.create();
+ Root<CompUser> o = cq.from(CompUser.class);
+ cq.select(o.get(CompUser_.name));
+ cq.where(cb.isNotEmpty(o.get(CompUser_.nicknames)));
+ assertEquivalence(cq, query);
}
- @AllowFailure
+ @AllowFailure(message="Address is embeddable. Can it be in " +
+ "subquery/From Clause?")
public void testExistExprUsingCriteria() {
String query = "SELECT DISTINCT o.name FROM CompUser o WHERE EXISTS" +
" (SELECT c FROM Address c WHERE c = o.address )";
@@ -370,19 +266,14 @@
o.get(CompUser_.address).get(Address_.country)));
q.where(cb.exists(sq).negate());
q.select(o.get(CompUser_.name)).distinct(true);
+
assertEquivalence(q, query);
- List result = em.createQuery(q).getResultList();
-
- assertNotNull("list is null", result);
- assertEquals("they are not equal", 0, result.size());
-
- em.clear();
}
@AllowFailure
public void testAnyExprUsingCriteria() {
String query =
- "SELECT o.name FROM CompUser o WHERE o.address.zipcode = ANY (" +
+ "SELECT o.name FROM CompUser o WHERE o.address.zipCode = ANY (" +
" SELECT s.computerName FROM CompUser s WHERE " +
"s.address.country IS NOT NULL )";
@@ -396,38 +287,26 @@
null));
q.where(cb.equal(o.get(CompUser_.address).get(Address_.zipCode),
cb.any(sq)));
+
assertEquivalence(q, query);
- List result = em.createQuery(q).getResultList();
-
- assertNotNull("list is null", result);
- assertEquals("they are not equal", 0, result.size());
-
- em.clear();
}
+ @AllowFailure(message="ResultPacker is all confused")
public void testConstructorExprUsingCriteria() {
String query =
"SELECT NEW org.apache.openjpa.persistence.common.apps.MaleUser(" +
"c.name, c.computerName, c.address, c.age, c.userid)" +
" FROM CompUser c WHERE c.name = 'Seetha'";
+
CriteriaQuery q = cb.create();
- q = cb.create();
Root<CompUser> c = q.from(CompUser.class);
q.where(cb.equal(c.get(CompUser_.name), "Seetha"));
q.select(cb.select(MaleUser.class, c.get(CompUser_.name),
c.get(CompUser_.computerName), c.get(CompUser_.address),
c.get(CompUser_.age), c.get(CompUser_.userid)));
- MaleUser male = (MaleUser) em.createQuery(q).getSingleResult();
-
- assertNotNull("the list is null", male);
- assertEquals("the names dont match", "Seetha", male.getName());
- assertEquals("computer names dont match", "MAC",
- male.getComputerName());
- assertEquals("the ages dont match", 40, male.getAge());
-
- em.clear();
- }
+ assertEquivalence(q, query);
+ }
public void testConcatSubStringFunc1() {
String query = "select " +
@@ -446,8 +325,8 @@
)
);
q.where(cb.equal(e.get(CompUser_.name), "Seetha"));
+
assertEquivalence(q, query);
- em.clear();
}
public void testConcatSubStringFunc2() {
@@ -459,18 +338,12 @@
Root<CompUser> e = q.from(CompUser.class);
q.select(e.get(CompUser_.address));
q.where(cb.and(cb.equal(e.get(CompUser_.name), "Seetha"),
- cb.equal(
- e.get(CompUser_.computerName),
+ cb.equal(e.get(CompUser_.computerName),
cb.concat("Ablahum",
- cb.substring(
- e.get(CompUser_.name),
- cb.locate(e.get(CompUser_.name), "e"),
- cb.literal(4)
- )
- )))
- );
+ cb.substring(e.get(CompUser_.name),
+ cb.locate(e.get(CompUser_.name), "e"), cb.literal(4))))));
+
assertEquivalence(q, query);
- em.clear();
}
public void testConcatSubStringFunc3() {
@@ -480,17 +353,11 @@
CriteriaQuery q = cb.create();
q = cb.create();
Root<CompUser> e = q.from(CompUser.class);
- q.select(
- cb.concat("XYZ",
- cb.substring(
- e.get(CompUser_.name),
- cb.locate(e.get(CompUser_.name), "e")
- )
- )
- );
+ q.select(cb.concat("XYZ", cb.substring(e.get(CompUser_.name),
+ cb.locate(e.get(CompUser_.name), "e"))));
q.where(cb.equal(e.get(CompUser_.name), "Ablahumeeth"));
+
assertEquivalence(q, query);
- em.clear();
}
public void testConcatSubStringFunc4() {
@@ -502,17 +369,11 @@
Root<CompUser> e = q.from(CompUser.class);
q.select(e.get(CompUser_.age));
q.where(cb.and(cb.equal(e.get(CompUser_.name), "Seetha"),
- cb.equal(
- e.get(CompUser_.computerName),
- cb.concat("XYZ",
- cb.substring(
- e.get(CompUser_.name),
- cb.locate(e.get(CompUser_.name), "e")
- )
- )))
- );
+ cb.equal(e.get(CompUser_.computerName),
+ cb.concat("XYZ", cb.substring(e.get(CompUser_.name),
+ cb.locate(e.get(CompUser_.name), "e"))))));
+
assertEquivalence(q, query);
- em.clear();
}
public void testConcatFunc() {
@@ -523,8 +384,8 @@
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.concat("", cb.literal("")));
q.where(cb.equal(e.get(CompUser_.name), "Seetha"));
+
assertEquivalence(q, query);
- em.clear();
}
public void testTrimFunc1() {
@@ -535,8 +396,8 @@
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.trim(e.get(CompUser_.computerName)));
q.where(cb.equal(e.get(CompUser_.name), "Shannon "));
+
assertEquivalence(q, query);
- em.clear();
}
public void testTrimFunc2() {
@@ -547,8 +408,8 @@
Root<CompUser> e = q.from(CompUser.class);
q.where(cb.equal(cb.trim(e.get(CompUser_.name)), "Shannon"));
q.select(e.get(CompUser_.computerName));
+
assertEquivalence(q, query);
- em.clear();
}
public void testLowerFunc1() {
@@ -559,8 +420,8 @@
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.lower(e.get(CompUser_.name)));
q.where(cb.equal(e.get(CompUser_.computerName), "UNIX"));
+
assertEquivalence(q, query);
- em.clear();
}
public void testLowerFunc2() {
@@ -571,8 +432,8 @@
Root<CompUser> e = q.from(CompUser.class);
q.where(cb.equal(cb.lower(e.get(CompUser_.name)), "ugo"));
q.select(e.get(CompUser_.age));
+
assertEquivalence(q, query);
- em.clear();
}
public void testUpperFunc1() {
@@ -583,8 +444,8 @@
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.upper(e.get(CompUser_.name)));
q.where(cb.equal(e.get(CompUser_.computerName), "PC"));
+
assertEquivalence(q, query);
- em.clear();
}
public void testUpperFunc2() {
@@ -595,8 +456,8 @@
Root<CompUser> e = q.from(CompUser.class);
q.where(cb.equal(cb.upper(e.get(CompUser_.name)), "UGO"));
q.select(e.get(CompUser_.age));
+
assertEquivalence(q, query);
- em.clear();
}
public void testLengthFunc() {
@@ -608,8 +469,8 @@
q.where(cb.equal(cb.length(e.get(CompUser_.address).
get(Address_.country)), 3));
q.select(e.get(CompUser_.name));
+
assertEquivalence(q, query);
- em.clear();
}
public void testArithmFunc1() {
@@ -620,8 +481,8 @@
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.abs(e.get(CompUser_.age)));
q.where(cb.equal(e.get(CompUser_.name), "Seetha"));
+
assertEquivalence(q, query);
- em.clear();
}
public void testArithmFunc2() {
@@ -632,8 +493,8 @@
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.sqrt(e.get(CompUser_.age)));
q.where(cb.equal(e.get(CompUser_.name), "Seetha"));
+
assertEquivalence(q, query);
- em.clear();
}
@AllowFailure
@@ -645,12 +506,12 @@
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.mod(e.get(CompUser_.age), 4));
q.where(cb.equal(e.get(CompUser_.name), "Seetha"));
+
assertEquivalence(q, query);
- em.clear();
}
// size method can not be applied to an array field
- @AllowFailure
+ @AllowFailure(message="size method can not be applied to an array field?")
public void testArithmFunc4() {
String query = "SELECT e.name FROM CompUser e WHERE " +
"SIZE(e.nicknames) = 6";
@@ -659,8 +520,8 @@
Root<CompUser> e = q.from(CompUser.class);
//q.where(cb.equal(cb.size(e.get(CompUser_.nicknames)), 6));
q.select(e.get(CompUser_.name));
+
assertEquivalence(q, query);
- em.clear();
}
public void testGroupByHavingClause() {
@@ -674,8 +535,8 @@
q.groupBy(e.get(CompUser_.name));
q.having(cb.like(e.get(CompUser_.name), "S%"));
q.select(e.get(CompUser_.name));
+
assertEquivalence(q, query);
- em.clear();
}
public void testOrderByClause() {
@@ -689,19 +550,20 @@
q.where(cb.like(e.get(CompUser_.name), "S%"));
q.select(e.get(CompUser_.name));
q.orderBy(cb.asc(e.get(CompUser_.name)));
+
assertEquivalence(q, query);
- em.clear();
}
public void testAVGAggregFunc() {
//To be Tested: AVG, COUNT, MAX, MIN, SUM
String query = "SELECT AVG(e.age) FROM CompUser e";
+
CriteriaQuery q = cb.create();
q = cb.create();
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.avg(e.get(CompUser_.age)));
+
assertEquivalence(q, query);
- em.clear();
}
public void testCOUNTAggregFunc() {
@@ -711,8 +573,8 @@
q = cb.create();
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.count(e.get(CompUser_.name)));
+
assertEquivalence(q, query);
- em.clear();
}
public void testMAXAggregFunc() {
@@ -722,8 +584,8 @@
q = cb.create();
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.max(e.get(CompUser_.age))).distinct(true);
+
assertEquivalence(q, query);
- em.clear();
}
@AllowFailure(message="criteria does not generate Optimize for 1 row")
@@ -734,8 +596,8 @@
q = cb.create();
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.min(e.get(CompUser_.age))).distinct(true);
+
assertEquivalence(q, query);
- em.clear();
}
public void testSUMAggregFunc() {
@@ -745,8 +607,8 @@
q = cb.create();
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.sum(e.get(CompUser_.age)));
+
assertEquivalence(q, query);
- em.clear();
}
// can not do TYPE with parameter in the IN clause
@@ -762,8 +624,8 @@
Parameter<Class> param2 = cb.parameter(Class.class);
// q.where(cb.in(e.type()).value(param1).value(param2));
q.orderBy(cb.asc(e.get(CompUser_.name)));
+
assertEquivalence(q, query);
- em.clear();
}
@AllowFailure
@@ -775,8 +637,8 @@
Parameter<Class> param1 = cb.parameter(Class.class);
q.select(e.type());
q.where(cb.equal(e.type(), param1).negate());
- assertEquivalence(q, query, new Object[] { MaleUser.class });
- em.clear();
+
+ assertEquivalence(q, query);
}
// Type literal
@@ -791,64 +653,63 @@
// Join<Address,FemaleUser> e = a.join(Address_.user);
// q.select(cb.literal(FemaleUser.class), e.get(CompUser_.address));
// q.where(cb.equal(e.type(), null).negate());
+
assertEquivalence(q, query);
- em.clear();
}
public void testTypeExpression4() {
String query = "SELECT e FROM CompUser e where TYPE(e) = MaleUser";
- CriteriaQuery q = cb.create();
- q = cb.create();
- Root<CompUser> e = q.from(CompUser.class);
- q.select(e);
- q.where(cb.equal(e.type(), cb.literal(MaleUser.class)));
- assertEquivalence(q, query);
- em.clear();
+
+ CriteriaQuery cq = cb.create();
+ Root<CompUser> e = cq.from(CompUser.class);
+ cq.select(e);
+ cq.where(cb.equal(e.type(), cb.literal(MaleUser.class)));
+
+ assertEquivalence(cq, query);
}
public void testTypeExpression5() {
String query = "SELECT e FROM CompUser e where TYPE(e) in (MaleUser)";
- CriteriaQuery q = cb.create();
- q = cb.create();
- Root<CompUser> e = q.from(CompUser.class);
- q.select(e);
- q.where(cb.in(e.type()).value(MaleUser.class));
- assertEquivalence(q, query);
- em.clear();
+
+ CriteriaQuery cq = cb.create();
+ Root<CompUser> e = cq.from(CompUser.class);
+ cq.select(e);
+ cq.where(cb.in(e.type()).value(MaleUser.class));
+
+ assertEquivalence(cq, query);
}
public void testTypeExpression6() {
String query = "SELECT e FROM CompUser e where TYPE(e) not in " +
"(MaleUser, FemaleUser)";
- CriteriaQuery q = cb.create();
- q = cb.create();
- Root<CompUser> e = q.from(CompUser.class);
- q.select(e);
- q.where(cb.in(e.type()).value(MaleUser.class).value(FemaleUser.class)
+
+ CriteriaQuery cq = cb.create();
+ Root<CompUser> e = cq.from(CompUser.class);
+ cq.select(e);
+ cq.where(cb.in(e.type()).value(MaleUser.class).value(FemaleUser.class)
.negate());
- assertEquivalence(q, query);
- em.clear();
+
+ assertEquivalence(cq, query);
}
@AllowFailure
public void testTypeExpression7() {
- String query = "SELECT TYPE(a.user) FROM Address a";
+ String query = "SELECT TYPE(a.b) FROM A a";
CriteriaQuery q = cb.create();
- q = cb.create();
- Root<Address> a = q.from(Address.class);
- q.select(a.get(Address_.user).type());
+ Root<A> a = q.from(A.class);
+ q.select(a.get(A_.b).type());
+
assertEquivalence(q, query);
- em.clear();
}
public void testTypeExpression8() {
- String query = "SELECT MaleUser FROM Address a";
+ String query = "SELECT MaleUser FROM A a";
+
CriteriaQuery q = cb.create();
- q = cb.create();
- Root<Address> a = q.from(Address.class);
+ Root<A> a = q.from(A.class);
q.select(cb.literal(MaleUser.class));
+
assertEquivalence(q, query);
- em.clear();
}
public void testTypeExpression9() {
@@ -859,9 +720,8 @@
Root<CompUser> e = q.from(CompUser.class);
q.select(cb.selectCase(e.type()).when(FemaleUser.class, "Female")
.otherwise("Male"));
+
assertEquivalence(q, query);
-
- em.clear();
}
public void testCoalesceExpressions() {
@@ -875,8 +735,8 @@
e.get(CompUser_.address).get(Address_.country))
.value("Unknown"));
q.orderBy(cb.desc(e.get(CompUser_.name)));
+
assertEquivalence(q, query);
- em.clear();
}
public void testNullIfExpressions() {
@@ -887,8 +747,8 @@
q.select(e.get(CompUser_.name), cb.nullif(e.get(CompUser_.address).get(
Address_.country), "USA"));
q.orderBy(cb.desc(e.get(CompUser_.name)));
+
assertEquivalence(q, query);
- em.clear();
}
public void testSimpleCaseExpression1() {
@@ -904,6 +764,7 @@
"us").otherwise("non-us");
q.select(e.get(CompUser_.name), cage, d2, e.get(CompUser_.address).get(
Address_.country));
+
assertEquivalence(q, query);
}
@@ -922,6 +783,7 @@
e.get(CompUser_.address).get(Address_.country));
q.select(e.get(CompUser_.name), cage, d2, e.get(CompUser_.address).get(
Address_.country));
+
assertEquivalence(q, query);
}
@@ -938,6 +800,7 @@
.otherwise("Male"));
q.where(cb.like(e.get(CompUser_.name), "S%"));
q.orderBy(cb.desc(e.get(CompUser_.name)));
+
assertEquivalence(q, query);
}
@@ -952,6 +815,7 @@
true).otherwise(false);
q.select(e.get(CompUser_.name), b, e.get(CompUser_.address).get(
Address_.country));
+
assertEquivalence(q, query);
}
@@ -968,6 +832,7 @@
cb.sum(e.get(CompUser_.age), 1)).otherwise(
cb.sum(e.get(CompUser_.age), 0));
q.select(e.get(CompUser_.name), e.get(CompUser_.age), cage);
+
assertEquivalence(q, query);
}
@@ -989,6 +854,7 @@
Expression cage = cb.sum(e.get(CompUser_.age), 1);
q.select(e.get(CompUser_.name), cage, d2, e.get(CompUser_.address).get(
Address_.country));
+
assertEquivalence(q, query);
}
@@ -1013,6 +879,7 @@
CompUser.CreditRating.EXCELLENT));
q.orderBy(cb.asc(e.get(CompUser_.age)));
+
assertEquivalence(q, query);
}
@@ -1051,19 +918,16 @@
CompUser.CreditRating.EXCELLENT)));
q.orderBy(cb.asc(e.get(CompUser_.age)));
+
assertEquivalence(q, query);
- List rs = em.createQuery(q).getResultList();
- Object[] result = (Object[]) rs.get(0);
- assertEquals("the name is not Ugo", "Ugo", result[0]);
- assertEquals("the credit rating is not 'EXCELLENT'", "EXCELLENT",
- ((CompUser.CreditRating) result[1]).name());
}
@AllowFailure
public void testSubquery1() {
String query = "select o1.id from Order o1 where o1.id in "
+ " (select distinct o.id from LineItem i, Order o"
- + " where i.quantity > 10 and o.count > 1000 and i.lid = o.id)";
+ + " where i.quantity > 10 and o.count > 1000 and i.id = o.id)";
+
CriteriaQuery q = cb.create();
Root<Order> o1 = q.from(Order.class);
q.select(o1.get(Order_.id));
@@ -1077,6 +941,7 @@
sq.select(o.get(Order_.id)).distinct(true);
q.where(cb.in(o1.get(Order_.id)).value(
sq.select(o.get(Order_.id)).distinct(true)));
+
assertEquivalence(q, query);
}
@@ -1095,6 +960,7 @@
q.where(cb.equal(o.get(Order_.customer).get(Customer_.balanceOwed), sq
.select(cb.max(o2.get(Order_.customer).get(
Customer_.balanceOwed)))));
+
assertEquivalence(q, query);
}
@@ -1113,13 +979,14 @@
q.where(cb.equal(o.get(Order_.customer).get(Customer_.balanceOwed), sq
.select(cb.max(o2.get(Order_.customer).get(
Customer_.balanceOwed)))));
+
assertEquivalence(q, query);
}
@AllowFailure
public void testSubquery4() {
String query = "select o.id from Order o where o.quantity >"
- + " (select count(i) from o.lineitems i)";
+ + " (select count(i) from o.lineItems i)";
CriteriaQuery q = cb.create();
Root<Order> o = q.from(Order.class);
q.select(o.get(Order_.id));
@@ -1141,6 +1008,7 @@
Root<Order> o2 = sq.from(Order.class);
q.where(cb.gt(o.get(Order_.quantity), sq.select(cb.count(o2
.get(Order_.quantity)))));
+
assertEquivalence(q, query);
}
@@ -1155,6 +1023,7 @@
Root<Order> o2 = sq.from(Order.class);
q.where(cb.gt(o.get(Order_.quantity), sq.select(cb.count(o2
.get(Order_.id)))));
+
assertEquivalence(q, query);
}
@@ -1169,6 +1038,7 @@
Root<Order> o2 = sq.from(Order.class);
q.where(cb.gt(o.get(Order_.quantity), sq.select(cb.avg(o2
.get(Order_.quantity)))));
+
assertEquivalence(q, query);
}
@@ -1191,6 +1061,7 @@
sq2.where(cb.equal(o2.get(Order_.id), 2)).select(o2);
q.where(cb.or(cb.exists(sq1), cb.exists(sq2)));
+
assertEquivalence(q, query);
}
@@ -1216,6 +1087,7 @@
// not sure how to do call between of integer(quantity)
// between integer (max quantity) and double (avg quantity)
// q.where(cb.between(o.get(Order_.quantity), sq1, sq2));
+
assertEquivalence(q, query);
}
@@ -1234,6 +1106,7 @@
sq.select(cb.sum(o2.get(Order_.quantity)));
q.where(cb.gt(o2.get(Order_.quantity), sq));
+
assertEquivalence(q, query);
}
@@ -1278,6 +1151,7 @@
SetJoin<Customer, Order> o2 = sqc.join(Customer_.orders);
sq.select(cb.sum(o2.get(Order_.quantity)));
q.where(cb.gt(o.get(Order_.quantity), sq));
+
assertEquivalence(q, query);
}
@@ -1297,6 +1171,7 @@
sq.select(o2.get(Order_.quantity));
q.where(cb.equal(o1.get(Order_.quantity), cb.any(sq)));
+
assertEquivalence(q, query);
}
@@ -1330,6 +1205,7 @@
Publisher_.id), p.get(Publisher_.id)), cb.equal(m2
.get(Magazine_.datePublished), sq2.select(cb.max(m3
.get(Magazine_.id))))));
+
assertEquivalence(q, query);
}
@@ -1365,12 +1241,13 @@
.otherwise(false)
// )
));
+
assertEquivalence(q, query);
}
@AllowFailure
public void testSubquery16() {
- String query = "select o1.oid from Order o1 where o1.quantity > "
+ String query = "select o1.id from Order o1 where o1.quantity > "
+ " (select o.quantity*2 from LineItem i, Order o"
+ " where i.quantity > 10 and o.quantity > 1000 and i.id = " +
"o.id)";
@@ -1415,7 +1292,7 @@
@AllowFailure
public void testSubquery18() {
String query = "select o.id from Order o where o.orderTs >"
- + " (select CURRENT_TIMESTAMP from o.lineitems i)";
+ + " (select CURRENT_TIMESTAMP from o.lineItems i)";
CriteriaQuery q = cb.create();
Root<Order> o = q.from(Order.class);
q.select(o.get(Order_.id));
@@ -1427,6 +1304,7 @@
// q.where(cb.gt(
// o.get(Order_.orderTs),
// sq.select(cb.currentTimestamp())));
+
assertEquivalence(q, query);
}
@@ -1569,30 +1447,4 @@
+ "AND d.id.effDate < :maxDate ";
}
- void startTx(EntityManager em) {
- em.getTransaction().begin();
- }
-
- void endTx(EntityManager em) {
- em.getTransaction().commit();
- }
-
- public CompUser createUser(String name, String cName, Address add, int age,
- boolean isMale) {
- CompUser user = null;
- if (isMale) {
- user = new MaleUser();
- user.setName(name);
- user.setComputerName(cName);
- user.setAddress(add);
- user.setAge(age);
- } else {
- user = new FemaleUser();
- user.setName(name);
- user.setComputerName(cName);
- user.setAddress(add);
- user.setAge(age);
- }
- return user;
- }
}
Modified: openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestTypesafeCriteria.java
URL: http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestTypesafeCriteria.java?rev=783166&r1=783165&r2=783166&view=diff
==============================================================================
--- openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestTypesafeCriteria.java (original)
+++ openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/persistence/criteria/TestTypesafeCriteria.java Wed Jun 10 00:41:35 2009
@@ -44,7 +44,7 @@
*
*/
public class TestTypesafeCriteria extends CriteriaTest {
-
+
public void testExplictRoot() {
String jpql = "select a from Account a";
CriteriaQuery c = cb.create();
@@ -183,20 +183,30 @@
assertEquivalence(c, jpql);
}
+ public void testMultipartNavigation() {
+ String jpql = "select a from A a where a.b.age=22";
+
+ CriteriaQuery cq = cb.create();
+ Root<A> a = cq.from(A.class);
+ cq.where(cb.equal(a.get(A_.b).get(B_.age), 22));
+
+ assertEquivalence(cq, jpql);
+ }
+
@AllowFailure(message = "Extra joins created in Criteria")
public void testMultiLevelJoins() {
String jpql = "SELECT c FROM Customer c JOIN c.orders o "
+ "JOIN o.lineItems i WHERE i.product.productType = 'printer'";
- CriteriaQuery c = cb.create();
- Root<Customer> cust = c.from(Customer.class);
- Join<Customer, Order> order = cust.join(Customer_.orders);
- Join<Order, LineItem> item = order.join(Order_.lineItems);
- c.select(cust.get(Customer_.name))
- .where(cb.equal(item.get(LineItem_.product)
+ CriteriaQuery cq = cb.create();
+ Root<Customer> c = cq.from(Customer.class);
+ Join<Customer, Order> o = c.join(Customer_.orders);
+ Join<Order, LineItem> i = o.join(Order_.lineItems);
+ cq.select(c)
+ .where(cb.equal(i.get(LineItem_.product)
.get(Product_.productType), "printer"));
- assertEquivalence(c, jpql);
+ assertEquivalence(cq, jpql);
}
public void testJoinsNotPresentInWhereClause() {
@@ -228,15 +238,16 @@
String jpql = "SELECT p.vendor FROM Employee e JOIN "
+ "e.contactInfo.phones p "
+ "WHERE e.contactInfo.address.zipCode = '95054'";
- CriteriaQuery q = cb.create();
- Root<Employee> emp = q.from(Employee.class);
- Join<Contact, Phone> phone = emp.join(Employee_.contactInfo).join(
+
+ CriteriaQuery cq = cb.create();
+ Root<Employee> e = cq.from(Employee.class);
+ Join<Contact, Phone> p = e.join(Employee_.contactInfo).join(
Contact_.phones);
- q.where(cb.equal(emp.get(Employee_.contactInfo).get(Contact_.address)
+ cq.where(cb.equal(e.get(Employee_.contactInfo).get(Contact_.address)
.get(Address_.zipCode), "95054"));
- q.select(phone.get(Phone_.vendor));
+ cq.select(p.get(Phone_.vendor));
- assertEquivalence(q, jpql);
+ assertEquivalence(cq, jpql);
}
@AllowFailure(message = "Key expression not implemented")
@@ -281,18 +292,19 @@
@AllowFailure(message = "broken")
public void testExpressionInProjection() {
String jpql = "SELECT o.quantity, o.totalCost*1.08 AS taxedCost, "
- + "a.zipCode FROM Customer c JOIN c.orders o JOIN c.address a"
+ + "a.zipCode FROM Customer c JOIN c.orders o JOIN c.address a "
+ "WHERE a.state = 'CA' AND a.county = 'Santa Clara'";
- CriteriaQuery q = cb.create();
- Root<Customer> cust = q.from(Customer.class);
- Join<Customer, Order> order = cust.join(Customer_.orders);
- Join<Customer, Address> address = cust.join(Customer_.address);
- q.where(cb.equal(address.get(Address_.state), "CA"), cb.equal(address
- .get(Address_.county), "Santa Clara"));
- q.select(order.get(Order_.quantity), cb.prod(order
- .get(Order_.totalCost), 1.08), address.get(Address_.zipCode));
+
+ CriteriaQuery cq = cb.create();
+ Root<Customer> c = cq.from(Customer.class);
+ Join<Customer, Order> o = c.join(Customer_.orders);
+ Join<Customer, Address> a = c.join(Customer_.address);
+ cq.where(cb.equal(a.get(Address_.state), "CA"),
+ cb.equal(a.get(Address_.county), "Santa Clara"));
+ cq.select(o.get(Order_.quantity), cb.prod(o
+ .get(Order_.totalCost), 1.08), a.get(Address_.zipCode));
- assertEquivalence(q, jpql);
+ assertEquivalence(cq, jpql);
}
public void testTypeExpression() {