Java Query类代码示例

import org.terracotta.context.query.Query; //导入依赖的package包/类
public static OperationStatistic findOperationStat(Cache<?, ?> cache1, final String statName, final String tag) {
  Query q = queryBuilder()
      .descendants().filter(context(identifier(subclassOf(OperationStatistic.class)))).build();

  Set<TreeNode> operationStatisticNodes = q.execute(Collections.singleton(ContextManager.nodeFor(cache1)));
  Set<TreeNode> result = queryBuilder()
      .filter(
          context(attributes(Matchers.<Map<String, Object>>allOf(
              hasAttribute("name", statName), hasAttribute("tags", new Matcher<Set<String>>() {
                @Override
                protected boolean matchesSafely(Set<String> object) {
                  return object.contains(tag);
                }
              }))))).build().execute(operationStatisticNodes);

  if (result.size() != 1) {
    throw new RuntimeException("single stat not found; found " + result.size());
  }

  TreeNode node = result.iterator().next();
  return (OperationStatistic) node.getContext().attributes().get("this");
}
 

import org.terracotta.context.query.Query; //导入依赖的package包/类
public static ValueStatistic findValueStat(Cache<?, ?> cache1, final String statName, final String tag) {
  Query q = queryBuilder().chain(self())
      .descendants().filter(context(identifier(subclassOf(ValueStatistic.class)))).build();

  Set<TreeNode> nodes = q.execute(Collections.singleton(ContextManager.nodeFor(cache1)));
  Set<TreeNode> result = queryBuilder()
      .filter(
          context(attributes(Matchers.<Map<String, Object>>allOf(
              hasAttribute("name", statName), hasAttribute("tags", new Matcher<Set<String>>() {
                @Override
                protected boolean matchesSafely(Set<String> object) {
                  return object.contains(tag);
                }
              }))))).build().execute(nodes);

  if (result.size() != 1) {
    throw new RuntimeException("single stat not found; found " + result.size());
  }

  TreeNode node = result.iterator().next();
  return (ValueStatistic) node.getContext().attributes().get("this");
}
 

import org.terracotta.context.query.Query; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static <S extends Enum<S>> OperationStatistic<S> findOperationStat(Object rootNode, final Class<S> statisticType, final String statName) {
  Query q = queryBuilder().descendants()
      .filter(context(identifier(subclassOf(OperationStatistic.class))))
      .filter(context(attributes(Matchers.allOf(
          hasAttribute("name", statName),
          hasAttribute("this", new Matcher<OperationStatistic>() {
            @Override
            protected boolean matchesSafely(OperationStatistic object) {
              return object.type().equals(statisticType);
            }
          })
      )))).build();


  Set<TreeNode> result = q.execute(Collections.singleton(ContextManager.nodeFor(rootNode)));

  if (result.size() != 1) {
    throw new RuntimeException("a single stat was expected; found " + result.size());
  }

  TreeNode node = result.iterator().next();
  return (OperationStatistic<S>) node.getContext().attributes().get("this");
}
 

import org.terracotta.context.query.Query; //导入依赖的package包/类
@Test
public void testClean() {
  StatisticsManager.createPassThroughStatistic(this, "mystat",
      Collections.emptySet(), COUNTER, () -> 12);

  assertTrue(PassThroughStatistic.hasStatisticsFor(this));

  StatisticsManager.nodeFor(this).clean();

  assertFalse(PassThroughStatistic.hasStatisticsFor(this));

  StatisticsManager manager = new StatisticsManager();
  manager.root(this);

  Query query = queryBuilder().descendants().filter(context(attributes(hasAttribute("name", "mystat")))).build();
  Set<TreeNode> nodes = manager.query(query);
  assertThat(nodes, IsEmptyCollection.empty());
}
 

