| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.openjpa.persistence.relations; |
| |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Set; |
| |
| import javax.persistence.EntityManager; |
| import javax.persistence.Query; |
| |
| import junit.textui.TestRunner; |
| import org.apache.openjpa.persistence.OpenJPAEntityManager; |
| import org.apache.openjpa.persistence.OpenJPAQuery; |
| import org.apache.openjpa.persistence.query.Magazine; |
| import org.apache.openjpa.persistence.query.Publisher; |
| import org.apache.openjpa.persistence.test.SQLListenerTestCase; |
| |
| |
| public class TestInverseEagerSQL |
| extends SQLListenerTestCase { |
| |
| public void setUp() { |
| setUp(Customer.class, Customer.CustomerKey.class, Order.class, |
| EntityAInverseEager.class, EntityA1InverseEager.class, EntityA2InverseEager.class, |
| EntityBInverseEager.class, EntityCInverseEager.class, EntityDInverseEager.class, |
| Publisher.class, Magazine.class); |
| |
| EntityManager em = emf.createEntityManager(); |
| em.getTransaction().begin(); |
| |
| Customer.CustomerKey ck = new Customer.CustomerKey("USA", 1); |
| Customer c = new Customer(); |
| c.setCid(ck); |
| c.setName("customer1"); |
| em.persist(c); |
| |
| for (int i = 0; i < 4; i++) { |
| Order order = new Order(); |
| order.setCustomer(c); |
| em.persist(order); |
| } |
| |
| EntityAInverseEager a = new EntityAInverseEager("a"); |
| em.persist(a); |
| |
| EntityA1InverseEager a1 = new EntityA1InverseEager("a1"); |
| em.persist(a1); |
| |
| EntityA2InverseEager a2 = new EntityA2InverseEager("a2"); |
| em.persist(a2); |
| |
| for (int i = 0; i < 4; i++) { |
| EntityBInverseEager b = new EntityBInverseEager("b" + i); |
| a.addB(b); |
| b.setA(a); |
| em.persist(b); |
| } |
| |
| for (int i = 4; i < 8; i++) { |
| EntityBInverseEager b = new EntityBInverseEager("b" + i); |
| a1.addB(b); |
| b.setA(a1); |
| em.persist(b); |
| } |
| |
| for (int i = 8; i < 12; i++) { |
| EntityBInverseEager b = new EntityBInverseEager("b" + i); |
| a2.addB(b); |
| b.setA(a2); |
| em.persist(b); |
| } |
| |
| for (int i = 0; i < 4; i++) { |
| EntityCInverseEager c1 = new EntityCInverseEager("c"+i, i, i); |
| em.persist(c1); |
| |
| EntityDInverseEager d1 = new EntityDInverseEager("d"+i, "d"+i, i, i); |
| em.persist(d1); |
| |
| c1.setD(d1); |
| d1.setC(c1); |
| } |
| |
| Publisher p1 = new Publisher(); |
| p1.setName("publisher1"); |
| em.persist(p1); |
| |
| for (int i = 0; i < 4; i++) { |
| Magazine magazine = new Magazine(); |
| magazine.setIdPublisher(p1); |
| magazine.setName("magagine"+i+"_"+p1.getName()); |
| em.persist(magazine); |
| } |
| |
| Publisher p2 = new Publisher(); |
| p2.setName("publisher2"); |
| em.persist(p2); |
| |
| for (int i = 0; i < 4; i++) { |
| Magazine magazine = new Magazine(); |
| magazine.setIdPublisher(p2); |
| magazine.setName("magagine"+i+"_"+p2.getName()); |
| em.persist(magazine); |
| } |
| |
| em.flush(); |
| em.getTransaction().commit(); |
| em.close(); |
| } |
| |
| public void testOneToManyInverseEagerQuery() { |
| sql.clear(); |
| |
| OpenJPAEntityManager em = emf.createEntityManager(); |
| OpenJPAQuery q = em.createQuery("SELECT c FROM Customer c "); |
| List<Customer> res = q.getResultList(); |
| |
| assertEquals(1, res.size()); |
| |
| for (int i = 0; i < res.size(); i++) { |
| Customer c = (Customer)res.get(i); |
| Collection<Order> orders = c.getOrders(); |
| for (Iterator<Order> iter=orders.iterator(); iter.hasNext();) { |
| Order order = (Order)iter.next(); |
| assertEquals(order.getCustomer(), c); |
| } |
| } |
| |
| assertEquals(2, sql.size()); |
| em.close(); |
| } |
| |
| public void testOneToOneInverseEagerQuery() { |
| sql.clear(); |
| |
| OpenJPAEntityManager em = emf.createEntityManager(); |
| String query = "select c FROM EntityCInverseEager c"; |
| Query q = em.createQuery(query); |
| List<EntityCInverseEager> res = q.getResultList(); |
| assertEquals(4, res.size()); |
| |
| for (int i = 0; i < res.size(); i++) { |
| EntityCInverseEager c = (EntityCInverseEager)res.get(i); |
| EntityDInverseEager d = c.getD(); |
| assertEquals(c, d.getC()); |
| } |
| |
| assertEquals(1, sql.size()); |
| em.close(); |
| } |
| |
| public void testOneToManyInheritanceQuery() { |
| sql.clear(); |
| |
| OpenJPAEntityManager em = emf.createEntityManager(); |
| String query = "select a FROM EntityA1InverseEager a"; |
| Query q = em.createQuery(query); |
| List list = q.getResultList(); |
| assertEquals(1, list.size()); |
| for (int i = 0; i < list.size(); i++) { |
| EntityA1InverseEager a1 = (EntityA1InverseEager)list.get(i); |
| Collection<EntityBInverseEager> listB = a1.getListB(); |
| assertEquals(4, listB.size()); |
| for (Iterator iter=listB.iterator(); iter.hasNext();) { |
| EntityBInverseEager b = (EntityBInverseEager)iter.next(); |
| EntityAInverseEager a = b.getA(); |
| assertEquals(a1, a); |
| } |
| } |
| assertEquals(3, sql.size()); |
| sql.clear(); |
| |
| query = "select a FROM EntityA2InverseEager a"; |
| q = em.createQuery(query); |
| list = q.getResultList(); |
| assertEquals(1, list.size()); |
| for (int i = 0; i < list.size(); i++) { |
| EntityA2InverseEager a2 = (EntityA2InverseEager)list.get(i); |
| Collection listB = a2.getListB(); |
| assertEquals(4, listB.size()); |
| for (Iterator iter=listB.iterator(); iter.hasNext();) { |
| EntityBInverseEager b = (EntityBInverseEager)iter.next(); |
| EntityAInverseEager a = b.getA(); |
| assertEquals(a2, a); |
| } |
| } |
| assertEquals(3, sql.size()); |
| sql.clear(); |
| |
| query = "select a FROM EntityAInverseEager a"; |
| q = em.createQuery(query); |
| list = q.getResultList(); |
| assertEquals(3, list.size()); |
| for (int i = 0; i < list.size(); i++) { |
| EntityAInverseEager a0 = (EntityAInverseEager)list.get(i); |
| Collection listB = a0.getListB(); |
| assertEquals(4, listB.size()); |
| for (Iterator iter=listB.iterator(); iter.hasNext();) { |
| EntityBInverseEager b = (EntityBInverseEager)iter.next(); |
| EntityAInverseEager a = b.getA(); |
| assertEquals(a0, a); |
| } |
| } |
| |
| assertEquals(2, sql.size()); |
| em.close(); |
| } |
| |
| public void testOneToManyEagerInverseLazyQuery() { |
| sql.clear(); |
| |
| OpenJPAEntityManager em = emf.createEntityManager(); |
| String query = "select p FROM Publisher p"; |
| Query q = em.createQuery(query); |
| List list = q.getResultList(); |
| assertEquals(2, list.size()); |
| assertEquals(2, sql.size()); |
| |
| sql.clear(); |
| em.clear(); |
| for (int i = 0; i < list.size(); i++) { |
| Publisher p = (Publisher) list.get(i); |
| Set<Magazine> magazines = p.getMagazineCollection(); |
| assertEquals(4, magazines.size()); |
| for (Iterator iter = magazines.iterator(); iter.hasNext();) { |
| Magazine m = (Magazine) iter.next(); |
| Publisher mp = m.getIdPublisher(); |
| assertEquals(p, mp); |
| } |
| } |
| |
| assertEquals(0, sql.size()); |
| em.close(); |
| } |
| |
| public static void main(String[] args) { |
| TestRunner.run(TestInverseEagerSQL.class); |
| } |
| } |
| |