import net.sf.ehcache.search.Results; //导入依赖的package包/类
/**
 * Use the Ehcache provided search API to perform criteria queries on defined search attributes.
 * NOTE: Requires search attributes to be previously defined in Ehcache config!
 * DEPRECATED because at observed large cache quantities the search noticeably slows down the system
 * @param params the search parameters as key/value pairs
 * @return the first found cache hit
 */
@Deprecated
@SuppressWarnings("unchecked")
public VALUE lookup(Map<String, String> params) {
    Query q = cache.createQuery();

    for (Map.Entry<String, String> param : params.entrySet()) {
        Attribute<String> theAttribute = ((Ehcache) cache).getSearchAttribute(param.getKey());
        q.addCriteria(theAttribute.eq(param.getValue()));
    }

    q.includeKeys().includeValues();
    Results results = q.execute();

    if (results == null || results.size() == 0) {
        return null;
    }

    if (results.size() > 1) {
        log.warn("There are multiple entries registered for params: {}", params.toString());
    }

    return (VALUE) results.all().get(0).getValue();
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
@Override
public List<Device> getByDeviceClassId(Long deviceClassId) {
  List<Device> deviceCacheObjects = new ArrayList<>();

  Results results = null;

  try {
    Query query = getCache().createQuery();
    Attribute<Long> id = getCache().getSearchAttribute("deviceClassId");
    results = query.includeKeys().includeValues().addCriteria(id.eq(deviceClassId)).execute();

    if (results.size() == 0) {
      throw new CacheElementNotFoundException("Failed to get device ids from cache");
    }

    results.all().forEach((result) -> deviceCacheObjects.add((DeviceCacheObject) result.getValue()));
  } finally {
    if (results != null) {
      results.discard();
    }
  }

  return deviceCacheObjects;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
private void cleanCaches(ObjectId objectId, Instant fromVersion, Instant toVersion) {

    Results results = getUidToDocumentCache().createQuery().includeKeys()
        .includeAttribute(getUidToDocumentCache().getSearchAttribute("ObjectId"))
        .includeAttribute(getUidToDocumentCache().getSearchAttribute("VersionFromInstant"))
        .includeAttribute(getUidToDocumentCache().getSearchAttribute("VersionToInstant"))
        .addCriteria(getUidToDocumentCache().getSearchAttribute("ObjectId")
                         .eq(objectId.toString()))
        .addCriteria(getUidToDocumentCache().getSearchAttribute("VersionFromInstant")
                         .le((fromVersion != null ? fromVersion : InstantExtractor.MIN_INSTANT).toString()))
        .addCriteria(getUidToDocumentCache().getSearchAttribute("VersionToInstant")
                         .ge((toVersion != null ? toVersion : InstantExtractor.MAX_INSTANT).toString()))
        .execute();

    for (Result result : results.all()) {
      getUidToDocumentCache().remove(result.getKey());
    }
  }
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
private List searchPartitionKeys(final Query query) {
	LinkedList<Object> keys = new LinkedList<Object>();
	System.out.println("Starting search...");
	long startTime = System.currentTimeMillis();
	Results results = query.execute();
	if(log.isDebugEnabled())
		log.debug(String.format("Search time: %d ms", System.currentTimeMillis() - startTime));

	// perform the refresh
	for (Result result : results.all()) {
		keys.add(result.getKey());
	}

	results.discard();

	return keys;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
public Collection<T> fetchByCriteria( Criteria criteria ) {
    net.sf.ehcache.search.Query query = this.cache.createQuery();
    query.includeValues();
    query.addCriteria( criteria );
    Results results = null;
    try {
        results = query.execute();
    } catch ( Exception e ) {
        throw new SearchException( "Query error" );
    }

    if ( results == null ) {
        return null;
    }

    Collection<T> genes = new HashSet<T>( results.size() );

    for ( Result result : results.all() ) {
        genes.add( ( T ) result.getValue() );
    }

    return genes;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
@Override
public DomainRoleEntry getDomainRole(String uid, Role role) {
    Cache cache = getCache(CacheId.DOMAIN_ROLES);
    Attribute<String> uidAttribute = cache.getSearchAttribute(UserRoleKey.USER_ID);
    Attribute<Role> roleAttribute = cache.getSearchAttribute(UserRoleKey.ROLE);
    // query is the fastest if you search for keys and if you need value then call Cache.get(key)
    Query queryRequestedUid = cache.createQuery()
                                   .addCriteria(uidAttribute.eq(uid))
                                   .addCriteria(roleAttribute.eq(role))
                                   .includeKeys()
                                   .end();
    Results results = queryRequestedUid.execute();
    DomainRoleEntry domainRole = null;
    if (!results.all().isEmpty()) {
        // Note: since (uid, role) is the primary key in domain role table
        // results is either empty or contains exactly one entry
        assert (results.all().size() == 1);
        domainRole = (DomainAccessControlStoreEhCache.<DomainRoleEntry> getElementValue(cache.get(results.all()
                                                                                                         .get(0)
                                                                                                         .getKey())));
    }

    return domainRole;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
private <T extends ControlEntry> List<T> getAces(String uid, CacheId cacheId) {
    Cache cache = getCache(cacheId);
    List<T> aces = new ArrayList<T>();
    // here search on uid take place
    Attribute<String> uidAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.USER_ID);
    // query is the fastest if you search for keys and if you need value then call Cache.get(key)
    Query queryRequestedUid = cache.createQuery().addCriteria(uidAttribute.eq(uid).or(uidAttribute.eq(WILDCARD)))
    // have specific user ids appear before wildcards
                                   .addOrderBy(uidAttribute, Direction.DESCENDING)
                                   .includeKeys()
                                   .end();
    Results results = queryRequestedUid.execute();
    for (Result result : results.all()) {
        aces.add(DomainAccessControlStoreEhCache.<T> getElementValue(cache.get(result.getKey())));
    }

    return aces;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
@Override
public Long getDeviceClassIdByName(String deviceClassName) {
  Long deviceClassId;

  if (deviceClassName == null || deviceClassName.equalsIgnoreCase("")) {
    throw new IllegalArgumentException("Attempting to retrieve a DeviceClass from the cache with a NULL or empty name parameter.");
  }

  Results results = null;
  try {
    Attribute<String> className = getCache().getSearchAttribute("deviceClassName");
    Query query = getCache().createQuery();
    results = query.includeKeys().addCriteria(className.eq(deviceClassName)).maxResults(1).execute();

    if (results.size() == 0) {
      throw new CacheElementNotFoundException("Failed to find a device class with name " + deviceClassName + " in the cache.");
    }

    deviceClassId = (long) results.all().get(0).getKey();
  } finally {
    if (results != null) {
      results.discard();
    }
  }

  return deviceClassId;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
@Override
public boolean hasTagWithName(String name) {
  if (name == null || name.equalsIgnoreCase("")) {
    throw new IllegalArgumentException("Attempting to retrieve a Tag from the cache with a NULL or empty name parameter.");
  }

  // This will prevent wildcard searches
  if (name.contains("*")) {
    name = name.replace("*", "\\*");
  }
  if (name.contains("?")) {
    name = name.replace("?", "\\?");
  }

  Results results = null;

  try {
    Ehcache ehcache = getCache();
    Attribute<String> tagName = ehcache.getSearchAttribute("tagName");

    Query query = ehcache.createQuery();
    results = query.includeKeys().addCriteria(tagName.ilike(name)).maxResults(1).execute();

    return results.hasKeys();
  }
  finally {
    if (results != null) {
      // Discard the results when done to free up cache resources.
      results.discard();
    }
  }

}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
/**
 * Receives a list of all DataTag ids which are attached to the given equipment or sub-equipment.
 * @param id The id of the (sub-)equipment
 * @param searchAttribute The ehcache search attribute, which is specified in the wrapper method
 * @return A list of all DataTag ids belonging to the given (sub-)equipment
 */
private List<Long> getDataTagIds(Long id, String searchAttribute) {
  List<Long> tagIds = new LinkedList<>();
  Results results = null;

  if (id == null) {
    throw new IllegalArgumentException("Attempting to retrieve a List of DataTag ids from the cache with a NULL " +
        "parameter.");
  }

  try {
    Attribute<Long> cacheEquipmentId = getCache().getSearchAttribute(searchAttribute);
    results = getCache().createQuery().includeKeys().addCriteria(cacheEquipmentId.eq(id)).execute();

    if (results == null) {
      throw new CacheElementNotFoundException("Failed to execute query with (sub)EquipmentId " + id + " : " +
          "Result is null.");
    }

    results.all().forEach(r -> tagIds.add((Long) r.getKey()));

  } finally {
    if (results != null) {
      // Discard the results when done to free up cache resources.
      results.discard();
    }
  }
  return tagIds;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
@Override
public Long getProcessId(final String name) {
  Long processKey = null;
  Results results = null;

  if (name == null || name.equalsIgnoreCase("")) {
    throw new IllegalArgumentException("Attempting to retrieve a Process from the cache with a NULL or empty name parameter.");
  }

  try {
    Attribute<String> processName = getCache().getSearchAttribute("processName");
    // By limiting the query result list to 1 it is up to the administrator to
    // make
    // sure that the process name is unique. Otherwise this will result in an
    // unpredictable behaviour.
    Query query = getCache().createQuery();
    results = query.includeKeys().addCriteria(processName.eq(name)).maxResults(1).execute();

    // Find the number of results -- the number of hits.
    int size = results.size();
    if (size == 0) {
      throw new CacheElementNotFoundException("Failed to find a process with name " + name + " in the cache.");
    }

    processKey = (Long) results.all().get(0).getKey();
  }
  finally {
    if (results != null) {
      // Discard the results when done to free up cache resources.
      results.discard();
    }
  }

  return processKey;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
@Override
public Long getCommandTagId(final String name) {
  Long commandTagKey = null;
  Results results = null;

  if (name == null || name.equalsIgnoreCase("")) {
    throw new IllegalArgumentException("Attempting to retrieve a CommandTag from the cache with a NULL or empty name parameter.");
  }

  try {
    Attribute<String> commandTagName = getCache().getSearchAttribute("commandTagName");
    Query query = getCache().createQuery();
    results = query.includeKeys().addCriteria(commandTagName.eq(name)).maxResults(1).execute();

    // Find the number of results -- the number of hits.
    int size = results.size();
    if (size == 0) {
      log.info("Failed to find a command tag with name " + name + " in the cache.");
    }

    commandTagKey = results.all().size() > 0 ? (Long) results.all().get(0).getKey() : null;
  }
  finally {
    if (results != null) {
      // Discard the results when done to free up cache resources.
      results.discard();
    }
  }

  return commandTagKey;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
/**
 * Given DSD entry name, clear its corresponding object values from the cache.
 *
 * @param name contains the name of object to be cleared.
 * @param contextId maps to sub-tree in DIT, e.g. ou=contextId, dc=example, dc=com.     *
 * @throws SecurityException in the event of system or rule violation.
 */
void clearDsdCacheEntry(String name, String contextId)
{
    Attribute<String> context = m_dsdCache.getSearchAttribute(CONTEXT_ID);
    Attribute<String> dsdName = m_dsdCache.getSearchAttribute(DSD_NAME);
    Query query = m_dsdCache.createQuery();
    query.includeKeys();
    query.includeValues();
    query.addCriteria(dsdName.eq(name).and(context.eq(contextId)));
    Results results = query.execute();
    for (Result result : results.all())
    {
        m_dsdCache.clear(result.getKey());
    }
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
/**
 * Given a role name, return the set of DSD's that have a matching member.
 *
 * @param name contains name of authorized Role used to search the cache.
 * @param contextId maps to sub-tree in DIT, e.g. ou=contextId, dc=example, dc=com.
 * @return un-ordered set of matching DSD's.
 * @throws SecurityException in the event of system or rule violation.
 */
private Set<SDSet> getDsdCache(String name, String contextId)
    throws SecurityException
{
    contextId = getContextId(contextId);
    Set<SDSet> finalSet = new HashSet<>();
    Attribute<String> context = m_dsdCache.getSearchAttribute(CONTEXT_ID);
    Attribute<String> member = m_dsdCache.getSearchAttribute(SchemaConstants.MEMBER_AT);
    Query query = m_dsdCache.createQuery();
    query.includeKeys();
    query.includeValues();
    query.addCriteria(member.eq(name).and(context.eq(contextId)));
    Results results = query.execute();
    boolean empty = false;
    for (Result result : results.all())
    {
        DsdCacheEntry entry = (DsdCacheEntry) result.getValue();
        if (!entry.isEmpty())
        {
            finalSet.add(entry.getSdSet());
            finalSet = putDsdCache(name, contextId);
        }
        else
        {
            empty = true;
        }
        finalSet.add(entry.getSdSet());
    }
    // If nothing was found in the cache, determine if it needs to be seeded:
    if (finalSet.size() == 0 && !empty)
    {
        finalSet = putDsdCache(name, contextId);
    }
    return finalSet;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
void runTests()
{
    loadCache();
    Attribute<String> member = cache.getSearchAttribute( "member" );
    Query query = cache.createQuery();
    query.includeKeys();
    query.includeValues();
    Set<String> roles = new HashSet<>();
    roles.add( "oamt17dsd1" );
    roles.add( "oamt17dsd4" );
    roles.add( "oamT13DSD6" );
    roles.add( "oamT16SDR7" );
    query.addCriteria( member.in( roles ) );
    Results results = query.execute();
    System.out.println( " Size: " + results.size() );
    System.out.println( "----Results-----\n" );
    Set<SDSet> resultSet = new HashSet<>();

    for ( Result result : results.all() )
    {
        DsdCacheEntry entry = ( DsdCacheEntry ) result.getValue();
        resultSet.add( entry.getSdSet() );
    }

    for ( SDSet sdSet : resultSet )
    {
        LOG.info( "Found SDSet: " + sdSet.getName() );
    }
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
private int performSearch(Criteria... criteria) {
    Query query = createQuery(criteria);
    long start = System.currentTimeMillis();
    Results results = query.execute();
    int count = results.size();
    long duration = System.currentTimeMillis() - start;
    log.info("Searchresult: found {} persons in {} ms.", count, duration);
    results.discard();
    return count;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
@Override
public List<DomainRoleEntry> getDomainRoles(String uid) {
    Cache cache = getCache(CacheId.DOMAIN_ROLES);
    List<DomainRoleEntry> domainRoles = new ArrayList<DomainRoleEntry>();
    Attribute<String> uidAttribute = cache.getSearchAttribute(UserRoleKey.USER_ID);
    // query is the fastest if you search for keys and if you need value then call Cache.get(key)
    Query queryRequestedUid = cache.createQuery().addCriteria(uidAttribute.eq(uid)).includeKeys().end();
    Results results = queryRequestedUid.execute();
    for (Result result : results.all()) {
        domainRoles.add(DomainAccessControlStoreEhCache.<DomainRoleEntry> getElementValue(cache.get(result.getKey())));
    }

    return domainRoles;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
private <T extends ControlEntry> T getAce(CacheId cacheId,
                                          String uid,
                                          String domain,
                                          String interfaceName,
                                          String operation) {
    Cache cache = getCache(cacheId);
    Attribute<String> uidAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.USER_ID);
    Attribute<String> domainAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.DOMAIN);
    Attribute<String> interfaceAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.INTERFACE);
    Attribute<String> operationAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.OPERATION);
    Query queryAllOperations = cache.createQuery()
                                    .addCriteria(uidAttribute.eq(uid).or(uidAttribute.eq(WILDCARD)))
                                    .addCriteria(domainAttribute.eq(domain))
                                    .addCriteria(interfaceAttribute.eq(interfaceName))
                                    .addCriteria(operationAttribute.eq(operation))
                                    // have specific user ids appear before wildcards
                                    .addOrderBy(uidAttribute, Direction.DESCENDING)
                                    .includeKeys()
                                    .end();
    Results results = queryAllOperations.execute();
    T ace = null;
    if (!results.all().isEmpty()) {
        ace = DomainAccessControlStoreEhCache.<T> getElementValue(cache.get(results.all().get(0).getKey()));
    }

    return ace;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
private <T extends ControlEntry> List<T> getEditableAces(String uid, CacheId cacheId, Role role) {
    List<T> aces = new ArrayList<T>();
    // find out first on which domains uid has specified role
    Cache drtCache = getCache(CacheId.DOMAIN_ROLES);
    UserRoleKey dreKey = new UserRoleKey(uid, role);
    String[] uidDomains = null;
    // read domains from DRE
    if (drtCache.isKeyInCache(dreKey)) {
        DomainRoleEntry dre = DomainAccessControlStoreEhCache.<DomainRoleEntry> getElementValue(drtCache.get(dreKey));
        uidDomains = dre.getDomains();
    }
    // if uid has no domains with specified role return empty list
    if (uidDomains == null || uidDomains.length == 0) {
        return aces;
    }

    Cache cache = getCache(cacheId);
    // here should search on uid and domain take place
    Attribute<String> uidAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.USER_ID);
    Attribute<String> domainAttribute = cache.getSearchAttribute(UserDomainInterfaceOperationKey.DOMAIN);
    for (String domain : uidDomains) {
        Query query = cache.createQuery()
                           .addCriteria(uidAttribute.eq(uid).and(domainAttribute.eq(domain)))
                           .includeKeys()
                           .end();
        Results results = query.execute();
        for (Result result : results.all()) {
            aces.add(DomainAccessControlStoreEhCache.<T> getElementValue(cache.get(result.getKey())));
        }

    }

    return aces;
}
 

import net.sf.ehcache.search.Results; //导入依赖的package包/类
public <T> List<T> getValues(Class<T> valueClass, int numMax, Criteria ... criteria) {
    Results results = this.buildQuery(numMax, criteria).includeValues().execute();

    return results.all().stream().map(result -> valueClass.cast(result.getValue())).collect(Collectors.toList());
}