Index search with preference

Question

My java object has three fields A,B,C. And i'm indexing on these three field's values.
There can be duplicate entries , like Obj1's A equal to Obj2's B.
While searching the index , if more than one object found, preference should be in order A->B->C, only one object shd be returned and others should be filtered out.
As performance is critical criteria in application i don't want to use filter (as there can be 100s of big java objects expected to be returned ,iterating through these can hamper performance.)
Can it be acheived through ChainedExtractor or any other better way?
Thanks in advance.
Prashant

Answer 1

Hi Prashant,
please check the following example:
public class ClassedQueryUtil {
     public static class ClassedQueryParameters implements PortableObject, Serializable {
          private List<ValueExtractor> extractors;
          private Object queryFor;
          public ClassedQueryParameters(List<ValueExtractor> extractors, Object queryFor) {
               super();
               this.extractors = extractors;
               this.queryFor = queryFor;
          public ClassedQueryParameters() {
               super();
          public void readExternal(PofReader reader) throws IOException {
               extractors = (List<ValueExtractor>) reader.readCollection(0, null);
               queryFor = reader.readObject(1);
          public void writeExternal(PofWriter writer) throws IOException {
               writer.writeCollection(0, extractors);
               writer.writeObject(1, queryFor);
          public List<ValueExtractor> getExtractors() {
               return extractors;
          public Object getQueryFor() {
               return queryFor;
     public static class ClassedQueryFilter  extends ClassedQueryParameters implements IndexAwareFilter {
          public ClassedQueryFilter(List<ValueExtractor> extractors, Object queryFor) {
               super(extractors, queryFor);
          public ClassedQueryFilter() {
               super();
          public Filter applyIndex(Map mapIndexes, Set candidateBinaryKeys) {
               List<ValueExtractor> extractors = getExtractors();
               Object queryFor = getQueryFor();
               boolean foundNoMatch = true;
               if (mapIndexes.keySet().containsAll(extractors)) {
                    for (ValueExtractor extractor : extractors) {
                         MapIndex index = (MapIndex) mapIndexes.get(extractor);
                         Collection reverse = (Collection) index.get(queryFor);
                         if (reverse != null && !reverse.isEmpty()) {
                              if (!Collections.disjoint(reverse, candidateBinaryKeys)) {
                                   candidateBinaryKeys.retainAll(reverse);
                                   foundNoMatch = false;
                                   break;
               if (foundNoMatch) {
                    candidateBinaryKeys.clear();
               return null;
          public int calculateEffectiveness(Map mapIndexes, Set candidateBinaryKeys) {
               List<ValueExtractor> extractors = getExtractors();
               if (mapIndexes.keySet().containsAll(extractors)) {
                    return 0;
               throw new UnsupportedOperationException("Must have all indexes defined!!!");
          public boolean evaluateEntry(Entry entry) {
               throw new UnsupportedOperationException("Must have all indexes defined!!!");
          public boolean evaluate(Object value) {
               throw new UnsupportedOperationException("Must have all indexes defined!!!");
     public static class ClassedQueryAggregator extends ClassedQueryParameters
     implements ParallelAwareAggregator {
          public ClassedQueryAggregator() {
               super();
          public ClassedQueryAggregator(List<ValueExtractor> extractors, Object queryFor) {
               super(extractors, queryFor);
          public Collection aggregateResults(Collection results) {
               int resultClassSoFar = Integer.MAX_VALUE;
               ArrayList resultValues = new ArrayList();
               for (Object object : results) {
                    Object[] result = (Object[]) object;
                    int resultClass = (Integer) result[0];
                    if (resultClass == -1 || resultClass > resultClassSoFar) {
                         continue;
                    } else {
                         if (resultClass < resultClassSoFar) {
                              resultValues.clear();
                              resultClassSoFar = resultClass;
                         Object[] resInner = (Object[]) result[1];
                         resultValues.ensureCapacity(resultValues.size()+resInner.length);
                         for (Object resultElement : resInner) {
                              resultValues.add(resultElement);
               if (!resultValues.isEmpty()) {
                    if (resultValues.get(0) instanceof Binary) {
                         for (int i=resultValues.size()-1; i>=0; --i) {
                              resultValues.set(i, ExternalizableHelper.fromBinary((Binary)resultValues.get(i)));
               return resultValues;
          public EntryAggregator getParallelAggregator() {
               return this;
          public Object aggregate(Set entries) {
               if (entries.isEmpty()) {
                    return new Object[] { new Integer(-1) };
               QueryMap.Entry first = (QueryMap.Entry) entries.iterator().next();
               Object[] resInner = new Object[entries.size()];
               List<ValueExtractor> extractors = getExtractors();
               Object queryFor = getQueryFor();
               int resultClass = 0;
               int numExtractors = extractors.size();
               for (resultClass = 0; resultClass < numExtractors; ++resultClass) {
                    if (queryFor.equals(first.extract(extractors.get(resultClass)))) {
                         break;
               boolean isBinaryEntry = first instanceof BinaryEntry;
               int i=0;
               for (Object entry : entries) {
                    if (isBinaryEntry) {
                         resInner[i] = ((BinaryEntry)entry).getBinaryValue();
                    } else {
                         resInner[i] = ((Map.Entry) entry).getValue();
                    ++i;
               return new Object[] { resultClass, resInner };
     public static Collection<Map.Entry> queryForEntries(NamedCache cache, List<ValueExtractor> extractors, Object queryFor) {
          int resultClassSoFar = Integer.MAX_VALUE;
          Set results = cache.entrySet(new ClassedQueryFilter(extractors, queryFor));
          ArrayList resultValues = new ArrayList();
          for (Object object : results) {
               Map.Entry entry = (Entry) object;
               int resultInClass = 0;
               int numExtractors = extractors.size();
               for (resultInClass = 0; resultInClass < numExtractors; ++resultInClass) {
                    Object extracted = InvocableMapHelper.extractFromEntry(extractors.get(resultInClass), entry);
                    if (queryFor.equals(extracted)) {
                         break;
               if (resultInClass > resultClassSoFar) {
                    continue;
               if (resultInClass < resultClassSoFar) {
                    resultValues.clear();
                    resultClassSoFar = resultInClass;
               resultValues.add(entry);
          return resultValues;
     public static Collection aggregateForValues(NamedCache cache, List<ValueExtractor> extractors, Object queryFor) {
          return (Collection) cache.aggregate(new ClassedQueryFilter(extractors, queryFor), new ClassedQueryAggregator(extractors, queryFor));
}To use it, invoke one of the two static methods on the ClassedQueryUtil class.
You must use a partitioned cache (distributed or near cache) for this to operate.
This depends on the Coherence 3.5 prerelease which has BinaryEntry. This allows the parallel aggregator on the storage node to avoid deserializing the entry value just to return it. If you don't have that then all candidate entries will be deserialized and reserialized on the storage node. Not that the candidate entry is an entry which has not been filtered away in the filter, so it is to be returned to the client to the best knowledge of the storage node, in the above example the entries matching on field B when there was not an entry matching on field A in that node.
Best regards,
Robert