import org.terracotta.context.query.Query; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static <T extends Enum<T>> OperationStatistic<T> findStat(Cache<?, ?> cache, final String statName, final String tag) {
  Query q = queryBuilder().chain(self())
      .descendants().filter(context(identifier(subclassOf(OperationStatistic.class)))).build();

  Set<TreeNode> operationStatisticNodes = q.execute(Collections.singleton(ContextManager.nodeFor(cache)));
  Set<TreeNode> result = queryBuilder()
      .filter(
          context(attributes(Matchers.<Map<String, Object>>allOf(
              hasAttribute("name", statName), hasAttribute("tags", new Matcher<Set<String>>() {
                @Override
                protected boolean matchesSafely(Set<String> object) {
                  return object.contains(tag);
                }
              }))))).build().execute(operationStatisticNodes);

  if (result.size() != 1) {
    throw new RuntimeException("query for unique stat '" + statName + "' with tag '" + tag + "' failed; found " + result.size() + " instance(s)");
  }

  TreeNode node = result.iterator().next();
  return (OperationStatistic<T>) node.getContext().attributes().get("this");
}
 

import org.terracotta.context.query.Query; //导入依赖的package包/类
/**
 * Find an operation statistic attached (as a children) to this context that matches the statistic name and type
 *
 * @param context the context of the query
 * @param type type of the operation statistic
 * @param statName statistic name
 * @param <T> type of the operation statistic content
 * @return the operation statistic searched for
 * @throws RuntimeException if 0 or more than 1 result is found
 */
static <T extends Enum<T>> OperationStatistic<T> findOperationStatisticOnChildren(Object context, Class<T> type, String statName) {
  @SuppressWarnings("unchecked")
  Query query = queryBuilder()
    .children()
    .filter(context(attributes(Matchers.allOf(hasAttribute("name", statName), hasAttribute("type", type)))))
    .build();

  Set<TreeNode> result = query.execute(Collections.singleton(ContextManager.nodeFor(context)));
  if (result.size() > 1) {
    throw new RuntimeException("result must be unique");
  }
  if (result.isEmpty()) {
    throw new RuntimeException("result must not be null");
  }
  @SuppressWarnings("unchecked")
  OperationStatistic<T> statistic = (OperationStatistic<T>) result.iterator().next().getContext().attributes().get("this");
  return statistic;
}
 

import org.terracotta.context.query.Query; //导入依赖的package包/类
/**
 * Find the list of tiers of a cache. We assume a lot of things here.
 * <ul>
 *   <li>The "eviction" statistic is available on the tier</li>
 *   <li>That the tiers have only one tag attribute</li>
 *   <li>That this tag contains the tier name</li>
 *   <li>That the only descendants having an "eviction" statistic are the tiers</li>
 * </ul>
 *
 * @param cache the context for looking for tiers
 * @return an array of tier names
 * @throws RuntimeException if not tiers are found or if tiers have multiple tags
 */
static String[] findTiers(Cache<?, ?> cache) {
  // Here I'm randomly taking the eviction observer because it exists on all tiers
  @SuppressWarnings("unchecked")
  Query statQuery = queryBuilder()
    .descendants()
    .filter(context(attributes(Matchers.allOf(hasAttribute("name", "eviction"), hasAttribute("type", StoreOperationOutcomes.EvictionOutcome.class)))))
    .build();

  Set<TreeNode> statResult = statQuery.execute(Collections.singleton(ContextManager.nodeFor(cache)));

  if (statResult.isEmpty()) {
    throw new RuntimeException("Failed to find tiers using the eviction observer, valid result Set sizes must 1 or more");
  }

  String[] tiers = new String[statResult.size()];

  int i = 0;
  for (TreeNode treeNode : statResult) {
    Set tags = (Set) treeNode.getContext().attributes().get("tags");
    if (tags.size() != 1) {
      throw new RuntimeException("We expect tiers to have only one tag");
    }

    String storeType = tags.iterator().next().toString();
    tiers[i++] = storeType;
  }
  return tiers;
}
 

import org.terracotta.context.query.Query; //导入依赖的package包/类
private Set<TreeNode> queryProperty(String tag) {
  @SuppressWarnings("unchecked")
  Query statQuery = queryBuilder()
    .descendants()
    .filter(context(attributes(Matchers.<Map<String, Object>>allOf(
      hasAttribute("name", "get"),
      hasTag(tag)
    ))))
    .build();

  return statQuery.execute(Collections.singleton(ContextManager.nodeFor(cache)));
}
 

