Author: ito
Date: Mon May 23 11:50:40 2011
New Revision: 1126455
URL: http://svn.apache.org/viewvc?rev=1126455&view=rev
Log:
CLEREZZA-501: sort facets functionality implemented
Added:
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/SortedCountFacetCollector.java
Modified:
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/CountFacetCollector.java
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/FacetCollector.java
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/GenericCondition.java
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/GraphIndexer.java
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/test/java/org/apache/clerezza/rdf/cris/GraphIndexerTest.java
Modified:
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/CountFacetCollector.java
URL:
http://svn.apache.org/viewvc/incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/CountFacetCollector.java?rev=1126455&r1=1126454&r2=1126455&view=diff
==============================================================================
---
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/CountFacetCollector.java
(original)
+++
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/CountFacetCollector.java
Mon May 23 11:50:40 2011
@@ -20,16 +20,18 @@
package org.apache.clerezza.rdf.cris;
import java.util.Collection;
+import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
+import java.util.Set;
/**
* A FacetCollector that counts members of a facet.
*
* @author daniel
*/
-public class CountFacetCollector implements FacetCollector<Integer> {
- final private Map<VirtualProperty, Map<String, Integer>> facetMap;
+public class CountFacetCollector extends FacetCollector<Integer> {
+ final Map<VirtualProperty, Map<String, Integer>> facetMap;
/**
* Creates a new CountFacetCollector that collects facet data over the
@@ -57,24 +59,34 @@ public class CountFacetCollector impleme
}
@Override
- public Map<VirtualProperty, Map<String, Integer>> getFacetMap() {
- return facetMap;
+ public Collection<VirtualProperty> getProperties() {
+ return Collections.unmodifiableCollection(facetMap.keySet());
}
@Override
- public void addFacetValue(VirtualProperty field, String value) {
+ void addFacetValue(VirtualProperty field, String value) {
Map<String, Integer> propertyMap = facetMap.get(field);
Integer old = propertyMap.get(value);
propertyMap.put(value, old == null ? 1 : old + 1);
}
@Override
- public Map<String, Integer> getFacets(VirtualProperty property) {
- return facetMap.get(property);
+ public Set<Map.Entry<String, Integer>> getFacets(VirtualProperty
property) {
+ return
Collections.unmodifiableSet(facetMap.get(property).entrySet());
}
@Override
public Integer getFacetValue(VirtualProperty property, String facet) {
return facetMap.get(property).get(facet);
}
+
+ @Override
+ Map<VirtualProperty, Map<String, Integer>> getFacetMap() {
+ return facetMap;
+ }
+
+ @Override
+ void postProcess() {
+ //do nothing
+ }
}
Modified:
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/FacetCollector.java
URL:
http://svn.apache.org/viewvc/incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/FacetCollector.java?rev=1126455&r1=1126454&r2=1126455&view=diff
==============================================================================
---
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/FacetCollector.java
(original)
+++
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/FacetCollector.java
Mon May 23 11:50:40 2011
@@ -19,7 +19,9 @@
package org.apache.clerezza.rdf.cris;
+import java.util.Collection;
import java.util.Map;
+import java.util.Set;
/**
* This class is a container that defines facets that should be collected and
@@ -27,7 +29,7 @@ import java.util.Map;
*
* @author daniel
*/
-public interface FacetCollector<T> {
+public abstract class FacetCollector<T> {
/**
* Add a property over which facets are collected.
@@ -36,30 +38,23 @@ public interface FacetCollector<T> {
*
* @param property A virtual property over which facets are
collected.
*/
- public void addFacetProperty(VirtualProperty property);
+ public abstract void addFacetProperty(VirtualProperty property);
- /**
- * This method adds a new data to the facet map.
- *
- * @param property The property.
- * @param value The value of the property as returned by Lucene.
- */
- public void addFacetValue(VirtualProperty property, String value);
/**
- * Returns the collected data.
+ * Returns the properties for which facets are collected..
*
- * @return The collected data.
+ * @return The properties.
*/
- public Map<VirtualProperty, Map<String, T>> getFacetMap();
+ public abstract Collection<VirtualProperty> getProperties();
/**
* Returns all facets for the given property.
*
* @param property the property.
- * @return A map with facets and facet values.
+ * @return A set with facets and facet values.
*/
- public Map<String, T> getFacets(VirtualProperty property);
+ public abstract Set<Map.Entry<String, T>> getFacets(VirtualProperty
property);
/**
* Returns a facet value.
@@ -68,5 +63,28 @@ public interface FacetCollector<T> {
* @param facet The facet.
* @return The facet value.
*/
- public T getFacetValue(VirtualProperty property, String facet);
+ public abstract T getFacetValue(VirtualProperty property, String facet);
+
+ /**
+ * Expert: This method returns the underlying data structure as a
nested map.
+ * It is intended for fast access to the underlying data, not for users.
+ *
+ * @return the facetMap
+ */
+ abstract Map<VirtualProperty, Map<String, T>> getFacetMap();
+
+ /**
+ * This method adds a new data to the facet map.
+ *
+ * @param property The property.
+ * @param value The value of the property as returned by Lucene.
+ */
+ abstract void addFacetValue(VirtualProperty property, String value);
+
+ /**
+ * Expert: This method performs post processing on the FacetCollector.
+ * Users should not call it. It is intended for avoiding time consuming
tasks
+ * until changes are written to the collector.
+ */
+ abstract void postProcess();
}
Modified:
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/GenericCondition.java
URL:
http://svn.apache.org/viewvc/incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/GenericCondition.java?rev=1126455&r1=1126454&r2=1126455&view=diff
==============================================================================
---
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/GenericCondition.java
(original)
+++
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/GenericCondition.java
Mon May 23 11:50:40 2011
@@ -70,7 +70,6 @@ public class GenericCondition extends Co
if(escapeQuery) {
searchQuery = QueryParser.escape(searchQuery);
- System.out.println("ESCAPED: " + searchQuery);
}
this.searchQuery = searchQuery;
Modified:
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/GraphIndexer.java
URL:
http://svn.apache.org/viewvc/incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/GraphIndexer.java?rev=1126455&r1=1126454&r2=1126455&view=diff
==============================================================================
---
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/GraphIndexer.java
(original)
+++
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/GraphIndexer.java
Mon May 23 11:50:40 2011
@@ -84,7 +84,7 @@ public class GraphIndexer extends Resour
private final GraphListener listener1;
private final GraphListener listener2;
- static final String SORT_PREFIX = "PRE";
+ static final String SORT_PREFIX = "_STORED_";
private Map<SortFieldArrayWrapper, Sort> sortCache = new
HashMap<SortFieldArrayWrapper, Sort>();
@@ -195,7 +195,7 @@ public class GraphIndexer extends Resour
if (stop) {
break;
}
- logger.info("{}: registered
write - waiting for more writes to follow.", getName());
+ logger.debug("{}: registered
write - waiting for more writes to follow.", getName());
waitUntilStable();
set = new
HashSet<Resource>(resourcesToProcess);
resourcesToProcess.clear();
@@ -220,7 +220,7 @@ public class GraphIndexer extends Resour
while (!resourcesClean) {
resourcesClean = true;
indexResources.awaitNanos(stableThreshold);
- if(++counter > resourceCacheCapacity) {
+ if(resourceCacheCapacity >= 0 && ++counter >
resourceCacheCapacity) {
break;
}
}
@@ -576,10 +576,17 @@ public class GraphIndexer extends Resour
collectFacets(facetCollectors, d);
result.add(getResource(d));
} catch (CorruptIndexException ex) {
+ logger.error("CRIS Error: ", ex);
} catch (IOException ex) {
+ logger.error("CRIS Error: ", ex);
}
}
+
+ for(FacetCollector facetCollector : facetCollectors) {
+ facetCollector.postProcess();
+ }
+
return result;
}
@@ -604,9 +611,11 @@ public class GraphIndexer extends Resour
Map<VirtualProperty, Map<String, Object>>
facetMap =
facetCollector.getFacetMap();
for(VirtualProperty property :
facetMap.keySet()) {
- String[] values =
d.getValues(property.getStringKey());
- if(values.length > 0) {
-
facetCollector.addFacetValue(property, values[0]);
+ String[] values =
d.getValues(SORT_PREFIX + property.getStringKey());
+ if(values != null) {
+ for(String value : values) {
+
facetCollector.addFacetValue(property, value);
+ }
}
}
}
@@ -654,18 +663,20 @@ public class GraphIndexer extends Resour
new GraphNode(resource,
this.baseGraph))).size());
for (String propertyValue : vProperty.value(new
GraphNode(resource, this.baseGraph))) {
logger.info("indexing " + vProperty + "(" +
vProperty.stringKey + ") with value " + (propertyValue));
- doc.add(new Field(vProperty.stringKey,
+ //for sorting
+ doc.add(new Field(SORT_PREFIX +
vProperty.stringKey,
propertyValue,
Field.Store.YES,
+
Field.Index.NOT_ANALYZED_NO_NORMS));
+ //for searching (the extra field doesn't cost
much time)
+ doc.add(new Field(vProperty.stringKey,
+ propertyValue,
+ Field.Store.NO,
Field.Index.NOT_ANALYZED));
doc.add(new Field(vProperty.stringKey,
propertyValue,
- Field.Store.YES,
+ Field.Store.NO,
Field.Index.ANALYZED));
- doc.add(new Field(SORT_PREFIX +
vProperty.stringKey,
- propertyValue,
- Field.Store.YES,
- Field.Index.NOT_ANALYZED));
}
}
return doc;
Added:
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/SortedCountFacetCollector.java
URL:
http://svn.apache.org/viewvc/incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/SortedCountFacetCollector.java?rev=1126455&view=auto
==============================================================================
---
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/SortedCountFacetCollector.java
(added)
+++
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/main/java/org/apache/clerezza/rdf/cris/SortedCountFacetCollector.java
Mon May 23 11:50:40 2011
@@ -0,0 +1,153 @@
+/*
+ * 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.clerezza.rdf.cris;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
+
+
+
+/**
+ * A FacetCollector that counts members of a facet and returns ordered facets.
+ *
+ * Uses the comparable interface to determine order between facets.
+ *
+ * Note: Facets are always ordered first by value and only when
+ * values are equal according to keys.
+ *
+ * @author daniel
+ */
+public class SortedCountFacetCollector extends CountFacetCollector {
+
+ private Map<VirtualProperty, SortedSet<Map.Entry<String, Integer>>>
sortedFacetMap;
+ private boolean reverseValues = false;
+ private boolean reverseKeys = false;
+
+ /**
+ * Default Constructor.
+ *
+ * Creates a facet collector that orders keys in ascending and values
in descending order.
+ */
+ public SortedCountFacetCollector() {
+ this(false, true);
+ }
+
+ /**
+ * Creates a facet collector that orders according to the supplied
parameters.
+ *
+ * Note: Facets are always ordered first by value and only when
+ * values are equal according to keys.
+ *
+ * @param reverseKeyOrder true = descending order, false = ascending
order.
+ * @param reverseValueOrder true = descending order, false = ascending
order.
+ */
+ public SortedCountFacetCollector(boolean reverseKeyOrder, boolean
reverseValueOrder) {
+ super();
+ sortedFacetMap = Collections.emptyMap();
+ this.reverseValues = reverseValueOrder;
+ this.reverseKeys = reverseKeyOrder;
+ }
+
+ /**
+ * Whether the collector orders values in ascending or descending order.
+ *
+ * @return true = descending order, false = ascending order.
+ */
+ public boolean valuesReversed() {
+ return reverseValues;
+ }
+
+ /**
+ * Whether the collector orders keys in ascending or descending order.
+ *
+ * @return true = descending order, false = ascending order.
+ */
+ public boolean keysReversed() {
+ return reverseKeys;
+ }
+
+ @Override
+ public Set<Entry<String, Integer>> getFacets(VirtualProperty property) {
+ return sortedFacetMap.get(property);
+ }
+
+ @Override
+ void postProcess() {
+ super.postProcess();
+
+ Collection<VirtualProperty> properties = facetMap.keySet();
+ sortedFacetMap = new HashMap<VirtualProperty,
+ SortedSet<Entry<String,
Integer>>>(properties.size());
+ for(VirtualProperty property : properties) {
+
+ TreeSet<Entry<String, Integer>> sortedSet =
+ new TreeSet<Entry<String, Integer>>(new
EntrySetComparator());
+ Set<Entry<String, Integer>> entrySet =
facetMap.get(property).entrySet();
+ sortedSet.addAll(entrySet);
+ sortedFacetMap.put(property, sortedSet);
+ }
+ }
+
+
+ private class EntrySetComparator implements Comparator<Entry<String,
Integer>> {
+ @Override
+ public int compare(Entry<String, Integer> e1, Entry<String,
Integer> e2) {
+ String key1, key2;
+ if(reverseKeys) {
+ key1 = e2.getKey();
+ key2 = e1.getKey();
+ } else{
+ key1 = e1.getKey();
+ key2 = e2.getKey();
+ }
+
+ Integer val1, val2;
+ Entry<String, Integer> o2 = e2;
+ if(reverseValues) {
+ val1 = e2.getValue();
+ val2 = e1.getValue();
+ } else {
+ val1 = e1.getValue();
+ val2 = e2.getValue();
+ }
+
+
+ int val;
+ if(key1.equals(key2)) {
+ val = 0;
+ } else {
+ val = val1.compareTo(val2);
+ if(val == 0) {
+ val = key1.compareTo(key2);
+ }
+ }
+
+ return val;
+ }
+
+ }
+}
Modified:
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/test/java/org/apache/clerezza/rdf/cris/GraphIndexerTest.java
URL:
http://svn.apache.org/viewvc/incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/test/java/org/apache/clerezza/rdf/cris/GraphIndexerTest.java?rev=1126455&r1=1126454&r2=1126455&view=diff
==============================================================================
---
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/test/java/org/apache/clerezza/rdf/cris/GraphIndexerTest.java
(original)
+++
incubator/clerezza/issues/CLEREZZA-501/rdf.cris/core/src/test/java/org/apache/clerezza/rdf/cris/GraphIndexerTest.java
Mon May 23 11:50:40 2011
@@ -20,7 +20,11 @@
package org.apache.clerezza.rdf.cris;
import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
import java.util.List;
+import java.util.Map.Entry;
+import java.util.Set;
import org.apache.clerezza.rdf.cris.ontologies.CRIS;
import org.apache.clerezza.rdf.core.*;
import org.apache.clerezza.rdf.utils.*;
@@ -356,4 +360,263 @@ public class GraphIndexerTest {
} catch (InterruptedException ex) {
}
}
+
+ @Test
+ public void facetCollectorTest() throws InterruptedException,
ParseException {
+ IndexDefinitionManager indexDefinitionManager = new
IndexDefinitionManager(definitions);
+ final PropertyHolder firstName = new
PropertyHolder(FOAF.firstName);
+ List<VirtualProperty> properties = new
ArrayList<VirtualProperty>();
+ properties.add(firstName);
+ properties.add(new PropertyHolder(FOAF.lastName));
+ indexDefinitionManager.addDefinitionVirtual(FOAF.Person,
properties);
+ service.reCreateIndex();
+
+ //count occurence of distinct firstnames
+ CountFacetCollector facetCollector = new CountFacetCollector();
+ facetCollector.addFacetProperty(firstName);
+
+ Thread.sleep(1000);
+ {
+ List<NonLiteral> results =
service.findResources(firstName, "*", false, facetCollector);
+ Assert.assertTrue(results.size() > 0);
+
+ //there are 7 distinct firsst names
+ Assert.assertEquals(7,
facetCollector.getFacets(firstName).size());
+ //the firstname "Frank" appears once
+ Assert.assertEquals(new Integer(1),
facetCollector.getFacetValue(firstName, "Frank"));
+ //the firstname "frank" never appears
+
Assert.assertNull(facetCollector.getFacetValue(firstName, "frank"));
+ //the firstname "Jane" appears twice
+ Assert.assertEquals(new Integer(2),
facetCollector.getFacetValue(firstName, "Jane"));
+ //the firstname "Harry" appears once
+ Assert.assertEquals(new Integer(1),
facetCollector.getFacetValue(firstName, "Harry"));
+ //the firstname "Harry Joe" appears once
+ Assert.assertEquals(new Integer(1),
facetCollector.getFacetValue(firstName, "Harry Joe"));
+ //the firstname "William" appears once
+ Assert.assertEquals(new Integer(1),
facetCollector.getFacetValue(firstName, "William"));
+ //the firstname "John" appears twice
+ Assert.assertEquals(new Integer(2),
facetCollector.getFacetValue(firstName, "John"));
+ }
+ }
+
+ @Test
+ public void sortedfacetCollectorTest() throws InterruptedException,
ParseException {
+ IndexDefinitionManager indexDefinitionManager = new
IndexDefinitionManager(definitions);
+ final PropertyHolder firstName = new
PropertyHolder(FOAF.firstName);
+ List<VirtualProperty> properties = new
ArrayList<VirtualProperty>();
+ properties.add(firstName);
+ properties.add(new PropertyHolder(FOAF.lastName));
+ indexDefinitionManager.addDefinitionVirtual(FOAF.Person,
properties);
+
+ createPerson("Aaron", "Ignore");
+ createPerson("Aaron", "IgnoreMore");
+ createPerson("Alpha", "Ignore");
+ createPerson("Alpha", "IgnoreMore");
+ createPerson("Beta", "Ignore");
+
+ service.reCreateIndex();
+
+ CountFacetCollector facetCollector = new
SortedCountFacetCollector(false, true);
+ facetCollector.addFacetProperty(firstName);
+
+ Thread.sleep(1000);
+ {
+ List<NonLiteral> results =
service.findResources(firstName, "*", false, facetCollector);
+ Assert.assertTrue(results.size() > 0);
+
+ Set<Entry<String, Integer>> facets =
facetCollector.getFacets(firstName);
+ Integer old = Integer.MAX_VALUE;
+ String oldKey = null;
+ for(Entry<String, Integer> facet : facets) {
+ if(old == facet.getValue() &&
+ oldKey != null &&
+
(facet.getKey().compareTo(oldKey) < 0)) {
+
+ Assert.fail("Facet keys are not ordered
in ascending order.");
+ }
+ if(facet.getValue() > old) {
+ Assert.fail("Facet values are not
ordered in descending order.");
+ }
+ old = facet.getValue();
+ oldKey = facet.getKey();
+ }
+ }
+
+ facetCollector = new SortedCountFacetCollector(false, false);
+ facetCollector.addFacetProperty(firstName);
+
+ Thread.sleep(1000);
+ {
+ List<NonLiteral> results =
service.findResources(firstName, "*", false, facetCollector);
+ Assert.assertTrue(results.size() > 0);
+
+ Set<Entry<String, Integer>> facets =
facetCollector.getFacets(firstName);
+ Integer old = -1;
+ String oldKey = null;
+ for (Entry<String, Integer> facet : facets) {
+ if (old == facet.getValue()
+ && oldKey != null
+ &&
(facet.getKey().compareTo(oldKey) < 0)) {
+ Assert.fail("Facet keys are not ordered
in ascending order.");
+ }
+ if (facet.getValue() < old) {
+ Assert.fail("Facet values are not
ordered in ascending order.");
+ }
+ old = facet.getValue();
+ oldKey = facet.getKey();
+ }
+ }
+
+ facetCollector = new SortedCountFacetCollector(true, false);
+ facetCollector.addFacetProperty(firstName);
+
+ Thread.sleep(1000);
+ {
+ List<NonLiteral> results =
service.findResources(firstName, "*", false, facetCollector);
+ Assert.assertTrue(results.size() > 0);
+
+ Set<Entry<String, Integer>> facets =
facetCollector.getFacets(firstName);
+ Integer old = -1;
+ String oldKey = null;
+ for (Entry<String, Integer> facet : facets) {
+ if (old == facet.getValue()
+ && oldKey != null
+ &&
(facet.getKey().compareTo(oldKey) > 0)) {
+ Assert.fail("Facet keys are not ordered
in descending order.");
+ }
+ if (facet.getValue() < old) {
+ Assert.fail("Facet values are not
ordered in ascending order.");
+ }
+ old = facet.getValue();
+ oldKey = facet.getKey();
+ }
+ }
+
+ facetCollector = new SortedCountFacetCollector(true, true);
+ facetCollector.addFacetProperty(firstName);
+
+ Thread.sleep(1000);
+ {
+ List<NonLiteral> results =
service.findResources(firstName, "*", false, facetCollector);
+ Assert.assertTrue(results.size() > 0);
+
+ Set<Entry<String, Integer>> facets =
facetCollector.getFacets(firstName);
+ Integer old = Integer.MAX_VALUE;
+ String oldKey = null;
+ for (Entry<String, Integer> facet : facets) {
+ if (old == facet.getValue()
+ && oldKey != null
+ &&
(facet.getKey().compareTo(oldKey) > 0)) {
+ Assert.fail("Facet keys are not ordered
in descending order.");
+ }
+ if (facet.getValue() > old) {
+ Assert.fail("Facet values are not
ordered in descending order.");
+ }
+ old = facet.getValue();
+ oldKey = facet.getKey();
+ }
+ }
+ }
+
+ @Test
+ public void sortResultsTest() throws InterruptedException,
ParseException {
+ IndexDefinitionManager indexDefinitionManager = new
IndexDefinitionManager(definitions);
+ final PropertyHolder firstName = new
PropertyHolder(FOAF.firstName);
+ List<VirtualProperty> properties = new
ArrayList<VirtualProperty>();
+ properties.add(firstName);
+ indexDefinitionManager.addDefinitionVirtual(FOAF.Person,
properties);
+ service.reCreateIndex();
+
+ SortSpecification sortSpecification = new SortSpecification();
+ sortSpecification.add(firstName,
SortSpecification.STRING_COMPARETO);
+ sortSpecification.add(SortSpecification.INDEX_ORDER);
+
+ Thread.sleep(1000);
+ {
+ List<NonLiteral> results =
service.findResources(firstName, "*", false, sortSpecification);
+ Assert.assertTrue(results.size() > 0);
+
+ List<String> expected = new ArrayList<String>(7);
+ expected.add("Frank");
+ expected.add("Harry");
+ expected.add("Harry Joe");
+ expected.add("Jane");
+ expected.add("Jane");
+ expected.add("Joe");
+ expected.add("John");
+
+
+
+ List<String> actual = new
ArrayList<String>(results.size());
+ for(NonLiteral result : results) {
+ GraphNode node = new GraphNode(result,
dataGraph);
+ Iterator<Literal> it =
node.getLiterals(FOAF.firstName);
+ while(it.hasNext()) {
+ actual.add(it.next().getLexicalForm());
+ }
+ }
+
+ //ignore "John William" because we can not make
assumptions about
+ //the order of properties
+ Assert.assertArrayEquals(expected.toArray(),
+ Arrays.copyOfRange(actual.toArray(), 0,
7));
+ }
+ }
+
+ @Test
+ public void genericConditionTest() throws InterruptedException,
ParseException {
+ IndexDefinitionManager indexDefinitionManager = new
IndexDefinitionManager(definitions);
+ final PropertyHolder firstName = new
PropertyHolder(FOAF.firstName);
+ List<VirtualProperty> properties = new
ArrayList<VirtualProperty>();
+ properties.add(firstName);
+ indexDefinitionManager.addDefinitionVirtual(FOAF.Person,
properties);
+ service.reCreateIndex();
+
+
+ Thread.sleep(1000);
+ {
+ List<Condition> conditions = new
ArrayList<Condition>(1);
+ //exact match --> exact expression match on untokenized
+ conditions.add(new GenericCondition(properties,
"\"Harry Joe\""));
+ List<NonLiteral> results =
service.findResources(conditions);
+ Assert.assertEquals(1, results.size());
+ conditions.clear();
+ //case-insensitive exact match
+ conditions.add(new GenericCondition(properties,
"\"harry joe\""));
+ results = service.findResources(conditions);
+ Assert.assertEquals(1, results.size());
+ conditions.clear();
+ //tokenized term match (Harry or Joe)
+ conditions.add(new GenericCondition(properties, "Harry
Joe"));
+ results = service.findResources(conditions);
+ Assert.assertEquals(3, results.size());
+ conditions.clear();
+ //case-insensitive tokenized term
+ conditions.add(new GenericCondition(properties, "harry
joe"));
+ results = service.findResources(conditions);
+ Assert.assertEquals(3, results.size());
+ conditions.clear();
+ //tokenized term match (Harry and Joe)
+ conditions.add(new GenericCondition(properties, "+Harry
+Joe"));
+ results = service.findResources(conditions);
+ Assert.assertEquals(1, results.size());
+ conditions.clear();
+ //tokenized term match (Joe and and not Harry)
+ conditions.add(new GenericCondition(properties, "-harry
+joe"));
+ results = service.findResources(conditions);
+ Assert.assertEquals(1, results.size());
+ conditions.clear();
+ //wildcard match
+ conditions.add(new GenericCondition(properties,
"harry*"));
+ results = service.findResources(conditions);
+ Assert.assertEquals(2, results.size());
+ conditions.clear();
+ //leading wildcard match
+ conditions.add(new GenericCondition(properties,
"*joe"));
+ results = service.findResources(conditions);
+ Assert.assertEquals(2, results.size());
+ conditions.clear();
+ }
+
+ }
}
