Custom comparator with LimitFilter

Question

When I use a custom comparator with a LimitFilter, the results within the limit are returned first and then the comparator is applied, instead of applying the comparator on the complete result set, and then limit them. Is there a way to achieve the scenario I am expecting?
Thank is advance

Answer 1

I am also on coherence version 3.5.2
1. custom-pof-config.xml:
<?xml version="1.0"?>
<!DOCTYPE pof-config SYSTEM "pof-config.dtd">
<pof-config>
     <user-type-list>
          <include>coherence-pof-config.xml</include>
          <user-type>
               <type-id>2001</type-id>
               <class-name>com.biperf.cache.example.CacheItem</class-name>
          </user-type>
          <user-type>
               <type-id>2002</type-id>
               <class-name>com.biperf.cache.example.CacheSubItem1</class-name>
          </user-type>
          <user-type>
               <type-id>2003</type-id>
               <class-name>com.biperf.cache.example.CacheSubItem2</class-name>
          </user-type>
          <user-type>
               <type-id>2004</type-id>
               <class-name>com.biperf.cache.example.CustomFilter1</class-name>
          </user-type>
          <user-type>
               <type-id>2005</type-id>
               <class-name>com.biperf.cache.example.CustomComparator1</class-name>
          </user-type>
          <user-type>
               <type-id>2006</type-id>
               <class-name>com.biperf.cache.example.CustomProcessor1</class-name>
          </user-type>
     </user-type-list>
     <allow-interfaces>true</allow-interfaces>
     <allow-subclasses>true</allow-subclasses>
</pof-config>2. Domain objects:
public class CacheItem extends AbstractEvolvable implements EvolvablePortableObject, java.io.Serializable, com.tangosol.io.pof.PortableObject
  private static final int VERSION = 1;
  private static final long serialVersionUID = -1L;
  private long cacheItemId;
  private Set<CacheSubItem1> item1 = new HashSet<CacheSubItem1>();
  private Set<String> item2 = new HashSet<String>();
  private Set<Long> item3 = new HashSet<Long>();
  public long getCacheItemId()
    return cacheItemId;
  public void setCacheItemId( long cacheItemId )
    this.cacheItemId = cacheItemId;
  public Set<CacheSubItem1> getItem1()
    return item1;
  public void setItem1( Set<CacheSubItem1> item1 )
    this.item1 = item1;
  public Set<String> getItem2()
    return item2;
  public void setItem2( Set<String> item2 )
    this.item2 = item2;
  public Set<Long> getItem3()
    return item3;
  public void setItem3( Set<Long> item3 )
    this.item3 = item3;
  @SuppressWarnings( "unchecked" )
  @Override
  public void readExternal( PofReader reader ) throws IOException
    cacheItemId = reader.readLong( 0 );
    item1 = (Set<CacheSubItem1>)reader.readCollection( 1, item1 );
    item2 = (Set<String>)reader.readCollection( 2, item2 );
    item3 = (Set<Long>)reader.readCollection( 3, item3 );
  @Override
  public void writeExternal( PofWriter writer ) throws IOException
    writer.writeLong( 0, cacheItemId );
    writer.writeCollection( 1, item1 );
    writer.writeCollection( 2, item2 );
    writer.writeCollection( 3, item3 );
  @Override
  public int getImplVersion()
    return VERSION ;
public class CacheSubItem1 extends AbstractEvolvable implements EvolvablePortableObject, java.io.Serializable, com.tangosol.io.pof.PortableObject
  private static final int VERSION = 1;
  private static final long serialVersionUID = -1L;
  private Map<Integer, CacheSubItem2> item1 = new HashMap<Integer, CacheSubItem2>();
  public Map<Integer, CacheSubItem2> getItem1()
    return item1;
  public void setItem1( Map<Integer, CacheSubItem2> item1 )
    this.item1 = item1;
  @SuppressWarnings( "unchecked" )
  @Override
  public void readExternal( PofReader reader ) throws IOException
    item1 = (Map<Integer, CacheSubItem2>)reader.readMap( 0, item1 );
  @Override
  public void writeExternal( PofWriter writer ) throws IOException
    writer.writeMap( 0, item1 );
  @Override
  public int getImplVersion()
    return VERSION ;