import org.terracotta.context.query.Query; //导入依赖的package包/类
@Test
public void testStatisticsAssociations() throws Exception {
  OffHeapDiskStore.Provider provider = new OffHeapDiskStore.Provider();

 ServiceLocator serviceLocator = dependencySet().with(mock(SerializationProvider.class))
   .with(new DefaultTimeSourceService(null)).with(mock(DiskResourceService.class)).build();
 provider.start(serviceLocator);

 OffHeapDiskStore<Long, String> store = provider.createStore(getStoreConfig(), mock(PersistableResourceService.PersistenceSpaceIdentifier.class));

 @SuppressWarnings("unchecked")
 Query storeQuery = queryBuilder()
   .children()
   .filter(context(attributes(Matchers.<Map<String, Object>>allOf(
     hasAttribute("tags", new Matcher<Set<String>>() {
       @Override
       protected boolean matchesSafely(Set<String> object) {
         return object.containsAll(singleton("Disk"));
       }
     })))))
   .build();

  Set<TreeNode> nodes = singleton(ContextManager.nodeFor(store));

  Set<TreeNode> storeResult = storeQuery.execute(nodes);
  assertThat(storeResult, not(empty()));

  provider.releaseStore(store);

  storeResult = storeQuery.execute(nodes);
  assertThat(storeResult, empty());
}
 

import org.terracotta.context.query.Query; //导入依赖的package包/类
public static void main(String[] args) {
  CacheManager manager = new CacheManager("manager-one");
  Cache<String, String> cache = new Cache<>("cache-one");

  manager.addCache(cache);

  StatisticsManager stats = new StatisticsManager();
  stats.root(manager);

  @SuppressWarnings("unchecked")
  Query query = queryBuilder().descendants().filter(context(Matchers.allOf(identifier(subclassOf(OperationStatistic.class)), attributes(hasAttribute("name", "get"))))).build();
  System.out.println(query);
  TreeNode getStatisticNode = stats.queryForSingleton(query);

  @SuppressWarnings("unchecked")
  OperationStatistic<GetResult> getStatistic = (OperationStatistic<GetResult>) getStatisticNode.getContext().attributes().get("this");
  LatencySampling<GetResult> hitLatency = new LatencySampling<>(of(GetResult.HIT), 1.0f);
  MinMaxAverage hitLatencyStats = new MinMaxAverage();
  hitLatency.addDerivedStatistic(hitLatencyStats);
  getStatistic.addDerivedStatistic(hitLatency);

  cache.get("foo");
  System.err.println("HITS        : " + getStatistic.count(GetResult.HIT));
  System.err.println("MISSES      : " + getStatistic.count(GetResult.MISS));
  System.err.println("HIT LATENCY : " + hitLatencyStats.mean());

  cache.put("foo", "bar");
  cache.get("foo");
  System.err.println("HITS        : " + getStatistic.count(GetResult.HIT));
  System.err.println("MISSES      : " + getStatistic.count(GetResult.MISS));
  System.err.println("HIT LATENCY : " + hitLatencyStats.mean());

  hitLatency.addDerivedStatistic((time, parameters) -> System.out.println("Event Latency : " + parameters[0]));

  cache.get("foo");
  System.err.println("HITS        : " + getStatistic.count(GetResult.HIT));
  System.err.println("MISSES      : " + getStatistic.count(GetResult.MISS));
  System.err.println("HIT LATENCY : " + hitLatencyStats.mean());

  getStatistic.removeDerivedStatistic(hitLatency);

  cache.get("foo");
  System.err.println("HITS        : " + getStatistic.count(GetResult.HIT));
  System.err.println("MISSES      : " + getStatistic.count(GetResult.MISS));
  System.err.println("HIT LATENCY : " + hitLatencyStats.mean());
}
 

import org.terracotta.context.query.Query; //导入依赖的package包/类
/**
 * Return the unique node selected by running this query against this
 * {@code ContextManager}'s root context.
 * <p>
 * If this query does not return a single unique result then an
 * {@code IllegalStateException} will be thrown.  More details on the query
 * execution context can be found in {@link #query(Query)}.
 *
 * @param query the query to execute
 * @return the node selected by the query
 * @throws IllegalStateException if the query does not select a unique node
 * @see #query(Query)
 * @see QueryBuilder#ensureUnique()
 */
public TreeNode queryForSingleton(Query query) throws IllegalStateException {
  return query(queryBuilder().chain(query).ensureUnique().build()).iterator().next();
}