[infinispan-commits] Infinispan SVN: r1263 - in trunk/query/src: main/java/org/infinispan/query/backend and 4 other directories.
infinispan-commits at lists.jboss.org
infinispan-commits at lists.jboss.org
Tue Dec 8 08:59:06 EST 2009
Author: navssurtani
Date: 2009-12-08 08:59:06 -0500 (Tue, 08 Dec 2009)
New Revision: 1263
Added:
trunk/query/src/main/java/org/infinispan/query/DefaultTransformer.java
trunk/query/src/main/java/org/infinispan/query/backend/KeyTransformationHandler.java
trunk/query/src/test/java/org/infinispan/query/backend/KeyTransformationHandlerTest.java
trunk/query/src/test/java/org/infinispan/query/blackbox/KeyTypeTest.java
trunk/query/src/test/java/org/infinispan/query/test/CustomKey.java
trunk/query/src/test/java/org/infinispan/query/test/CustomTransformer.java
Removed:
trunk/query/src/main/java/org/infinispan/query/KeyTransformationHandler.java
Modified:
trunk/query/src/main/java/org/infinispan/query/Transformable.java
trunk/query/src/main/java/org/infinispan/query/backend/QueryInterceptor.java
trunk/query/src/main/java/org/infinispan/query/impl/CacheQueryImpl.java
trunk/query/src/test/java/org/infinispan/query/blackbox/AbstractLocalQueryTest.java
Log:
Checking in code to allow custom-user keys. Code is tested and works.
Added: trunk/query/src/main/java/org/infinispan/query/DefaultTransformer.java
===================================================================
--- trunk/query/src/main/java/org/infinispan/query/DefaultTransformer.java (rev 0)
+++ trunk/query/src/main/java/org/infinispan/query/DefaultTransformer.java 2009-12-08 13:59:06 UTC (rev 1263)
@@ -0,0 +1,61 @@
+package org.infinispan.query;
+
+import org.infinispan.CacheException;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+/**
+ * Warning, slow as a dog, uses serialization to get a byte representation of a class. Implement your own!
+ *
+ * Repeat. It is HIGHLY RECOMMENDED THAT YOU PROVIDE YOUR OWN IMPLEMENTATION OF {@link org.infinispan.query.Transformer}
+ *
+ * @author Navin Surtani
+ */
+public class DefaultTransformer implements Transformer {
+ @Override
+ public Object fromString(String s) {
+ //"sz:[b1, b2, b3, b4, ... ]"
+ String sz = s.substring(0, s.indexOf(":"));
+ byte[] buf = new byte[Integer.parseInt(sz)];
+ String sub = s.substring(s.indexOf(":") + 1);
+ String tokens = sub.replace("[", "").replace("]", "");
+ StringTokenizer st = new StringTokenizer(tokens, ",");
+ int i = 0;
+ while (st.hasMoreTokens()) {
+ String token = st.nextToken().trim();
+ byte b = Byte.parseByte(token);
+ buf[i++] = b;
+ }
+
+ ObjectInputStream ois = null;
+ try {
+ ois = new ObjectInputStream(new ByteArrayInputStream(buf));
+ Object o = ois.readObject();
+ ois.close();
+ return o;
+ } catch (Exception e) {
+ throw new CacheException (e);
+ }
+
+ }
+
+ @Override
+ public String toString(Object customType) {
+ try {
+ ByteArrayOutputStream baos = new ByteArrayOutputStream();
+ ObjectOutputStream oos = new ObjectOutputStream(baos);
+ oos.writeObject(customType);
+ oos.close();
+ baos.close();
+ byte[] b = baos.toByteArray();
+ return b.length + ":" + Arrays.toString(b);
+ } catch (Exception e) {
+ throw new CacheException(e);
+ }
+ }
+}
Deleted: trunk/query/src/main/java/org/infinispan/query/KeyTransformationHandler.java
===================================================================
--- trunk/query/src/main/java/org/infinispan/query/KeyTransformationHandler.java 2009-12-07 18:22:16 UTC (rev 1262)
+++ trunk/query/src/main/java/org/infinispan/query/KeyTransformationHandler.java 2009-12-08 13:59:06 UTC (rev 1263)
@@ -1,99 +0,0 @@
-package org.infinispan.query;
-
-import org.infinispan.util.Util;
-import org.infinispan.CacheException;
-
-/**
- * This transforms arbitrary keys to a String which can be used by Lucene as a document identifier, and vice versa.
- * <p />
- * There are 2 approaches to doing so; one for SimpleKeys: Java primitives (and their object wrappers) and Strings,
- * and one for custom, user-defined types that could be used as keys.
- * <p />
- * For SimpleKeys, users don't need to do anything, these keys are automatically transformed by this class.
- * <p />
- * For user-defined keys, only types annotated with @Transformable, and declaring an appropriate {@link org.infinispan.query.Transformer}
- * implementation, are supported.
- *
- * @author Manik Surtani
- * @since 4.0
- * @see org.infinispan.query.Transformable
- * @see org.infinispan.query.Transformer
- */
-public class KeyTransformationHandler {
- public static Object stringToKey(String s) {
- char type = s.charAt(0);
- switch (type) {
- case 'S':
- // this is a normal String
- return s.substring(2);
- case 'I':
- // This is an Integer
- return Integer.parseInt(s.substring(2));
- case 'T':
- // this is a custom transformable.
- int indexOfSecondDelimiter = s.indexOf(":", 2);
- String transformerClassName = s.substring(2, indexOfSecondDelimiter);
- String keyAsString = s.substring(indexOfSecondDelimiter + 1);
- Transformer t = null;
- // try and locate class
- try {
- t = (Transformer) Util.getInstance(transformerClassName);
- } catch (Exception e) {
- // uh oh, cannot load this class! What now?
- throw new CacheException(e);
- }
-
- return t.fromString(keyAsString);
- }
- throw new CacheException("Unknown type metadata " + type);
- }
-
- public static String keyToString(Object key) {
- if (validKey(key)) {
- // this string should be in the format of
- // "<TYPE>:(TRANSFORMER):<KEY>"
- // e.g.:
- // "S:my string key"
- // "I:75"
- // "D:5.34"
- // "B:f"
- // "T:com.myorg.MyTransformer:STRING_GENERATED_BY_MY_TRANSFORMER"
-
- char prefix = ' ';
- if (key instanceof String)
- prefix = 'S';
- else if (key instanceof Integer)
- prefix = 'I';
- else if (key instanceof Boolean)
- prefix = 'B';
- /// etc etc etc
-
- return prefix + ":" + key;
- }
- else
- throw new IllegalArgumentException("Indexing only works with entries keyed on Strings - you passed in a " + key.getClass().toString());
- }
-
- private static boolean validKey(Object key) {
- // for now we just support Strings and bypass the rest of the logic!
- if (true) return key instanceof String;
-
- // we support String and JDK primitives and their wrappers.
- if (key instanceof String ||
- key instanceof Integer ||
- key instanceof Long ||
- key instanceof Float ||
- key instanceof Double ||
- key instanceof Boolean ||
- key instanceof Short ||
- key instanceof Byte ||
- key instanceof Character
- )
- return true;
- if (key.getClass().isAnnotationPresent(Transformable.class))
- return true;
-
- return false;
- }
-
-}
Modified: trunk/query/src/main/java/org/infinispan/query/Transformable.java
===================================================================
--- trunk/query/src/main/java/org/infinispan/query/Transformable.java 2009-12-07 18:22:16 UTC (rev 1262)
+++ trunk/query/src/main/java/org/infinispan/query/Transformable.java 2009-12-08 13:59:06 UTC (rev 1263)
@@ -14,5 +14,5 @@
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Transformable {
- Class<? extends Transformer> transformer();
+ Class<? extends Transformer> transformer() default DefaultTransformer.class;
}
Copied: trunk/query/src/main/java/org/infinispan/query/backend/KeyTransformationHandler.java (from rev 1222, trunk/query/src/main/java/org/infinispan/query/KeyTransformationHandler.java)
===================================================================
--- trunk/query/src/main/java/org/infinispan/query/backend/KeyTransformationHandler.java (rev 0)
+++ trunk/query/src/main/java/org/infinispan/query/backend/KeyTransformationHandler.java 2009-12-08 13:59:06 UTC (rev 1263)
@@ -0,0 +1,169 @@
+package org.infinispan.query.backend;
+
+import org.infinispan.util.Util;
+import org.infinispan.CacheException;
+import org.infinispan.query.Transformer;
+import org.infinispan.query.Transformable;
+
+/**
+ * This transforms arbitrary keys to a String which can be used by Lucene as a document identifier, and vice versa.
+ * <p/>
+ * There are 2 approaches to doing so; one for SimpleKeys: Java primitives (and their object wrappers) and Strings, and
+ * one for custom, user-defined types that could be used as keys.
+ * <p/>
+ * For SimpleKeys, users don't need to do anything, these keys are automatically transformed by this class.
+ * <p/>
+ * For user-defined keys, only types annotated with @Transformable, and declaring an appropriate {@link
+ * org.infinispan.query.Transformer} implementation, are supported.
+ *
+ * @author Manik Surtani
+ * @see org.infinispan.query.Transformable
+ * @see org.infinispan.query.Transformer
+ * @since 4.0
+ */
+public class KeyTransformationHandler {
+ public static Object stringToKey(String s) {
+ char type = s.charAt(0);
+ switch (type) {
+ case 'S':
+ // this is a normal String, but NOT a SHORT. For short see case 'x'.
+ return s.substring(2);
+ case 'I':
+ // This is an Integer
+ return Integer.parseInt(s.substring(2));
+ case 'Y':
+ // This is a BYTE
+ return Byte.parseByte(s.substring(2));
+ case 'L':
+ // This is a Long
+ return Long.parseLong(s.substring(2));
+ case 'X':
+ // This is a SHORT
+ return Short.parseShort(s.substring(2));
+ case 'D':
+ // This is a Double
+ return Double.parseDouble(s.substring(2));
+ case 'F':
+ // This is a Float
+ return Float.parseFloat(s.substring(2));
+ case 'B':
+ // This is a Boolean. This is NOT the case for a BYTE. For a BYTE, see case 'y'.
+ return Boolean.parseBoolean(s.substring(2));
+ case 'C':
+ // This is a Character
+ return s.charAt(2);
+ case 'T':
+ // this is a custom transformable.
+ int indexOfSecondDelimiter = s.indexOf(":", 2);
+ String transformerClassName = s.substring(2, indexOfSecondDelimiter);
+ String keyAsString = s.substring(indexOfSecondDelimiter + 1);
+ Transformer t;
+ // try and locate class
+ try {
+ t = (Transformer) Util.getInstance(transformerClassName);
+ } catch (Exception e) {
+ // uh oh, cannot load this class! What now?
+ throw new CacheException(e);
+ }
+
+ return t.fromString(keyAsString);
+ }
+ throw new CacheException("Unknown type metadata " + type);
+ }
+
+ public static String keyToString(Object key) {
+ // this string should be in the format of
+ // "<TYPE>:(TRANSFORMER):<KEY>"
+ // e.g.:
+ // "S:my string key"
+ // "I:75"
+ // "D:5.34"
+ // "B:f"
+ // "T:com.myorg.MyTransformer:STRING_GENERATED_BY_MY_TRANSFORMER"
+
+ char prefix = ' ';
+
+ // First going to check if the key is a primitive or a String. Otherwise, check if it's a transformable.
+ // If none of those conditions are satisfied, we'll throw an Exception.
+
+ if (isStringOrPrimitive(key)) {
+ // Using 'X' for Shorts and 'Y' for Bytes because 'S' is used for Strings and 'B' is being used for Booleans.
+
+
+ if (key instanceof String)
+ prefix = 'S';
+ else if (key instanceof Integer)
+ prefix = 'I';
+ else if (key instanceof Boolean)
+ prefix = 'B';
+ else if (key instanceof Long)
+ prefix = 'L';
+ else if (key instanceof Float)
+ prefix = 'F';
+ else if (key instanceof Double)
+ prefix = 'D';
+ else if (key instanceof Short)
+ prefix = 'X';
+ else if (key instanceof Byte)
+ prefix = 'Y';
+ else if (key instanceof Character)
+ prefix = 'C';
+
+ return prefix + ":" + key;
+
+ } else if (isTransformable(key)) {
+ // There is a bit more work to do for this case.
+ prefix = 'T';
+
+ System.out.println("key class is: - " + key.getClass());
+ // Do the transformer casting
+
+ // Try and get the @Transformable annotation.
+ Transformable transformableAnnotation = key.getClass().getAnnotation(Transformable.class);
+
+ // Use that to find the class that is being used as the transformer.
+ Class<? extends Transformer> transformerClass = transformableAnnotation.transformer();
+ Transformer t;
+ try {
+ t = Util.getInstance(transformerClass);
+ }
+ catch (Exception e) {
+ throw new CacheException(e);
+ }
+ //Get the name of the Class that has been used. Add it to the toString() method that has to be defined
+ // in the Transformer implementation
+ String subKey = key.getClass().getName() + ":" + t.toString(key);
+ // We've built the second part of the String and now need to add that bit to the prefix for our complete keyString
+ // for lucene.
+ return prefix + ":" + subKey;
+
+ } else
+ throw new IllegalArgumentException("Indexing only works with entries keyed on Strings, primitives " +
+ "and classes that have the @Transformable annotation - you passed in a " + key.getClass().toString());
+ }
+
+ private static boolean isStringOrPrimitive(Object key) {
+
+ // we support String and JDK primitives and their wrappers.
+ if (key instanceof String ||
+ key instanceof Integer ||
+ key instanceof Long ||
+ key instanceof Float ||
+ key instanceof Double ||
+ key instanceof Boolean ||
+ key instanceof Short ||
+ key instanceof Byte ||
+ key instanceof Character
+ )
+ return true;
+
+ return false;
+ }
+
+ private static Boolean isTransformable(Object key) {
+ // returns true if the Transformable annotation is present on the custom key class.
+ return key.getClass().isAnnotationPresent(Transformable.class);
+
+ }
+
+}
Property changes on: trunk/query/src/main/java/org/infinispan/query/backend/KeyTransformationHandler.java
___________________________________________________________________
Name: svn:keywords
+ Id Revision
Name: svn:eol-style
+ LF
Modified: trunk/query/src/main/java/org/infinispan/query/backend/QueryInterceptor.java
===================================================================
--- trunk/query/src/main/java/org/infinispan/query/backend/QueryInterceptor.java 2009-12-07 18:22:16 UTC (rev 1262)
+++ trunk/query/src/main/java/org/infinispan/query/backend/QueryInterceptor.java 2009-12-08 13:59:06 UTC (rev 1263)
@@ -13,7 +13,7 @@
import org.infinispan.factories.annotations.Inject;
import org.infinispan.interceptors.base.CommandInterceptor;
import org.infinispan.marshall.MarshalledValue;
-import static org.infinispan.query.KeyTransformationHandler.keyToString;
+import static org.infinispan.query.backend.KeyTransformationHandler.keyToString;
import javax.transaction.TransactionManager;
import java.io.Serializable;
@@ -133,9 +133,7 @@
Set<Class<?>> classes = searchFactory.getDocumentBuildersIndexedEntities().keySet();
for (Class c : classes) {
Serializable id = null;
-
if (log.isDebugEnabled()) log.debug("Clearing indexes for class: - " + c);
-
searchFactory.getWorker().performWork(new Work<Object>(c, id, WorkType.PURGE_ALL),
new TransactionalEventTransactionContext(transactionManager));
}
Modified: trunk/query/src/main/java/org/infinispan/query/impl/CacheQueryImpl.java
===================================================================
--- trunk/query/src/main/java/org/infinispan/query/impl/CacheQueryImpl.java 2009-12-07 18:22:16 UTC (rev 1262)
+++ trunk/query/src/main/java/org/infinispan/query/impl/CacheQueryImpl.java 2009-12-08 13:59:06 UTC (rev 1263)
@@ -47,7 +47,7 @@
import org.infinispan.Cache;
import org.infinispan.query.CacheQuery;
import org.infinispan.query.QueryIterator;
-import org.infinispan.query.KeyTransformationHandler;
+import org.infinispan.query.backend.KeyTransformationHandler;
import org.infinispan.query.backend.IndexSearcherCloser;
import java.io.IOException;
@@ -305,6 +305,7 @@
// Loop through my list of keys and get it from the cache. Put each object that I get into a separate list.
List<Object> listToReturn = new ArrayList<Object>(size);
for (String key : keysForCache) {
+ System.out.println(key);
listToReturn.add(cache.get(KeyTransformationHandler.stringToKey(key)));
}
Added: trunk/query/src/test/java/org/infinispan/query/backend/KeyTransformationHandlerTest.java
===================================================================
--- trunk/query/src/test/java/org/infinispan/query/backend/KeyTransformationHandlerTest.java (rev 0)
+++ trunk/query/src/test/java/org/infinispan/query/backend/KeyTransformationHandlerTest.java 2009-12-08 13:59:06 UTC (rev 1263)
@@ -0,0 +1,90 @@
+package org.infinispan.query.backend;
+
+import org.testng.annotations.Test;
+import org.infinispan.query.test.CustomKey;
+
+/**
+ * This is the test class for {@link org.infinispan.query.backend.KeyTransformationHandler}
+ *
+ * @author Navin Surtani
+ */
+
+ at Test(groups = "functional")
+public class KeyTransformationHandlerTest {
+
+ String s = null;
+ Object key = null;
+
+ public void testKeyToStringWithStringAndPrimitives() {
+ s = KeyTransformationHandler.keyToString("key");
+ assert s.equals("S:key");
+
+ s = KeyTransformationHandler.keyToString(1);
+ assert s.equals("I:1");
+
+ s = KeyTransformationHandler.keyToString(true);
+ assert s.equals("B:true");
+
+ s = KeyTransformationHandler.keyToString((short) 1);
+ assert s.equals("X:1");
+
+ s = KeyTransformationHandler.keyToString((long) 1);
+ assert s.equals("L:1");
+
+ s = KeyTransformationHandler.keyToString((byte) 1);
+ assert s.equals("Y:1");
+
+ s = KeyTransformationHandler.keyToString((float) 1);
+ assert s.equals("F:1.0");
+
+ s = KeyTransformationHandler.keyToString('A');
+ assert s.equals("C:A");
+
+ s = KeyTransformationHandler.keyToString(1.0);
+ assert s.equals("D:1.0");
+ }
+
+ public void testStringToKeyWithStringAndPrimitives() {
+ key = KeyTransformationHandler.stringToKey("S:key1");
+ assert key.getClass().equals(String.class);
+ assert key.equals("key1");
+
+ key = KeyTransformationHandler.stringToKey("I:2");
+ assert key.getClass().equals(Integer.class);
+ assert key.equals(2);
+
+ key = KeyTransformationHandler.stringToKey("Y:3");
+ assert key.getClass().equals(Byte.class);
+ assert key.equals((byte) 3);
+
+ key = KeyTransformationHandler.stringToKey("F:4.0");
+ assert key.getClass().equals(Float.class);
+ assert key.equals((float) 4.0);
+
+ key = KeyTransformationHandler.stringToKey("L:5");
+ assert key.getClass().equals(Long.class);
+ assert key.equals((long) 5);
+
+ key = KeyTransformationHandler.stringToKey("X:6");
+ assert key.getClass().equals(Short.class);
+ assert key.equals((short) 6);
+
+ key = KeyTransformationHandler.stringToKey("B:true");
+ assert key.getClass().equals(Boolean.class);
+ assert key.equals(true);
+
+ key = KeyTransformationHandler.stringToKey("D:8.0");
+ assert key.getClass().equals(Double.class);
+ assert key.equals(8.0);
+
+ key = KeyTransformationHandler.stringToKey("C:9");
+ assert key.getClass().equals(Character.class);
+ assert key.equals('9');
+
+ }
+
+ public void testStringToKeyWithCustomTransformable(){
+ CustomKey customKey = new CustomKey("hello", 5);
+ System.out.println(customKey.getClass().getName());
+ }
+}
Modified: trunk/query/src/test/java/org/infinispan/query/blackbox/AbstractLocalQueryTest.java
===================================================================
--- trunk/query/src/test/java/org/infinispan/query/blackbox/AbstractLocalQueryTest.java 2009-12-07 18:22:16 UTC (rev 1262)
+++ trunk/query/src/test/java/org/infinispan/query/blackbox/AbstractLocalQueryTest.java 2009-12-08 13:59:06 UTC (rev 1263)
@@ -35,7 +35,7 @@
protected String key2 = "BigGoat";
protected String key3 = "MiniGoat";
- protected Cache<String, Person> cache;
+ protected Cache<Object, Person> cache;
protected QueryHelper qh;
@AfterMethod(alwaysRun = true)
Added: trunk/query/src/test/java/org/infinispan/query/blackbox/KeyTypeTest.java
===================================================================
--- trunk/query/src/test/java/org/infinispan/query/blackbox/KeyTypeTest.java (rev 0)
+++ trunk/query/src/test/java/org/infinispan/query/blackbox/KeyTypeTest.java 2009-12-08 13:59:06 UTC (rev 1263)
@@ -0,0 +1,116 @@
+package org.infinispan.query.blackbox;
+
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.TermQuery;
+import org.infinispan.Cache;
+import org.infinispan.config.Configuration;
+import org.infinispan.manager.CacheManager;
+import org.infinispan.query.CacheQuery;
+import org.infinispan.query.QueryFactory;
+import org.infinispan.query.backend.QueryHelper;
+import org.infinispan.query.test.Person;
+import org.infinispan.query.test.CustomKey;
+import org.infinispan.test.SingleCacheManagerTest;
+import org.infinispan.test.fwk.TestCacheManagerFactory;
+import org.infinispan.transaction.lookup.DummyTransactionManagerLookup;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.Test;
+import org.testng.annotations.BeforeMethod;
+
+import java.util.List;
+import java.util.Properties;
+
+/**
+ * Class that will put in different kinds of keys into the cache and run a query on it to see if
+ * different primitives will work as keys.
+ *
+ * @author Navin Surtani
+ */
+
+ at Test(groups = "functional")
+public class KeyTypeTest extends SingleCacheManagerTest{
+
+ Cache<Object, Person> cache;
+ QueryHelper qh;
+ Person person1;
+
+ @Override
+ protected CacheManager createCacheManager() throws Exception {
+ Configuration c = new Configuration();
+ c.setTransactionManagerLookupClass(DummyTransactionManagerLookup.class.getName());
+ return TestCacheManagerFactory.createCacheManager(c, true);
+ }
+
+ @BeforeMethod (alwaysRun = true)
+ public void setUp() throws Exception{
+ System.setProperty(QueryHelper.QUERY_ENABLED_PROPERTY, "true");
+ System.setProperty(QueryHelper.QUERY_INDEX_LOCAL_ONLY_PROPERTY, "true");
+
+ CacheManager manager = createCacheManager();
+ cache = manager.getCache();
+ qh = new QueryHelper(cache, new Properties(), Person.class);
+
+ person1 = new Person();
+ person1.setName("Navin");
+ person1.setBlurb("Owns a macbook");
+ person1.setAge(20);
+
+
+ }
+
+ @AfterMethod(alwaysRun = true)
+ public void tearDown() {
+ if (cache != null) {
+ cache.clear();
+ cache.stop();
+ }
+ }
+
+ public void testPrimitiveAndStringKeys(){
+ String key1 = "key1";
+ int key2 = 2;
+ byte key3 = (byte) 3;
+ float key4 = (float) 4;
+ long key5 = (long) 5;
+ short key6 = (short) 6;
+ boolean key7 = true;
+ double key8 = (double) 8;
+ char key9 = '9';
+
+
+ cache.put(key1, person1);
+ cache.put(key2, person1);
+ cache.put(key3, person1);
+ cache.put(key4, person1);
+ cache.put(key5, person1);
+ cache.put(key6, person1);
+ cache.put(key7, person1);
+ cache.put(key8, person1);
+ cache.put(key9, person1);
+
+ // Going to search the 'blurb' field for 'owns'
+ Term term = new Term ("blurb", "owns");
+ CacheQuery cacheQuery = new QueryFactory(cache, qh).getQuery(new TermQuery(term));
+ assert cacheQuery.getResultSize() == 9;
+
+ List<Object> found = cacheQuery.list();
+ for (int i = 0; i < 9; i++){
+ assert found.get(i).equals(person1);
+ }
+
+ }
+
+ public void testCustomKeys(){
+ CustomKey key1 = new CustomKey("Kim", 3);
+ CustomKey key2 = new CustomKey("Jong", 4);
+ CustomKey key3 = new CustomKey("Il", 2);
+
+ cache.put(key1, person1);
+ cache.put(key2, person1);
+ cache.put(key3, person1);
+
+ Term term = new Term("blurb", "owns");
+ CacheQuery cacheQuery = new QueryFactory(cache, qh).getQuery(new TermQuery(term));
+ assert cacheQuery.getResultSize() == 3;
+ }
+}
Added: trunk/query/src/test/java/org/infinispan/query/test/CustomKey.java
===================================================================
--- trunk/query/src/test/java/org/infinispan/query/test/CustomKey.java (rev 0)
+++ trunk/query/src/test/java/org/infinispan/query/test/CustomKey.java 2009-12-08 13:59:06 UTC (rev 1263)
@@ -0,0 +1,35 @@
+package org.infinispan.query.test;
+
+import org.infinispan.query.Transformable;
+
+/**
+ * Test class used as a transformable. Used to test the code in {@link org.infinispan.query.backend.KeyTransformationHandler}
+ * through the {@link org.infinispan.query.backend.KeyTransformationHandlerTest}
+ *
+ * @author Navin Surtani
+ */
+
+ at Transformable(transformer = CustomTransformer.class)
+public class CustomKey {
+
+ private String name;
+ private int aNumber;
+
+ public CustomKey(String name, int aNumber){
+ this.name = name;
+ this.aNumber = aNumber;
+ }
+
+ public String getName(){
+ return name;
+ }
+
+ public int getANumber(){
+ return aNumber;
+ }
+
+ @Override
+ public String toString(){
+ return "aNumber=" + aNumber + ";name=" + name;
+ }
+}
Added: trunk/query/src/test/java/org/infinispan/query/test/CustomTransformer.java
===================================================================
--- trunk/query/src/test/java/org/infinispan/query/test/CustomTransformer.java (rev 0)
+++ trunk/query/src/test/java/org/infinispan/query/test/CustomTransformer.java 2009-12-08 13:59:06 UTC (rev 1263)
@@ -0,0 +1,36 @@
+package org.infinispan.query.test;
+
+import org.infinispan.query.Transformer;
+
+/**
+ * Custom class that implements {@link org.infinispan.query.Transformer}
+ *
+ * @author Navin Surtani
+ */
+
+
+public class CustomTransformer implements Transformer {
+
+
+ @Override
+ public Object fromString(String s) {
+ // I know that the custom type is a CustomKey.
+ // The string will be of the format of "aNumber=" + aNumber + ";name=" + name
+ // For test purposes we can create a new instance of this class with the same values.
+
+ int indexOfFirstEquals = s.indexOf("=");
+ int indexOfSemiColon = s.indexOf(";");
+ String aNumber = s.substring(indexOfFirstEquals, indexOfSemiColon);
+
+ // We know that this index will be the first one after indexOfFirstEquals
+ int indexOfSecondEquals = s.indexOf("=", indexOfFirstEquals);
+ String name = s.substring(indexOfSecondEquals);
+
+ return new CustomKey(name, Integer.parseInt(aNumber));
+ }
+
+ @Override
+ public String toString(Object customType) {
+ return customType.toString();
+ }
+}
More information about the infinispan-commits
mailing list