/** * Check to see if this query matches an id. Equivalent to calling {@link #matches(Map)} * with the result of {@link #toMap(Id)}. * * @param id * Id to use when checking for a match. * @return * True if the query expression matches the id. */ default boolean matches(Id id) { return matches(toMap(id)); }
@Override public boolean matches(Map<String, String> tags) { return !q.matches(tags); }
/** * Get an aggregator using the default set of tags for the final result. The tags will * be extracted based on the exact matches for the underlying query. */ default Aggregator aggregator() { return aggregator(query().exactTags(), true); }
private Iterable<TagsValuePair> evalNoCheck(DataExpr expr, Iterable<TagsValuePair> input) { DataExpr.Aggregator aggr = expr.aggregator(expr.query().exactTags(), false); for (TagsValuePair p : input) { aggr.update(p); } return aggr.result(); }
@Override public void update(TagsValuePair p) { if (!shouldCheckQuery || query.matches(p.tags())) { ++aggr; } }
@Override public void update(TagsValuePair p) { Map<String, String> tags = p.tags(); if (!shouldCheckQuery || af.query().matches(tags)) { Map<String, String> newTags = tags.entrySet().stream() .filter(e -> keys.contains(e.getKey())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); aggrs.computeIfAbsent(newTags, ks -> af.aggregator(ks, false)).update(p); } }
@Override public void update(TagsValuePair p) { if (!shouldCheckQuery || query.matches(p.tags())) { aggr += p.value(); ++count; } }
@Override public void update(TagsValuePair p) { Map<String, String> tags = new HashMap<>(p.tags()); if (!shouldCheckQuery || af.query().matches(tags)) { for (String k : keys) { tags.remove(k); } aggrs.computeIfAbsent(tags, ks -> af.aggregator(ks, false)).update(p); } }
@Override public void update(TagsValuePair p) { Map<String, String> tags = p.tags(); if (!shouldCheckQuery || query.matches(tags)) { pairs.add(new TagsValuePair(tags, p.value())); } }
@Override public void update(TagsValuePair p) { Map<String, String> tags = p.tags(); if (!shouldCheckQuery || af.query().matches(tags)) { Map<String, String> k = keyTags(tags); if (k != null) { k.putAll(queryTags); aggrs.computeIfAbsent(k, ks -> af.aggregator(ks, false)).update(p); } } }
@Override public void update(TagsValuePair p) { if ((!shouldCheckQuery || query.matches(p.tags())) && p.value() < aggr) { aggr = p.value(); ++count; } }
@Override public void update(TagsValuePair p) { if ((!shouldCheckQuery || query.matches(p.tags())) && p.value() > aggr) { aggr = p.value(); ++count; } }
@Test public void andQuery() { Query q = parse("name,foo,:eq,bar,baz,:eq,:and"); Assertions.assertFalse(q.matches(registry.createId("foo"))); Assertions.assertFalse(q.matches(registry.createId("bar"))); Assertions.assertTrue(q.matches(registry.createId("foo", "bar", "baz"))); Assertions.assertFalse(q.matches(registry.createId("bar", "bar", "baz"))); Assertions.assertFalse(q.matches(registry.createId("foo", "bar", "def"))); Assertions.assertFalse(q.matches(registry.createId("foo", "abc", "def"))); }
@Test public void orQuery() { Query q = parse("name,foo,:eq,bar,baz,:eq,:or"); Assertions.assertTrue(q.matches(registry.createId("foo"))); Assertions.assertFalse(q.matches(registry.createId("bar"))); Assertions.assertTrue(q.matches(registry.createId("foo", "bar", "baz"))); Assertions.assertTrue(q.matches(registry.createId("bar", "bar", "baz"))); Assertions.assertTrue(q.matches(registry.createId("foo", "bar", "def"))); Assertions.assertTrue(q.matches(registry.createId("foo", "abc", "def"))); }