public class CacheSubItem2 extends AbstractEvolvable implements EvolvablePortableObject, java.io.Serializable, com.tangosol.io.pof.PortableObject
  private static final int VERSION = 1;
  private static final long serialVersionUID = -1L;
  private int value;
  private boolean flag;
  public int getValue()
    return value;
  public void setValue( int value )
    this.value = value;
  public boolean isFlag()
    return flag;
  public void setFlag( boolean flag )
    this.flag = flag;
  @Override
  public void readExternal( PofReader reader ) throws IOException
    value = reader.readInt( 0 );
    flag = reader.readBoolean( 1 );
  @Override
  public void writeExternal( PofWriter writer ) throws IOException
    writer.writeInt( 0, value );
    writer.writeBoolean( 1, flag );
  @Override
  public int getImplVersion()
    return VERSION ;
public class CustomComparator1 implements java.io.Serializable, Comparator<CacheItem>, com.tangosol.io.pof.PortableObject
  private static final long serialVersionUID = -1L;
  private int sortOrder = 1 ;
  private Integer key ;
  public CustomComparator1(){}
  public CustomComparator1( Integer key )
    this.key = key ;
  @Override
  public int compare( CacheItem item1, CacheItem item2 )
    return sortOrder * ( getValue( item1 ).compareTo( getValue( item2 ) )  ) ;
  private Integer getValue( CacheItem item )
    int value = item.getItem1().iterator().next().getItem1().get( key ).getValue() ;
    return new Integer( value ) ;
  @Override
  public void readExternal( PofReader reader ) throws IOException
    sortOrder = reader.readInt( 0 ) ;
    key = reader.readInt( 1 ) ;
  @Override
  public void writeExternal( PofWriter writer ) throws IOException
    writer.writeInt( 0, sortOrder ) ;
    writer.writeInt( 1, key ) ;
  public void setAscendingOrder()
    sortOrder = 1 ;
  public void setDescendingOrder()
    sortOrder = -1 ;
