Author: ppoddar
Date: Wed Feb 11 16:57:26 2009
New Revision: 743396
URL: http://svn.apache.org/viewvc?rev=743396&view=rev
Log:
OPENJPA-900: Consolidate Query Hint related processing. As a
byproduct, support new JPA 2.0 getHins() and getSupportedHints().
Added:
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/util/Reflectable.java
openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/conf/TestQueryHints.java
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/HintHandler.java
Modified:
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/conf/JDBCProductDerivation.java
openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/enhance/Reflection.java
openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/kernel/Filters.java
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/AbstractProductDerivation.java
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/ProductDerivation.java
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/ProductDerivations.java
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/FetchPlan.java
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/QueryImpl.java
openjpa/trunk/openjpa-persistence/src/main/resources/org/apache/openjpa/persistence/localizer.properties
openjpa/trunk/openjpa-slice/src/main/java/org/apache/openjpa/slice/ProductDerivation.java
Modified:
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/conf/JDBCProductDerivation.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/conf/JDBCProductDerivation.java?rev=743396&r1=743395&r2=743396&view=diff
==============================================================================
---
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/conf/JDBCProductDerivation.java
(original)
+++
openjpa/trunk/openjpa-jdbc/src/main/java/org/apache/openjpa/jdbc/conf/JDBCProductDerivation.java
Wed Feb 11 16:57:26 2009
@@ -18,11 +18,14 @@
*/
package org.apache.openjpa.jdbc.conf;
+import java.util.Collections;
import java.util.Map;
+import java.util.Set;
import org.apache.openjpa.conf.BrokerFactoryValue;
import org.apache.openjpa.conf.OpenJPAProductDerivation;
import org.apache.openjpa.jdbc.kernel.JDBCBrokerFactory;
+import org.apache.openjpa.jdbc.sql.OracleDictionary;
import org.apache.openjpa.lib.conf.AbstractProductDerivation;
import org.apache.openjpa.lib.conf.ConfigurationProvider;
@@ -48,4 +51,9 @@
}
return false;
}
+ + @Override
+ public Set<String> getSupportedQueryHints() {
+ return Collections.singleton(OracleDictionary.SELECT_HINT);
+ }
}
Modified:
openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/enhance/Reflection.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/enhance/Reflection.java?rev=743396&r1=743395&r2=743396&view=diff
==============================================================================
---
openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/enhance/Reflection.java
(original)
+++
openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/enhance/Reflection.java
Wed Feb 11 16:57:26 2009
@@ -21,13 +21,18 @@
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.security.AccessController;
+import java.util.Collections;
+import java.util.Set;
+import java.util.TreeSet;
import org.apache.commons.lang.StringUtils;
import org.apache.openjpa.lib.util.J2DoPrivHelper;
import org.apache.openjpa.lib.util.Localizer;
+import org.apache.openjpa.lib.util.Reflectable;
import org.apache.openjpa.util.GeneralException; import
org.apache.openjpa.util.UserException;
@@ -754,4 +759,166 @@
public static void set(Object target, Method setter, short value) {
set(target, setter, new Short(value));
}
+ + /**
+ * Gets all bean-style property names of the given Class or its
superclass.
+ * A bean-style property 'abc' exists in Class C iff C has
declared + * following pair of methods:
+ * public void setAbc(Y y) or public C setAbc(Y y)
+ * public Y getAbc();
+ * + * If a getter property is annotated with {...@link
Reflectable}, then
+ * it is ignored.
+ * + */
+ public static Set<String> getBeanStylePropertyNames(Class c) {
+ if (c == null)
+ return Collections.EMPTY_SET;
+ Method[] methods = c.getMethods();
+ if (methods == null || methods.length < 2)
+ return Collections.EMPTY_SET;
+ Set<String> result = new TreeSet<String>();
+ for (Method m : methods) {
+ if (m.getName().startsWith("get")) {
+ if (!canReflect(m))
+ continue;
+ String prop = StringUtils.capitalize(m.getName()
+ .substring("get".length()));
+ Class rtype = m.getReturnType();
+ try {
+ Method setter = c.getMethod("set"+prop, new
Class[]{rtype});
+ if (setter.getReturnType() == void.class ||
+ setter.getReturnType().isAssignableFrom(c))
+ result.add(prop);
+ } catch (NoSuchMethodException e) {
+ + }
+ }
+ }
+ return result;
+ }
+ + /**
+ * Gets all public field names of the given Class.
+ * + */
+ public static Set<String> getPublicFieldNames(Class c) {
+ if (c == null)
+ return Collections.EMPTY_SET;
+ Field[] fields = c.getFields();
+ if (fields == null || fields.length == 0)
+ return Collections.EMPTY_SET;
+ Set<String> result = new TreeSet<String>();
+ for (Field f : fields) {
+ if (canReflect(f))
+ result.add(f.getName());
+ }
+ return result;
+ }
+ + /**
+ * Gets values of all field f the given class such that f exactly
+ * match the given modifiers and are of given type (Object
implies any type)
+ * unless f is annotated as {...@link Reflectable}. + * + */
+ public static <T> Set<T> getFieldValues(Class c, int mods,
Class<T> t){
+ if (c == null)
+ return Collections.EMPTY_SET;
+ Field[] fields = c.getFields();
+ if (fields == null || fields.length == 0)
+ return Collections.EMPTY_SET;
+ Set<T> result = new TreeSet<T>();
+ for (Field f : fields) {
+ if (mods == f.getModifiers() + && (t ==
Object.class || t.isAssignableFrom(f.getType()))
+ && canReflect(f)) {
+ try {
+ result.add((T)f.get(null));
+ } catch (IllegalArgumentException e) {
+ } catch (IllegalAccessException e) {
+ }
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Affirms if the given member is selected for reflection. The
decision is
+ * based on the following truth table on both the class-level and
+ * member-level annotation (null annotation represents MAYBE)
+ * + * Class member + * MAYBE MAYBE YES
+ * MAYBE YES YES
+ * MAYBE NO NO
+ *
+ * YES MAYBE YES
+ * YES YES YES
+ * YES NO NO
+ *
+ * NO YES YES
+ * NO MAYBE NO
+ * NO NO NO + * + */ + static boolean
canReflect(Reflectable cls, Reflectable member) {
+ if (cls == null || cls.value()) {
+ return member == null || member.value() == true;
+ } else {
+ return member != null && member.value() == true;
+ }
+ }
+ + /**
+ * Affirms if the original declaration the given field is annotated
+ * for reflection. + */
+ static boolean canReflect(Field field) {
+ Class cls = field.getDeclaringClass();
+ return
canReflect((Reflectable)cls.getAnnotation(Reflectable.class),
+ field.getAnnotation(Reflectable.class));
+ }
+ + /**
+ * Affirms if the original declaration the given method is annotated
+ * for reflection. + */
+ static boolean canReflect(Method method) {
+ Class cls = getDeclaringClass(method);
+ if (cls != method.getDeclaringClass())
+ method = getDeclaringMethod(cls, method);
+ return
canReflect((Reflectable)cls.getAnnotation(Reflectable.class),
+ method.getAnnotation(Reflectable.class));
+ }
+ + /**
+ * Gets the declaring class of the given method signature but
also checks
+ * if the method is declared in an interface. If yes, then
returns the
+ * interface. + */
+ public static Class getDeclaringClass(Method m) {
+ if (m == null)
+ return null;
+ Class cls = m.getDeclaringClass();
+ Class[] intfs = cls.getInterfaces();
+ for (Class intf : intfs) {
+ if (getDeclaringMethod(intf, m) != null)
+ cls = intf;
+ }
+ return cls;
+ }
+ + /**
+ * Gets the method in the given class that has the same signature
of the
+ * given method, if exists. Otherwise, null.
+ */
+ public static Method getDeclaringMethod(Class c, Method m) {
+ try {
+ Method m0 = c.getMethod(m.getName(), m.getParameterTypes());
+ return m0;
+ } catch (Exception e) {
+ return null;
+ }
+ } }
Modified:
openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/kernel/Filters.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/kernel/Filters.java?rev=743396&r1=743395&r2=743396&view=diff
==============================================================================
---
openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/kernel/Filters.java
(original)
+++
openjpa/trunk/openjpa-kernel/src/main/java/org/apache/openjpa/kernel/Filters.java
Wed Feb 11 16:57:26 2009
@@ -247,12 +247,23 @@
if (type.isAssignableFrom(o.getClass()))
return o;
- // the only non-numeric conversions we do are to string, or from
+ // the non-numeric conversions we do are to string, or from
// string/char to number, or calendar/date
+ // String to Boolean
+ // String to Integer
boolean num = o instanceof Number;
if (!num) {
if (type == String.class)
return o.toString();
+ else if (type == Boolean.class && o instanceof String)
+ return Boolean.valueOf(o.toString());
+ else if (type == Integer.class && o instanceof String)
+ try {
+ return new Integer(o.toString());
+ } catch (NumberFormatException e) {
+ throw new
ClassCastException(_loc.get("cant-convert", o,
+ o.getClass(), type).getMessage());
+ }
else if (type == Character.class) {
String str = o.toString();
if (str != null && str.length() == 1)
Modified:
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/AbstractProductDerivation.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/AbstractProductDerivation.java?rev=743396&r1=743395&r2=743396&view=diff
==============================================================================
---
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/AbstractProductDerivation.java
(original)
+++
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/AbstractProductDerivation.java
Wed Feb 11 16:57:26 2009
@@ -19,7 +19,9 @@
package org.apache.openjpa.lib.conf;
import java.io.File;
+import java.util.Collections;
import java.util.List;
+import java.util.Set;
/**
* Abstract no-op product derivation for easy extension.
@@ -85,4 +87,8 @@
public void beforeConfigurationClose(Configuration conf) {
}
+ + public Set<String> getSupportedQueryHints() {
+ return Collections.EMPTY_SET;
+ }
}
Modified:
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/ProductDerivation.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/ProductDerivation.java?rev=743396&r1=743395&r2=743396&view=diff
==============================================================================
---
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/ProductDerivation.java
(original)
+++
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/ProductDerivation.java
Wed Feb 11 16:57:26 2009
@@ -21,6 +21,7 @@
import java.io.File;
import java.io.IOException;
import java.util.List;
+import java.util.Set;
/**
* Hooks for deriving products with additional functionality.
@@ -157,4 +158,13 @@
* @since 0.9.7
*/
public void beforeConfigurationClose(Configuration conf);
+ + + /**
+ * Return set of Query hint keys recognized by this receiver.
+ * + * @since 2.0.0
+ */
+ public Set<String> getSupportedQueryHints();
+
}
Modified:
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/ProductDerivations.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/ProductDerivations.java?rev=743396&r1=743395&r2=743396&view=diff
==============================================================================
---
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/ProductDerivations.java
(original)
+++
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/conf/ProductDerivations.java
Wed Feb 11 16:57:26 2009
@@ -29,6 +29,8 @@
import java.util.List;
import java.util.Map;
import java.util.MissingResourceException;
+import java.util.Set;
+import java.util.TreeSet;
import org.apache.commons.lang.StringUtils;
import org.apache.openjpa.lib.util.J2DoPrivHelper;
@@ -434,6 +436,19 @@
collection.add(fqLoc);
}
}
+ + + public static Set<String> getSupportedQueryHints() {
+ Set<String> result = new TreeSet<String>();
+ // most specific to least
+ for (int i = _derivations.length - 1; i >= 0; i--) {
+ Set<String> members =
_derivations[i].getSupportedQueryHints();
+ if (members != null || !members.isEmpty())
+ result.addAll(members);
+ }
+ return result;
+ }
+
/**
* Compare {...@link ProductDerivation}s.
Added:
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/util/Reflectable.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/util/Reflectable.java?rev=743396&view=auto
==============================================================================
---
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/util/Reflectable.java
(added)
+++
openjpa/trunk/openjpa-lib/src/main/java/org/apache/openjpa/lib/util/Reflectable.java
Wed Feb 11 16:57:26 2009
@@ -0,0 +1,25 @@
+package org.apache.openjpa.lib.util;
+
+import static java.lang.annotation.ElementType.FIELD;
+import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.TYPE;
+import static java.lang.annotation.RetentionPolicy.RUNTIME;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.Target;
+
+/**
+ * Annotates a getter method or field so {...@link Reflection reflection
+ * utility} to control whether the annotated member is recorded
during scanning + * for bean-style method or field.
+ * + * @author Pinaki Poddar
+ * + * @since 2.0.0
+ *
+ */
+...@target({TYPE, METHOD, FIELD})
+...@retention(RUNTIME)
+public @interface Reflectable {
+ boolean value() default true;
+}
Added:
openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/conf/TestQueryHints.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/conf/TestQueryHints.java?rev=743396&view=auto
==============================================================================
---
openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/conf/TestQueryHints.java
(added)
+++
openjpa/trunk/openjpa-persistence-jdbc/src/test/java/org/apache/openjpa/conf/TestQueryHints.java
Wed Feb 11 16:57:26 2009
@@ -0,0 +1,167 @@
+/*
+ * 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.conf;
+
+import javax.persistence.EntityManager;
+import javax.persistence.Query;
+
+import org.apache.openjpa.jdbc.sql.OracleDictionary;
+import org.apache.openjpa.kernel.QueryHints;
+import org.apache.openjpa.persistence.HintHandler;
+import org.apache.openjpa.persistence.OpenJPAPersistence;
+import org.apache.openjpa.persistence.OpenJPAQuery;
+import org.apache.openjpa.persistence.test.SingleEMFTestCase;
+
+/**
+ * Tests JPA 2.0 API methods {...@link Query#getSupportedHints()} and +
* {...@link Query#getHints()}. + * + * @author Pinaki Poddar
+ *
+ */
+public class TestQueryHints extends SingleEMFTestCase {
+ EntityManager em;
+ OpenJPAQuery query;
+ + public void setUp() {
+ super.setUp((Object[])null);
+ em = emf.createEntityManager();
+ String sql = "select * from Person";
+ query = OpenJPAPersistence.cast(em.createNativeQuery(sql));
+ }
+ + public void testSupportedHintsContainProductDerivationHints() {
+ assertSupportedHint(OracleDictionary.SELECT_HINT, true);
+ }
+ + public void testSupportedHintsContainFetchPlanHints() {
+ assertSupportedHint("openjpa.FetchPlan.LockTimeout", true);
+ }
+
+ public void
testSupportedHintsIgnoresSomeFetchPlanBeanStyleProperty() {
+ assertSupportedHint("openjpa.FetchPlan.QueryResultCache",
false);
+ }
+ + public void testSupportedHintsContainQueryProperty() {
+ assertSupportedHint("openjpa.Subclasses", true);
+ }
+ + public void testSupportedHintsContainKernelQueryHints() {
+ assertSupportedHint(QueryHints.HINT_IGNORE_PREPARED_QUERY,
true);
+ }
+ + public void testSupportedHintsContainJPAQueryHints() {
+ assertSupportedHint("javax.persistence.query.timeout", true);
+ }
+ + public void testUnrecognizedKeyIsIgnored() {
+ String unrecognizedKey = "acme.org.hint.SomeThingUnknown";
+ query.setHint(unrecognizedKey, "xyz");
+ assertFalse(query.getHints().containsKey(unrecognizedKey));
+
assertNull(query.getFetchPlan().getDelegate().getHint(unrecognizedKey));
+ }
+ + public void testRecognizedKeyIsNotRecordedButAvailable() {
+ String recognizedKey = "openjpa.some.derivation.hint";
+ query.setHint(recognizedKey, "abc");
+ assertFalse(query.getHints().containsKey(recognizedKey));
+ assertEquals("abc",
query.getFetchPlan().getDelegate().getHint(recognizedKey));
+ }
+
+ public void testSupportedKeyIsRecordedAndAvailable() {
+ String supportedKey = "openjpa.FetchPlan.FetchBatchSize";
+ query.setHint(supportedKey, 42);
+ assertTrue(query.getHints().containsKey(supportedKey));
+ assertEquals(42, query.getFetchPlan().getFetchBatchSize());
+ }
+ + public void testSupportedKeyWrongValue() {
+ String supportedKey = "openjpa.FetchPlan.FetchBatchSize";
+ short goodValue = (short)42;
+ float badValue = 57.9f;
+ query.setHint(supportedKey, goodValue);
+ assertTrue(query.getHints().containsKey(supportedKey));
+ assertEquals(goodValue,
query.getFetchPlan().getFetchBatchSize());
+ + try {
+ query.setHint(supportedKey, badValue);
+ fail("Expected to fail to set " + supportedKey + " hint
to " + badValue);
+ } catch (IllegalArgumentException e) {
+ // good
+ }
+ }
+ + public void testSupportedKeyIntegerValueConversion() {
+ String supportedKey = "openjpa.hint.OptimizeResultCount";
+ String goodValue = "57";
+ int badValue = -3;
+ query.setHint(supportedKey, goodValue);
+ assertTrue(query.getHints().containsKey(supportedKey));
+ assertEquals(57,
query.getFetchPlan().getDelegate().getHint(supportedKey));
+ + try {
+ query.setHint(supportedKey, badValue);
+ fail("Expected to fail to set " + supportedKey + " hint
to " + badValue);
+ } catch (IllegalArgumentException e) {
+ // good
+ }
+ }
+
+ public void testSupportedKeyBooleanValueConversion() {
+ String supportedKey = QueryHints.HINT_IGNORE_PREPARED_QUERY;
+ String goodValue = "true";
+ query.setHint(supportedKey, goodValue);
+ assertTrue(query.getHints().containsKey(supportedKey));
+ assertEquals(true,
query.getFetchPlan().getDelegate().getHint(supportedKey));
+ + goodValue = "false";
+ query.setHint(supportedKey, goodValue);
+ assertTrue(query.getHints().containsKey(supportedKey));
+ assertEquals(false,
query.getFetchPlan().getDelegate().getHint(supportedKey));
+ }
+ + public void testJPAHintSetsFetchPlan() {
+ String jpaKey = "javax.persistence.query.timeout";
+ query.setHint(jpaKey, 5671);
+ assertEquals(5671, query.getFetchPlan().getLockTimeout());
+ }
+ + public void testParts() {
+ HintHandler.HintKeyComparator test = new
HintHandler.HintKeyComparator();
+ assertEquals(0, test.countDots("a"));
+ assertEquals(1, test.countDots("a.b"));
+ assertEquals(2, test.countDots("a.b.c"));
+ assertEquals(3, test.countDots("a.b.c.d"));
+ assertEquals(4, test.countDots("a.b.c.d."));
+ assertEquals(1, test.countDots("."));
+ assertEquals(0, test.countDots(""));
+ assertEquals(0, test.countDots(null));
+ }
+ + void assertSupportedHint(String hint, boolean contains) {
+ if (contains)
+ assertTrue("Expeceted suppoerted hint [" + hint + "]",
+ query.getSupportedHints().contains(hint));
+ else
+ assertFalse("Unexpeceted suppoerted hint [" + hint + "]",
+ query.getSupportedHints().contains(hint));
+ }
+ + +}
Modified:
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/FetchPlan.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/FetchPlan.java?rev=743396&r1=743395&r2=743396&view=diff
==============================================================================
---
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/FetchPlan.java
(original)
+++
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/FetchPlan.java
Wed Feb 11 16:57:26 2009
@@ -22,6 +22,7 @@
import javax.persistence.LockModeType;
import org.apache.openjpa.kernel.FetchConfiguration;
+import org.apache.openjpa.lib.util.Reflectable;
import org.apache.openjpa.meta.FetchGroup;
/**
@@ -88,6 +89,7 @@
*
* @since 1.0.0
*/
+ @Reflectable(false)
public boolean getQueryResultCacheEnabled();
/**
@@ -102,6 +104,7 @@
/**
* @deprecated use {...@link #getQueryResultCacheEnabled()} instead.
*/
+ @Reflectable(false)
public boolean getQueryResultCache();
/**
@@ -293,5 +296,6 @@
* @deprecated cast to {...@link FetchPlanImpl} instead. This
* method pierces the published-API boundary, as does the SPI cast.
*/
+ @Reflectable(false)
public org.apache.openjpa.kernel.FetchConfiguration getDelegate();
}
Added:
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/HintHandler.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/HintHandler.java?rev=743396&view=auto
==============================================================================
---
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/HintHandler.java
(added)
+++
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/HintHandler.java
Wed Feb 11 16:57:26 2009
@@ -0,0 +1,365 @@
+package org.apache.openjpa.persistence;
+
+import static
org.apache.openjpa.kernel.QueryHints.HINT_IGNORE_PREPARED_QUERY;
+import static
org.apache.openjpa.kernel.QueryHints.HINT_INVALIDATE_PREPARED_QUERY;
+import static org.apache.openjpa.kernel.QueryHints.HINT_RESULT_COUNT;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.TreeSet;
+
+import org.apache.openjpa.conf.OpenJPAConfiguration;
+import org.apache.openjpa.enhance.Reflection;
+import org.apache.openjpa.kernel.FetchConfiguration;
+import org.apache.openjpa.kernel.Filters;
+import org.apache.openjpa.kernel.exps.AggregateListener;
+import org.apache.openjpa.kernel.exps.FilterListener;
+import org.apache.openjpa.lib.conf.ProductDerivation;
+import org.apache.openjpa.lib.conf.ProductDerivations;
+import org.apache.openjpa.lib.log.Log;
+import org.apache.openjpa.lib.util.Localizer;
+import org.apache.openjpa.lib.util.StringDistance;
+
+
+/**
+ * Manages query hint keys and handles their values on behalf of a
owning
+ * {...@link QueryImpl}. Uses specific knowledge of hint keys declared in
+ * different parts of the system.
+ * + * This receiver collects hint keys from different parts of the
system. The
+ * keys are implicitly or explicitly declared by several different
mechanics.
+ * This receiver sets the values on behalf of a owning {...@link QueryImpl}
+ * based on the its specific knowledge of these keys.
+ * + * The hint keys from following sources are collected and
handled: + * + * 1. {...@link org.apache.openjpa.kernel.QueryHints}
interface declares hint keys
+ * as public static final fields. These fields are collected by
reflection.
+ * The values are handled by invoking methods on the owning {...@link
QueryImpl}
+ * + * 2. Some hint keys are collected from bean-style property
names of {...@link + * JDBCFetchPlan} by {...@link
Reflection#getBeanStylePropertyNames(Class) + * reflection} and
prefixed with <code>openjpa.FetchPlan</code>. + * Their values are
used to set the corresponding property of {...@link + * FetchPlan} via
{...@link #hintToSetter(FetchPlan, String, Object) reflection}
+ * + * 3. Currently defined <code>javax.persistence.*</code>
hint keys have + * a equivalent counterpart to one of these
FetchPlan keys. + * The JPA keys are mapped to equivalent FetchPlan
hint keys.
+ * + * 4. Some keys directly invoke setters or add listeners to
the owning + * {...@link QueryImpl}. These hint keys are statically
declared in + * this receiver itself. + * + * 5.
ProductDerivation may introduce their own query hint keys via {...@link +
* ProductDerivation#getSupportedQueryHints()}. Their values are set
in the + * {...@link FetchConfiguration#setHint(String, Object)}
+ * + * A hint key is classified into one of the following three
categories:
+ * + * 1. Supported: A key is known to this receiver as collected
from different + * parts of the system. The value of a supported
key is recorded and + * available via {...@link #getHints()} method.
+ * 2. Recognized: A key is not known to this receiver but has a
prefix which
+ * is known to this receiver. The value of a recognized key is
not recorded + * but its value is available via {...@link
FetchConfiguration#getHint(String)}
+ * 3. Unrecognized: A key is neither supported nor recognized. The
value of a + * unrecognized key is neither recorded nor set anywhere.
+ * + * If an incompatible value is supplied for a supported key, a
non-fatal
+ * {...@link ArgumentException} is raised.
+ * + * @author Pinaki Poddar
+ *
+ * @since 2.0.0
+ * + * @nojavadoc
+ */
+public class HintHandler {
+ private final QueryImpl owner;
+ private Map<String, Object> _hints;
+ private Set<String> _supportedKeys;
+ private Set<String> _supportedPrefixes;
+ + static final String PREFIX_JPA = "javax.persistence.";
+ static final String PREFIX_FETCHPLAN = "openjpa.FetchPlan.";
+ + // These keys are directly handled in {...@link QueryImpl} class.
+ // Declaring a public static final String variable in this class
will + // make it register as a supported hint key
+ // if you do not want that then annotate as {...@link
Reflectable(false)}.
+ public static final String HINT_SUBCLASSES = "openjpa.Subclasses";
+ public static final String HINT_FILTER_LISTENER =
"openjpa.FilterListener";
+ public static final String HINT_FILTER_LISTENERS = +
"openjpa.FilterListeners";
+ public static final String HINT_AGGREGATE_LISTENER = +
"openjpa.AggregateListener";
+ public static final String HINT_AGGREGATE_LISTENERS = +
"openjpa.AggregateListeners";
+ + // JPA Specification 2.0 keys are mapped to equivalent
FetchPlan keys
+ public static Map<String,String> _jpaKeys = new TreeMap<String,
String>();
+ static {
+ _jpaKeys.put(addPrefix(PREFIX_JPA, "query.timeout"),
+ addPrefix(PREFIX_FETCHPLAN, "LockTimeout"));
+ }
+ + private static final String DOT = ".";
+ private static final String BLANK = "";
+ private static final Localizer _loc = Localizer.forPackage(
+ HintHandler.class);
+ + public HintHandler(QueryImpl impl) {
+ owner = impl;
+ }
+ + /**
+ * Gets all the recorded hint keys and their values.
+ */
+ @SuppressWarnings("unchecked")
+ public Map<String, Object> getHints() {
+ return _hints == null ? Collections.EMPTY_MAP + :
Collections.unmodifiableMap(_hints);
+ }
+ + /**
+ * Record a key-value pair only only if the given key is supported.
+ * + * @return FALSE if the key is unrecognized. +
* null (i.e. MAY BE) if the key is recognized, but not supported.
+ * TRUE if the key is supported.
+ */
+ public Boolean record(String hint, Object value) {
+ if (hint == null)
+ return Boolean.FALSE;
+ if (isSupported(hint)) {
+ if (_hints == null)
+ _hints = new TreeMap<String, Object>();
+ _hints.put(hint, value);
+ return Boolean.TRUE;
+ }
+ + Log log =
owner.getDelegate().getBroker().getConfiguration()
+ .getLog(OpenJPAConfiguration.LOG_RUNTIME);
+ String possible =
StringDistance.getClosestLevenshteinDistance(hint, +
getSupportedHints());
+ if (log.isWarnEnabled()) {
+ log.warn(_loc.get("bad-query-hint", hint, possible));
+ }
+ return (isKnownHintPrefix(hint)) ? null : Boolean.FALSE;
+ }
+ + /**
+ * Gets all the supported hint keys. The set of supported hint
keys is
+ * statically determined by collecting hint keys from the
ProductDerivations
+ * and reflecting upon some of the known classes.
+ */
+ public Set<String> getSupportedHints() {
+ if (_supportedKeys == null) {
+ _supportedKeys = new TreeSet<String>(new
HintKeyComparator());
+ _supportedPrefixes = new TreeSet<String>();
+ +
_supportedKeys.addAll(Reflection.getFieldValues(
+ org.apache.openjpa.kernel.QueryHints.class,
+ Modifier.PUBLIC | Modifier.STATIC | Modifier.FINAL,
+ String.class));
+
+ _supportedKeys.addAll(addPrefix(PREFIX_FETCHPLAN,
+ Reflection.getBeanStylePropertyNames(
+ owner.getFetchPlan().getClass())));
+
+ _supportedKeys.addAll(_jpaKeys.keySet());
+
+ _supportedKeys.addAll(Reflection.getFieldValues(
+ HintHandler.class, + Modifier.PUBLIC |
Modifier.STATIC | Modifier.FINAL, + String.class));
+
+
_supportedKeys.addAll(ProductDerivations.getSupportedQueryHints());
+ + for (String key : _supportedKeys) {
+ _supportedPrefixes.add(getPrefixOf(key));
+ }
+ }
+ return _supportedKeys;
+ }
+ + /**
+ * Add a hint key to the set of supported hint keys.
+ */
+ public void addHintKey(String key) {
+ getSupportedHints().add(key);
+ _supportedPrefixes.add(getPrefixOf(key));
+ }
+ + public Set<String> getKnownPrefixes() {
+ getSupportedHints();
+ return _supportedPrefixes;
+ }
+ + /**
+ * Affirms the given key matches one of the supported keys.
+ */
+ public boolean isSupported(String key) {
+ return getSupportedHints().contains(key);
+ }
+ + /**
+ * Affirms the given key has a prefix that matches with any of
the + * supported prefixes.
+ */
+ public boolean isSupportedPrefix(String key) {
+ return getKnownPrefixes().contains(getPrefixOf(key));
+ }
+ + static Set<String> addPrefix(String prefix, Set<String>
original) {
+ Set<String> result = new TreeSet<String>();
+ String join = prefix.endsWith(DOT) ? BLANK : DOT;
+ for (String o : original)
+ result.add(prefix + join + o);
+ return result;
+ }
+ + static String addPrefix(String prefix, String original) {
+ String join = prefix.endsWith(DOT) ? BLANK : DOT;
+ return prefix + join + original;
+ }
+ + public static String removePrefix(String key, String prefix) {
+ if (prefix == null)
+ return key;
+ if (!prefix.endsWith(DOT))
+ prefix = prefix + DOT;
+ if (key != null && key.startsWith(prefix))
+ return key.substring(prefix.length());
+ return key;
+ }
+ + static String getPrefixOf(String key) {
+ int index = key == null ? -1 : key.indexOf(DOT);
+ return (index != -1) ? key.substring(0,index) : key;
+ }
+ + boolean isKnownHintPrefix(String key) {
+ String prefix = getPrefixOf(key);
+ return getKnownPrefixes().contains(prefix);
+ }
+ + public static boolean hasPrefix(String key, String prefix) {
+ if (key == null || prefix == null)
+ return false;
+ if (!prefix.endsWith(DOT))
+ prefix = prefix + DOT;
+ return key.startsWith(prefix);
+ }
+ + public void setHint(String key, Object value) {
+ Boolean record = record(key, value);
+ FetchConfiguration fetch =
owner.getDelegate().getFetchConfiguration();
+ ClassLoader loader =
owner.getDelegate().getBroker().getClassLoader();
+ if (record == Boolean.FALSE)
+ return;
+ if (record == null) {
+ fetch.setHint(key, value);
+ return;
+ }
+ try {
+ if (HINT_SUBCLASSES.equals(key)) {
+ if (value instanceof String)
+ value = Boolean.valueOf((String) value);
+ owner.setSubclasses(((Boolean) value).booleanValue());
+ } else if (HINT_FILTER_LISTENER.equals(key))
+
owner.addFilterListener(Filters.hintToFilterListener(value,
+ loader));
+ else if (HINT_FILTER_LISTENERS.equals(key)) {
+ FilterListener[] arr =
Filters.hintToFilterListeners(value, + loader);
+ for (int i = 0; i < arr.length; i++)
+ owner.addFilterListener(arr[i]);
+ } else if (HINT_AGGREGATE_LISTENER.equals(key))
+
owner.addAggregateListener(Filters.hintToAggregateListener(
+ value, loader));
+ else if (HINT_AGGREGATE_LISTENERS.equals(key)) {
+ AggregateListener[] arr =
Filters.hintToAggregateListeners(
+ value, loader);
+ for (int i = 0; i < arr.length; i++)
+ owner.addAggregateListener(arr[i]);
+ } else if (isFetchPlanHint(key)) {
+ hintToSetter(owner.getFetchPlan(),
+ getFetchPlanProperty(key), value);
+ } else if (HINT_RESULT_COUNT.equals(key)) {
+ int v = (Integer)Filters.convert(value, Integer.class);
+ if (v < 0)
+ throw new
ArgumentException(_loc.get("bad-query-hint-value",
+ key, value), null, null, false);
+ fetch.setHint(key, v);
+ } else if (HINT_INVALIDATE_PREPARED_QUERY.equals(key)) {
+ fetch.setHint(key, Filters.convert(value,
Boolean.class));
+ owner.invalidatePreparedQuery();
+ } else if (HINT_IGNORE_PREPARED_QUERY.equals(key)) {
+ fetch.setHint(key, Filters.convert(value,
Boolean.class));
+ owner.ignorePreparedQuery();
+ } else { // default + fetch.setHint(key,
value);
+ }
+ return;
+ } catch (IllegalArgumentException iae) {
+ throw new
ArgumentException(_loc.get("bad-query-hint-value", +
key, value), null, null, false);
+ } catch (ClassCastException ce) {
+ throw new
ArgumentException(_loc.get("bad-query-hint-value", +
key, ce.getMessage()), null, null, false);
+ } catch (Exception e) {
+ throw PersistenceExceptions.toPersistenceException(e);
+ }
+ }
+ + private boolean isFetchPlanHint(String key) {
+ return key.startsWith(PREFIX_FETCHPLAN) + ||
(_jpaKeys.containsKey(key) && isFetchPlanHint(_jpaKeys.get(key)));
+ }
+ + private String getFetchPlanProperty(String key) {
+ if (key.startsWith(PREFIX_FETCHPLAN))
+ return removePrefix(key, PREFIX_FETCHPLAN);
+ else if (_jpaKeys.containsKey(key))
+ return getFetchPlanProperty(_jpaKeys.get(key));
+ else
+ return key;
+ }
+ + private void hintToSetter(FetchPlan fetchPlan, String k,
Object value) {
+ if (fetchPlan == null || k == null)
+ return;
+
+ Method setter = Reflection.findSetter(fetchPlan.getClass(),
k, true);
+ Class paramType = setter.getParameterTypes()[0];
+ if (Enum.class.isAssignableFrom(paramType) && value
instanceof String)
+ value = Enum.valueOf(paramType, (String) value);
+
+ Filters.hintToSetter(fetchPlan, k, value);
+ }
+ + public static class HintKeyComparator implements
Comparator<String> {
+ public int compare(String s1, String s2) {
+ if (getPrefixOf(s1).equals(getPrefixOf(s2))) {
+ int n1 = countDots(s1);
+ int n2 = countDots(s2);
+ return (n1 == n2) ? s1.compareTo(s2) : (n1 - n2);
+ } else
+ return s1.compareTo(s2);
+ }
+ + public int countDots(String s) {
+ if (s == null || s.length() == 0)
+ return 0;
+ int index = s.indexOf(DOT);
+ return (index == -1) ? 0 :
countDots(s.substring(index+1)) + 1;
+ }
+ }
+}
Modified:
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/QueryImpl.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/QueryImpl.java?rev=743396&r1=743395&r2=743396&view=diff
==============================================================================
---
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/QueryImpl.java
(original)
+++
openjpa/trunk/openjpa-persistence/src/main/java/org/apache/openjpa/persistence/QueryImpl.java
Wed Feb 11 16:57:26 2009
@@ -18,8 +18,9 @@
*/
package org.apache.openjpa.persistence;
+import static
org.apache.openjpa.kernel.QueryLanguages.LANG_PREPARED_SQL;
+
import java.io.Serializable;
-import java.lang.reflect.Method;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.ArrayList;
@@ -41,15 +42,12 @@
import javax.persistence.TemporalType;
import org.apache.openjpa.conf.OpenJPAConfiguration;
-import org.apache.openjpa.enhance.Reflection;
import org.apache.openjpa.kernel.Broker;
import org.apache.openjpa.kernel.DelegatingQuery;
import org.apache.openjpa.kernel.DelegatingResultList;
import org.apache.openjpa.kernel.FetchConfiguration;
-import org.apache.openjpa.kernel.Filters;
import org.apache.openjpa.kernel.PreparedQuery;
import org.apache.openjpa.kernel.PreparedQueryCache;
-import org.apache.openjpa.kernel.QueryHints;
import org.apache.openjpa.kernel.QueryLanguages;
import org.apache.openjpa.kernel.QueryOperations;
import org.apache.openjpa.kernel.QueryStatistics;
@@ -63,8 +61,6 @@
import org.apache.openjpa.util.RuntimeExceptionTranslator;
import org.apache.openjpa.util.UserException;
-import static
org.apache.openjpa.kernel.QueryLanguages.LANG_PREPARED_SQL;
-
/**
* Implementation of {...@link Query} interface.
* @@ -85,6 +81,8 @@
private Map<String, Object> _named;
private Map<Integer, Object> _positional;
private String _id;
+
+ private final HintHandler _hintHandler;
/**
* Constructor; supply factory exception translator and delegate.
@@ -97,6 +95,7 @@
org.apache.openjpa.kernel.Query query) {
_em = em;
_query = new DelegatingQuery(query, ret);
+ _hintHandler = new HintHandler(this);
}
/**
@@ -254,7 +253,7 @@
}
private Object execute() {
- if (_query.getOperation() != QueryOperations.OP_SELECT)
+ if (!isNative() && _query.getOperation() !=
QueryOperations.OP_SELECT)
throw new
InvalidStateException(_loc.get("not-select-query", _query
.getQueryString()), null, null, false);
@@ -351,81 +350,8 @@
public OpenJPAQuery setHint(String key, Object value) {
_em.assertNotCloseInvoked();
- if (key == null)
- return this;
- if (!key.startsWith("openjpa.")) {
- _query.getFetchConfiguration().setHint(key, value);
- return this;
- }
- String k = key.substring("openjpa.".length());
-
- try {
- if ("Subclasses".equals(k)) {
- if (value instanceof String)
- value = Boolean.valueOf((String) value);
- setSubclasses(((Boolean) value).booleanValue());
- } else if ("FilterListener".equals(k))
- addFilterListener(Filters.hintToFilterListener(value,
_query
- .getBroker().getClassLoader()));
- else if ("FilterListeners".equals(k)) {
- FilterListener[] arr =
Filters.hintToFilterListeners(value,
- _query.getBroker().getClassLoader());
- for (int i = 0; i < arr.length; i++)
- addFilterListener(arr[i]);
- } else if ("AggregateListener".equals(k))
-
addAggregateListener(Filters.hintToAggregateListener(value,
- _query.getBroker().getClassLoader()));
- else if ("FilterListeners".equals(k)) {
- AggregateListener[] arr =
Filters.hintToAggregateListeners(
- value, _query.getBroker().getClassLoader());
- for (int i = 0; i < arr.length; i++)
- addAggregateListener(arr[i]);
- } else if (k.startsWith("FetchPlan.")) {
- k = k.substring("FetchPlan.".length());
- hintToSetter(getFetchPlan(), k, value);
- } else if (k.startsWith("hint.")) {
- if ("hint.OptimizeResultCount".equals(k)) {
- if (value instanceof String) {
- try {
- value = new Integer((String) value);
- } catch (NumberFormatException nfe) {
- }
- }
- if (!(value instanceof Number)
- || ((Number) value).intValue() < 0)
- throw new ArgumentException(_loc.get(
- "bad-query-hint-value", key, value),
null,
- null, false);
- _query.getFetchConfiguration().setHint(key, value);
- } else if
(QueryHints.HINT_INVALIDATE_PREPARED_QUERY.equals
- (key)) {
- _query.getFetchConfiguration().setHint(key,
(Boolean)value);
- invalidatePreparedQuery();
- } else if
(QueryHints.HINT_IGNORE_PREPARED_QUERY.equals(key)) {
- _query.getFetchConfiguration().setHint(key,
(Boolean)value);
- ignorePreparedQuery();
- } else {
- _query.getFetchConfiguration().setHint(key, value);
- }
- } else
- throw new
ArgumentException(_loc.get("bad-query-hint", key),
- null, null, false);
- return this;
- } catch (Exception e) {
- throw PersistenceExceptions.toPersistenceException(e);
- }
- }
-
- private void hintToSetter(FetchPlan fetchPlan, String k, Object
value) {
- if (fetchPlan == null || k == null)
- return;
-
- Method setter = Reflection.findSetter(fetchPlan.getClass(),
k, true);
- Class paramType = setter.getParameterTypes()[0];
- if (Enum.class.isAssignableFrom(paramType) && value
instanceof String)
- value = Enum.valueOf(paramType, (String) value);
-
- Filters.hintToSetter(fetchPlan, k, value);
+ _hintHandler.setHint(key, value);
+ return this;
}
public OpenJPAQuery setParameter(int position, Calendar value,
@@ -613,7 +539,7 @@
*/
//TODO: JPA 2.0 Hints that are not set to FetchConfiguration
public Map<String, Object> getHints() {
- return _query.getFetchConfiguration().getHints();
+ return _hintHandler.getHints();
}
public LockModeType getLockMode() {
@@ -622,8 +548,7 @@
}
public Set<String> getSupportedHints() {
- throw new UnsupportedOperationException(
- "JPA 2.0 - Method not yet implemented");
+ return _hintHandler.getSupportedHints();
}
public Query setLockMode(LockModeType lockMode) {
@@ -704,7 +629,7 @@
/**
* Remove this query from PreparedQueryCache. */
- private boolean invalidatePreparedQuery() {
+ boolean invalidatePreparedQuery() {
PreparedQueryCache cache = _em.getPreparedQueryCache();
if (cache == null)
return false;
@@ -716,7 +641,7 @@
* Ignores this query from PreparedQueryCache by recreating the
original
* query if it has been cached. */
- private void ignorePreparedQuery() {
+ void ignorePreparedQuery() {
PreparedQuery cached = _em.getPreparedQuery(_id);
if (cached == null)
return;
Modified:
openjpa/trunk/openjpa-persistence/src/main/resources/org/apache/openjpa/persistence/localizer.properties
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-persistence/src/main/resources/org/apache/openjpa/persistence/localizer.properties?rev=743396&r1=743395&r2=743396&view=diff
==============================================================================
---
openjpa/trunk/openjpa-persistence/src/main/resources/org/apache/openjpa/persistence/localizer.properties
(original)
+++
openjpa/trunk/openjpa-persistence/src/main/resources/org/apache/openjpa/persistence/localizer.properties
Wed Feb 11 16:57:26 2009
@@ -70,7 +70,7 @@
mult-results: Query returned multiple results: "{0}".
no-pos-named-params-mix: Cannot mix named and positional parameters
in query \
"{0}".
-bad-query-hint: "{0}" is not a recognized query hint.
+bad-query-hint: "{0}" is not a supported query hint. May be you meant
"{1}"?
bad-query-hint-value: Invalid value specified for query hint "{0}": {1}
detached: Cannot perform this operation on detached entity "{0}".
removed: Cannot perform this operation on removed entity "{0}".
Modified:
openjpa/trunk/openjpa-slice/src/main/java/org/apache/openjpa/slice/ProductDerivation.java
URL:
http://svn.apache.org/viewvc/openjpa/trunk/openjpa-slice/src/main/java/org/apache/openjpa/slice/ProductDerivation.java?rev=743396&r1=743395&r2=743396&view=diff
==============================================================================
---
openjpa/trunk/openjpa-slice/src/main/java/org/apache/openjpa/slice/ProductDerivation.java
(original)
+++
openjpa/trunk/openjpa-slice/src/main/java/org/apache/openjpa/slice/ProductDerivation.java
Wed Feb 11 16:57:26 2009
@@ -18,7 +18,9 @@
*/
package org.apache.openjpa.slice;
+import java.util.Collections;
import java.util.Map;
+import java.util.Set;
import org.apache.openjpa.conf.OpenJPAProductDerivation;
import org.apache.openjpa.lib.conf.AbstractProductDerivation;
@@ -98,4 +100,8 @@
log.warn(_loc.get("forced-set-config",
prefix+"."+v.getProperty(), forced));
}
+ + public Set<String> getSupportedQueryHints() {
+ return Collections.singleton(HINT_TARGET);
+ }
}
