/* | |
* TestPersistentMaps.java | |
* | |
* Created on October 13, 2006, 1:54 PM | |
* | |
* To change this template, choose Tools | Template Manager | |
* and open the template in the editor. | |
*/ | |
/* | |
* 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.kernel; | |
import java.util.ArrayList; | |
import java.util.Arrays; | |
import java.util.Collection; | |
import java.util.HashMap; | |
import java.util.Iterator; | |
import java.util.List; | |
import java.util.Map; | |
import org.apache.openjpa.persistence.kernel.common.apps.MapElementPC; | |
import org.apache.openjpa.persistence.kernel.common.apps.MapElementPCChild; | |
import org.apache.openjpa.persistence.kernel.common.apps.PersistentMapHolder; | |
import org.apache.openjpa.persistence.Extent; | |
import org.apache.openjpa.persistence.OpenJPAEntityManager; | |
import org.apache.openjpa.persistence.OpenJPAQuery; | |
public class TestPersistentMaps extends BaseKernelTest { | |
private static final String JDOQL = "javax.jdo.query.JDOQL"; | |
/** | |
* Creates a new instance of TestPersistentMaps | |
*/ | |
public TestPersistentMaps() { | |
} | |
public TestPersistentMaps(String name) { | |
super(name); | |
} | |
public void setUp() { | |
deleteAll(PersistentMapHolder.class); | |
OpenJPAEntityManager pm = getPM(); | |
startTx(pm); | |
pm.persist(new PersistentMapHolder()); | |
endTx(pm); | |
endEm(pm); | |
} | |
private PersistentMapHolder getHolder(OpenJPAEntityManager pm) { | |
Extent e = pm.createExtent(PersistentMapHolder.class, true); | |
assertSize(1, ((Collection) e.list())); | |
return (PersistentMapHolder) e.iterator().next(); | |
} | |
private Object keyInstance(Class type) throws Exception { | |
if (type.getName().equals(String.class.getName())) | |
return randomString(); | |
else | |
return type.newInstance(); | |
} | |
private void testMap(int num, String name, Class keyClass, Class valueClass) | |
throws Exception { | |
OpenJPAEntityManager srcpm = getPM(true, true); | |
startTx(srcpm); | |
PersistentMapHolder holder = getHolder(srcpm); | |
Map map = holder.getNamedMap(name); | |
Map internalMap = new HashMap(); | |
for (int i = 0; i < num; i++) { | |
Object key = keyInstance(keyClass); | |
Object value = keyInstance(valueClass); | |
map.put(key, value); | |
internalMap.put(key, value); | |
assertEquals(map.get(key), internalMap.get(key)); | |
} | |
endTx(srcpm); | |
OpenJPAEntityManager pm = getPM(); | |
startTx(pm); | |
// holder = getHolder(pm); | |
map = holder.getNamedMap(name); | |
for (Iterator i = internalMap.keySet().iterator(); i.hasNext();) { | |
Object k = i.next(); | |
assertEquals(map.get(k), internalMap.get(k)); | |
} | |
endTx(pm); | |
endEm(pm); | |
String selectWhere = | |
"select from " + PersistentMapHolder.class.getName() + " where "; | |
pm = getPM(); | |
startTx(pm); | |
for (Iterator i = internalMap.keySet().iterator(); i.hasNext();) { | |
Object param = i.next(); | |
if (pm.isPersistent(param)) | |
param = pm.find(param.getClass(), pm.getObjectId(param)); | |
Object val = internalMap.get(param); | |
if (pm.isPersistent(val)) | |
val = pm.find(val.getClass(), pm.getObjectId(val)); | |
OpenJPAQuery q; | |
q = pm.createQuery(JDOQL, | |
selectWhere + name + ".containsKey(:param)"); | |
q.setParameter("param", param); | |
assertSize(1, q.getResultList()); | |
q = pm.createQuery(JDOQL, | |
selectWhere + name + ".containsValue(:value)"); | |
q.setParameter("value", val); | |
assertSize(1, q.getResultList()); | |
q = pm.createQuery(JDOQL, selectWhere + name + ".containsValue(" + | |
name + ".get(:param))"); | |
q.setParameter("param", param); | |
assertSize(1, q.getResultList()); | |
q = pm.createQuery(JDOQL, | |
selectWhere + name + ".get(:param) != null"); | |
q.setParameter("param", param); | |
assertSize(1, q.getResultList()); | |
q = pm.createQuery(JDOQL, | |
selectWhere + name + ".get(:param) == :value"); | |
q.setParameter("param", param); | |
q.setParameter("value", val); | |
assertSize(1, q.getResultList()); | |
q = pm.createQuery(JDOQL, | |
selectWhere + name + ".get(:param) != :value"); | |
q.setParameter("param", param); | |
q.setParameter("value", val); | |
assertSize(0, q.getResultList()); | |
} | |
endTx(pm); | |
endEm(pm); | |
pm = getPM(); | |
startTx(pm); | |
for (Iterator i = internalMap.keySet().iterator(); i.hasNext();) { | |
Object param = i.next(); | |
if (pm.isPersistent(param)) | |
param = pm.find(param.getClass(), pm.getObjectId(param)); | |
List getQueries = new ArrayList(Arrays.asList(new String[]{ | |
selectWhere + name + ".get(:param) != null", | |
selectWhere + name + ".get(:param) == " + name + ".get(:param)", | |
selectWhere + "!(" + name + ".get(:param) == null)", | |
selectWhere + "!(" + name + ".get(:param) != " + name + | |
".get(:param))", | |
})); | |
for (Iterator qi = getQueries.iterator(); qi.hasNext();) { | |
String query = (String) qi.next(); | |
if (valueClass == String.class) | |
query += " order by " + name + ".get(:param) desc"; | |
OpenJPAQuery q = pm.createQuery(JDOQL, query); | |
q.setParameter("param", param); | |
assertSize(1, q.getResultList()); | |
} | |
} | |
endTx(pm); | |
endEm(pm); | |
endEm(srcpm); | |
} | |
public void testPCKeyStringValue() | |
throws Exception { | |
testMap(5, "testPCKeyStringValue", | |
MapElementPC.class, String.class); | |
} | |
public void testStringKeyPCValue() | |
throws Exception { | |
testMap(6, "testStringKeyPCValue", | |
String.class, MapElementPC.class); | |
} | |
public void testPCKeyPCValue() | |
throws Exception { | |
testMap(7, "testPCKeyPCValue", | |
MapElementPC.class, MapElementPC.class); | |
} | |
public void testPCSubKeyStringValue() | |
throws Exception { | |
testMap(8, "testPCSubKeyStringValue", | |
MapElementPCChild.class, String.class); | |
} | |
public void testStringKeyPCSubValue() | |
throws Exception { | |
testMap(9, "testStringKeyPCSubValue", | |
String.class, MapElementPCChild.class); | |
} | |
public void testPCSubKeyPCValue() | |
throws Exception { | |
testMap(10, "testPCSubKeyPCValue", | |
MapElementPCChild.class, MapElementPC.class); | |
} | |
public void testPCSubKeyPCSubValue() | |
throws Exception { | |
testMap(11, "testPCSubKeyPCSubValue", | |
MapElementPCChild.class, MapElementPCChild.class); | |
} | |
public void testPCKeyPCSubValue() | |
throws Exception { | |
testMap(12, "testPCKeyPCSubValue", | |
MapElementPC.class, MapElementPCChild.class); | |
} | |
public void testPCIntfKeyStringValue() | |
throws Exception { | |
testMap(13, "testPCIntfKeyStringValue", | |
MapElementPC.class, String.class); | |
} | |
public void testStringKeyPCIntfValue() | |
throws Exception { | |
testMap(14, "testStringKeyPCIntfValue", | |
String.class, MapElementPC.class); | |
} | |
public void testPCIntfKeyPCValue() | |
throws Exception { | |
testMap(15, "testPCIntfKeyPCValue", | |
MapElementPC.class, MapElementPC.class); | |
} | |
/** | |
* Test querying maps when there are multiple holder instances that | |
* have maps with the same key. | |
*/ | |
public void testQueryMultipleMaps() throws Exception { | |
deleteAll(PersistentMapHolder.class); | |
String mapName = "testStringKeyPCValue"; | |
String[] mapNames = new String[]{ | |
"testPCKeyStringValue", | |
// "testStringKeyPCValue", | |
"testPCKeyPCValue", | |
"testPCSubKeyStringValue", | |
"testStringKeyPCSubValue", | |
"testPCSubKeyPCValue", | |
"testPCSubKeyPCSubValue", | |
"testPCKeyPCSubValue", | |
"testPCIntfKeyStringValue", | |
"testStringKeyPCIntfValue", | |
"testPCIntfKeyPCValue", | |
}; | |
OpenJPAEntityManager pm; | |
pm = getPM(); | |
startTx(pm); | |
MapElementPC pc = new MapElementPC(); | |
pc.setElementData("foo"); | |
int max = 5; | |
for (int i = 0; i < max; i++) { | |
PersistentMapHolder holder = new PersistentMapHolder(); | |
for (int j = 0; j < i; j++) { | |
holder.getNamedMap(mapName).put("key" + j, pc); | |
} | |
pm.persist(holder); | |
} | |
endTx(pm); | |
endEm(pm); | |
pm = getPM(); | |
pc = (MapElementPC) pm.find(MapElementPC.class, pm.getObjectId(pc)); | |
for (int i = 0; i < max; i++) { | |
OpenJPAQuery q; | |
String key = "key" + i; | |
String selectWhere = "select from " + | |
PersistentMapHolder.class.getName() + " where "; | |
q = pm.createQuery(JDOQL, | |
selectWhere + mapName + ".containsKey(:key)"); | |
q.setParameter("key", key); | |
assertSize(max - i - 1, q.getResultList()); | |
q = pm.createQuery(JDOQL, | |
selectWhere + mapName + ".get(:key) == :val"); | |
q.setParameter("key", key); | |
q.setParameter("val", pc); | |
assertSize(max - i - 1, q.getResultList()); | |
q = pm.createQuery(JDOQL, | |
selectWhere + "testPCKeyStringValue.isEmpty() && " | |
+ mapName + ".get(:key) == :val"); | |
q.setParameter("key", key); | |
q.setParameter("val", pc); | |
assertSize(max - i - 1, q.getResultList()); | |
// now try to execute queries against multiple other | |
// map instances, so we can make sure the joins are robust | |
for (int j = 0; j < mapNames.length; j++) { | |
StringBuffer query = new StringBuffer(selectWhere); | |
for (int k = 0; k < j; k++) { | |
query.append(mapNames[k] + ".isEmpty() && "); | |
} | |
q = pm.createQuery(JDOQL, | |
query + mapName + ".get(:key) == :val"); | |
q.setParameter("key", key); | |
q.setParameter("val", pc); | |
assertSize(max - i - 1, q.getResultList()); | |
} | |
} | |
endEm(pm); | |
} | |
} |