public class CustomFilter1 implements Filter, java.io.Serializable, com.tangosol.io.pof.PortableObject
  private static final long serialVersionUID = -1L;
  private Integer key = null ;
  public CustomFilter1(){}
  public CustomFilter1( Integer key )
    super() ;
    this.key = key ;
  @Override
  public boolean evaluate( Object item )
    for( CacheSubItem1 subItem1: ((CacheItem)item).getItem1() )
      CacheSubItem2 subItem2 = subItem1.getItem1().get( key );
      if(null!=subItem2){
        return true ;
    return false ;
  @Override
  public void readExternal( PofReader reader ) throws IOException
    key = reader.readInt( 0 ) ;
  @Override
  public void writeExternal( PofWriter writer ) throws IOException
    writer.writeInt( 0, key ) ;
public class CustomProcessor1 extends AbstractProcessor implements PortableObject
  private static final long serialVersionUID = -1L;
  private Integer key ;
  private Set<String> item2s = new HashSet<String>();
  public CustomProcessor1(){}
  public CustomProcessor1( Integer key, Set<String> item2s )
    this.key = key ;
    this.item2s = item2s ;
  @Override
  public Object process( com.tangosol.util.InvocableMap.Entry entry )
    if ( !entry.isPresent() )
      return null ;
    CacheItem item = (CacheItem)entry.getValue() ;
    return extract( item ) ;
  public CacheItem extract( CacheItem item )
    CacheItem extract = new CacheItem() ;
    extract.setCacheItemId( item.getCacheItemId() );
    Set<CacheSubItem1> item1s = item.getItem1() ;
    for( CacheSubItem1 item1: item1s )
      extract.getItem1().add( getExtractedItem1( item1 ) ) ;
    for( String item2: item2s )
      if( item.getItem2().contains( item2 ) )
        extract.getItem2().add( item2 );
    return extract ;
  private CacheSubItem1 getExtractedItem1( CacheSubItem1 hydrated )
    CacheSubItem1 extracted = new CacheSubItem1() ;
    extracted.getItem1().put( key, hydrated.getItem1().get( key ) ) ;
    return extracted ;
  public Integer getKey()
    return key;
  public void setKey( Integer key )
    this.key = key;
  public Set< String > getItem2s()
    return item2s;
  public void setItem2s( Set< String > item2s )
    this.item2s = item2s;
  @SuppressWarnings( "unchecked" )
  @Override
  public void readExternal( PofReader reader ) throws IOException
    key = reader.readInt( 0 ) ;
    item2s = (Set<String>)reader.readCollection( 1, item2s );
  @Override
  public void writeExternal( PofWriter writer ) throws IOException
    writer.writeInt( 0, key ) ;
    writer.writeCollection( 1, item2s );
}3. Cache data loader:
public class CacheDataLoader
  public static final String BASE_ITEM2_KEY = "12345678901234567890";
  public static final char[] VALID_CHARS =
  {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J',
  'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'T', 'U',
  'V', 'W', 'X', 'Y', 'Z', '1', '2', '3', '4',
  '5', '6', '7', '8', '9', '0'} ;
  public static final int NUMBER_OF_ITEM2 = 1000 ;
  public static final int NUMBER_OF_ITEM3 = 1000 ;
  public static final int NUMBER_OF_ITEM = 20000;
  public static final int BATCH_LOAD_SIZE = 10000 ;
  public static final int NUMBER_OF_KEYS_PER_SUBITEM1 = 50;
  public static final int MULITPLE_ITEM1_FREQUENCY = 1000 ;
  public static final int NUMBER_OF_MULTIPLE_ITEM1 = 1;
  public static final int MULITPLE_ITEM2_FREQUENCY = 2;
  public static final int NUMBER_OF_MULTIPLE_ITEM2 = 3;
  public static final int MULITPLE_ITEM3_FREQUENCY = 2;
  public static final int NUMBER_OF_MULTIPLE_ITEM3 = 5;
  public static final long BASE_CACHE_ITEM_KEY = 10000000 ;
  public static final long BASE_ITEM3_KEY = 10000000;
  private long item3Count = 0;
  private long item2Count = 0;
  private long cacheItemCount = 0;
  private NamedCache cache = CacheFactory.getCache( "cache-data" ) ;
  public static void main( String[] args )
    CacheDataLoader loader = new CacheDataLoader() ;
    loader.load() ;
    loader.createIndices() ;
  private void createIndices()
    cache.addIndex( new KeyExtractor( IdentityExtractor.INSTANCE ), false, null );
    cache.addIndex( new ReflectionExtractor( "getItem2" ), false, null );
    cache.addIndex( new ReflectionExtractor( "getItem3" ), false, null );
  private void load()
    long start = System.currentTimeMillis();
    cache.clear();
    int iterations = NUMBER_OF_ITEM/BATCH_LOAD_SIZE ;
    for ( int i=0;i<iterations; i++ )
      cache.putAll( getCacheItems( BATCH_LOAD_SIZE ) );
    System.out.println( "CACHE LOAD: Instances: " + cache.size() + " keysize: " + NUMBER_OF_KEYS_PER_SUBITEM1 + " Time: " + ( System.currentTimeMillis() - start ) );
  private Map<Long, CacheItem> getCacheItems( int loadSize )
    Map<Long, CacheItem> cacheItems = new HashMap<Long, CacheItem>() ;
    for( int i=0; i<loadSize; i++)
      CacheItem cacheItem = getCacheItem();
      cacheItems.put( cacheItem.getCacheItemId(), cacheItem ) ;
    return cacheItems ;
  private CacheItem getCacheItem()
    CacheItem cacheItem = new CacheItem();
    cacheItem.setCacheItemId( getNextCacheItemId() );
    cacheItem.setItem1( getItem1() ) ;
    cacheItem.setItem2( getItem2() );
    cacheItem.setItem3( getItem3() );
    return cacheItem;
  private Set<Long> getItem3()
    Set<Long> item3s = new HashSet<Long>() ;
    //First item3
    item3s.add( getNextItem3Id() ) ;
    //Additional item3s
    if( isAdditionalItem3Required() )
      for(int i=0; i<NUMBER_OF_MULTIPLE_ITEM3; ++i){
        item3s.add( getNextItem3Id() ) ;
    return item3s;
  private Set<String> getItem2()
    Set<String> item2s = new HashSet<String>() ;
    //First item2
    item2s.add( getNextItem2Id() ) ;
    //Additional item2s
    if( isAdditionalItem2Required() )
      for(int i=0; i<NUMBER_OF_MULTIPLE_ITEM2; ++i){
        item2s.add( getNextItem2Id() ) ;
    return item2s;
  private Set<CacheSubItem1> getItem1()
    Set<CacheSubItem1> item1s = new HashSet<CacheSubItem1>() ;
    //First item1
    item1s.add( getSubItem1() ) ;
    //Additional item1s
    if( isAdditionalItem1Required() )
      for(int i=0; i<NUMBER_OF_MULTIPLE_ITEM1; ++i){
        item1s.add( getSubItem1() ) ;
    return item1s;
  private CacheSubItem1 getSubItem1()
    CacheSubItem1 item = new CacheSubItem1() ;
    item.setItem1( getSubItemMap( NUMBER_OF_KEYS_PER_SUBITEM1 ) ) ;
    return item;
  private Map<Integer, CacheSubItem2> getSubItemMap( int numberPriceKeys )
    Map<Integer, CacheSubItem2> items = new HashMap<Integer, CacheSubItem2>();
    for ( int x = 0; x < numberPriceKeys; x++ )
      Integer key = x;
      items.put( key, getSubItem2() );
    return items;
  private CacheSubItem2 getSubItem2()
    CacheSubItem2 item = new CacheSubItem2() ;
    item.setFlag( RandomUtils.nextBoolean() ) ;
    item.setValue( getRandomValue() ) ;
    return item;
  private boolean isAdditionalItem1Required()
    return cacheItemCount%MULITPLE_ITEM1_FREQUENCY == 0;
  private boolean isAdditionalItem2Required()
    return cacheItemCount%MULITPLE_ITEM2_FREQUENCY == 0;
  private boolean isAdditionalItem3Required()
    return cacheItemCount%MULITPLE_ITEM3_FREQUENCY == 0;
  private long getNextCacheItemId()
    return BASE_CACHE_ITEM_KEY + (++cacheItemCount);
  private long getNextItem3Id()
    return BASE_ITEM3_KEY + (++item3Count%NUMBER_OF_ITEM3);
  private String getNextItem2Id()
    return BASE_ITEM2_KEY + (++item2Count%NUMBER_OF_ITEM2);
  private int getRandomValue()
    return RandomUtils.nextInt( 10000 ) ;
}4. Test Case:
public class TestExampleCache extends TestCase
  public void testLimitFilter1()
    final Integer key = getKey();
    Set<String> item2 = getItem2();
    Set<Long> item3 = getItem3();
    CustomComparator1 comparator = new CustomComparator1(key);
    comparator.setAscendingOrder();
    Filter[] filterArray = { new ContainsAnyFilter( "getItem2", item2 ),
                             new ContainsAnyFilter( "getItem3", item3 ),
                             new CustomFilter1( key ) };
    Filter allFilter = new AllFilter( filterArray ) ;
    CustomProcessor1 processor = new CustomProcessor1(key,item2);
    Set<Map.Entry<Long, CacheItem>> result1 = CacheFactory.getCache( "cache-data" ).entrySet( allFilter,comparator );
    for(Map.Entry<Long, CacheItem> entry : result1 ){
      CacheItem item = processor.extract( entry.getValue() );
      System.out.println(item.getCacheItemId()+"-"+item.getItem1().iterator().next().getItem1().values().iterator().next().getValue());
    System.out.println();
  public void testLimitFilter2()
    final Integer key = getKey();
    final int numberOfProducts = 10;
    Set<String> item2 = getItem2();
    Set<Long> item3 = getItem3();
    CustomComparator1 comparator = new CustomComparator1(key);
    comparator.setAscendingOrder();
    Filter[] filterArray = { new ContainsAnyFilter( "getItem2", item2 ),
                             new ContainsAnyFilter( "getItem3", item3 ),
                             new CustomFilter1( key ) };
    Filter allFilter = new AllFilter( filterArray ) ;
    LimitFilter limitFilter = new LimitFilter(allFilter, numberOfProducts);
    CustomProcessor1 processor = new CustomProcessor1(key,item2);
    Set<Map.Entry<Long, CacheItem>> result1 = CacheFactory.getCache( "cache-data" ).entrySet( limitFilter,comparator );
    for(Map.Entry<Long, CacheItem> entry : result1 ){
      CacheItem item = processor.extract( entry.getValue() );
      System.out.println(item.getCacheItemId()+"-"+item.getItem1().iterator().next().getItem1().values().iterator().next().getValue());
    System.out.println();
    limitFilter.nextPage();
    Set<Map.Entry<Long, CacheItem>> result2 = CacheFactory.getCache( "cache-data" ).entrySet( limitFilter,comparator );
    for(Map.Entry<Long, CacheItem> entry : result2 ){
      CacheItem item = processor.extract( entry.getValue() );
      System.out.println(item.getCacheItemId()+"-"+item.getItem1().iterator().next().getItem1().values().iterator().next().getValue());
  private Integer getKey()
    return new Integer(10);
  private Set<String> getItem2()
    Set<String> items = new HashSet<String>();
    items.add( "12345678901234567890" + 1 );
    items.add( "12345678901234567890" + 2 );
    items.add( "12345678901234567890" + 3 );
    items.add( "12345678901234567890" + 4 );
    items.add( "12345678901234567890" + 5 );
    items.add( "12345678901234567890" + 6 );
    items.add( "12345678901234567890" + 7 );
    items.add( "12345678901234567890" + 8 );
    items.add( "12345678901234567890" + 9 );
    items.add( "12345678901234567890" + 10 );
    items.add( "12345678901234567890" + 11 );
    items.add( "12345678901234567890" + 12 );
    return items;
  private Set<Long> getItem3()
    Set<Long> items = new HashSet<Long>();
    items.add( new Long(10000001) );
    items.add( new Long(10000002) );
    items.add( new Long(10000003) );
    items.add( new Long(10000004) );
    items.add( new Long(10000005) );
    items.add( new Long(10000006) );
    items.add( new Long(10000007) );
    items.add( new Long(10000008) );
    items.add( new Long(10000009) );
    items.add( new Long(10000010) );
    return items;
}5. Results:
a. testLimitFilter1()
10010001-109
10002002-121
10002004-487
10006003-726
10008004-762
10000004-845
10010003-922
10014003-1157
10012002-1426
10008002-1585
10002003-1709
10004004-2004
10004001-2179
10018002-2452
10016004-3073
10012004-3145
10008001-3249
10018001-3270
10008003-3319
10016002-3778
10012001-4256
10012003-4391
10002001-4921
10006002-5072
10000002-5162
10016003-5777
10014004-6068
10000001-6260
10000003-6373
10004002-6615
10014001-7679
10006001-7729
10006004-7794
10010002-8188
10010004-8215
10018004-8258
10016001-8383
10018003-8760
10004003-9652
10014002-9876
b. testLimitFilter2()
Page-1
10002004-487
10000004-845
10012002-1426
10008002-1585
10004004-2004
10018001-3270
10016003-5777
10006004-7794
10016001-8383
10018003-8760
Page-2
10018002-2452
10008001-3249
10008003-3319
10016002-3778
10012001-4256
10012003-4391
10014004-6068
10000003-6373
10010002-8188
10010004-8215
c. Expected results:
Page-1
10010001-109
10002002-121
10002004-487
10006003-726
10008004-762
10000004-845
10010003-922
10014003-1157
10012002-1426
10008002-1585
Page-2
10002003-1709
10004004-2004
10004001-2179
10018002-2452
10016004-3073
10012004-3145
10008001-3249
10018001-3270
10008003-3319
10016002-3778
Edited by: user8065775 on Oct 21, 2009 3:02 PM
PS : Looks like the following thread addresses the problem that I have mentioned, which has links to download the source code but they do not work. Is there a way that I can access the java source pointed to in the post pointed to by the following link?
Re: The question about the locking of the cache
SortByMethodNameAggregator.java
SortByMethodNameCaller.java
Can you please email me the code to [email protected]