private DBQuery.Query getFindByStateQuery(AlertState state) { if (state == AlertState.RESOLVED) { /* Resolved alerts: * - Not interval (legacy) * - Interval alerts with non-null resolved_at field */ return DBQuery.or( DBQuery.notEquals(AlertImpl.FIELD_IS_INTERVAL, true), DBQuery.notEquals(AlertImpl.FIELD_RESOLVED_AT, null) ); } if (state == AlertState.UNRESOLVED) { /* Unresolved alerts: * - Interval alerts with null resolved_at field */ return DBQuery.and( DBQuery.is(AlertImpl.FIELD_IS_INTERVAL, true), DBQuery.is(AlertImpl.FIELD_RESOLVED_AT, null) ); } return DBQuery.empty(); } }
public long countInstallationOfEntityByIdAndFoundOnSystem(ModelId entityId) { final DBQuery.Query query = DBQuery.elemMatch(ContentPackInstallation.FIELD_ENTITIES, DBQuery.and( DBQuery.is(NativeEntityDescriptor.FIELD_ENTITY_FOUND_ON_SYSTEM, true), DBQuery.is(NativeEntityDescriptor.FIELD_META_ID, entityId.id()))); return dbCollection.getCount(query); } }
@Override public DBQuery.Query buildQuery(String key, Object value) { return DBQuery.greaterThan(key, value); } }
public Collection<IndexFieldTypesDTO> findForFieldNamesAndIndices(Collection<String> fieldNames, Collection<String> indexNames) { final DBQuery.Query query = DBQuery.and( DBQuery.in(IndexFieldTypesDTO.FIELD_INDEX_NAME, indexNames), DBQuery.in(FIELDS_FIELD_NAMES, fieldNames) ); return findByQuery(query); }
@Override public DBQuery.Query buildQuery(String key, Object value) { return DBQuery.is(key, value); } }
@Override public SortedSet<IndexRange> find(DateTime begin, DateTime end) { final DBQuery.Query query = DBQuery.or( DBQuery.and( DBQuery.notExists("start"), // "start" has been used by the old index ranges in MongoDB DBQuery.lessThanEquals(IndexRange.FIELD_BEGIN, end.getMillis()), DBQuery.greaterThanEquals(IndexRange.FIELD_END, begin.getMillis()) ), DBQuery.and( DBQuery.notExists("start"), // "start" has been used by the old index ranges in MongoDB DBQuery.lessThanEquals(IndexRange.FIELD_BEGIN, 0L), DBQuery.greaterThanEquals(IndexRange.FIELD_END, 0L) ) ); try (DBCursor<MongoIndexRange> indexRanges = collection.find(query)) { return ImmutableSortedSet.copyOf(IndexRange.COMPARATOR, (Iterator<? extends IndexRange>) indexRanges); } }
public DBQuery.Query toDBQuery() { if (queryMap.isEmpty()) { return DBQuery.empty(); } final List<DBQuery.Query> dbQueries = new ArrayList<>(); for (Map.Entry<String, Collection<SearchQueryParser.FieldValue>> entry : queryMap.asMap().entrySet()) { final List<DBQuery.Query> queries = new ArrayList<>(); final List<SearchQueryParser.FieldValue> include = selectValues(entry.getValue(), value -> !value.isNegate()); final List<SearchQueryParser.FieldValue> exclude = selectValues(entry.getValue(), SearchQueryParser.FieldValue::isNegate); if (!include.isEmpty()) { queries.add(DBQuery.or(toQuery(entry.getKey(), include))); } if (!exclude.isEmpty()) { queries.add(DBQuery.nor(toQuery(entry.getKey(), exclude))); } dbQueries.add(DBQuery.and(queries.toArray(new DBQuery.Query[0]))); } return DBQuery.and(dbQueries.toArray(new DBQuery.Query[0])); }
@Override public IndexRange get(String index) throws NotFoundException { final DBQuery.Query query = DBQuery.and( DBQuery.notExists("start"), DBQuery.is(IndexRange.FIELD_INDEX_NAME, index)); final MongoIndexRange indexRange = collection.findOne(query); if (indexRange == null) { throw new NotFoundException("Index range for index <" + index + "> not found."); } return indexRange; }
/** * Returns an unordered stream of all entries in the database. * <p> * The returned stream needs to be closed to free the underlying database resources. * * @return stream of all database entries */ public Stream<DTO> streamAll() { return streamQuery(DBQuery.empty()); }
public TrafficHistogram clusterTrafficOfLastDays(Duration duration, Interval interval) { final ImmutableMap.Builder<DateTime, Long> inputBuilder = ImmutableMap.builder(); final ImmutableMap.Builder<DateTime, Long> outputBuilder = ImmutableMap.builder(); final ImmutableMap.Builder<DateTime, Long> decodedBuilder = ImmutableMap.builder(); final DateTime to = getDayBucket(Tools.nowUTC()); final DateTime from = to.minus(duration); final DBQuery.Query query = DBQuery.and( DBQuery.lessThanEquals(BUCKET, to), DBQuery.greaterThan(BUCKET, from) ); try (DBCursor<TrafficDto> cursor = db.find(query)) { cursor.forEach(trafficDto -> { inputBuilder.put(trafficDto.bucket(), trafficDto.input().values().stream().mapToLong(Long::valueOf).sum()); outputBuilder.put(trafficDto.bucket(), trafficDto.output().values().stream().mapToLong(Long::valueOf).sum()); decodedBuilder.put(trafficDto.bucket(), trafficDto.decoded().values().stream().mapToLong(Long::valueOf).sum()); }); Map<DateTime, Long> inputHistogram = inputBuilder.build(); Map<DateTime, Long> outputHistogram = outputBuilder.build(); Map<DateTime, Long> decodedHistogram = decodedBuilder.build(); // we might need to aggregate the hourly database values to their UTC daily buckets if (interval == Interval.DAILY) { inputHistogram = aggregateToDaily(inputHistogram); outputHistogram = aggregateToDaily(outputHistogram); decodedHistogram = aggregateToDaily(decodedHistogram); } return TrafficHistogram.create(from, to, inputHistogram, outputHistogram, decodedHistogram); } }
private DBQuery.Query getFindAnyStreamQuery(List<String> streamIds) { final List<DBQuery.Query> streamQueries = streamIds.stream() .map(streamId -> DBQuery.is(AlertImpl.FIELD_STREAM_ID, streamId)) .collect(Collectors.toList()); return DBQuery.or(streamQueries.toArray(new DBQuery.Query[streamQueries.size()])); }
@Override public Set<GrokPattern> bulkLoad(Collection<String> patternIds) { final DBCursor<GrokPattern> dbCursor = dbCollection.find(DBQuery.in("_id", patternIds)); return ImmutableSet.copyOf((Iterator<GrokPattern>) dbCursor); }
public void replaceVariableNames(String oldName, String newName) { final DBQuery.Query query = DBQuery.regex(Configuration.FIELD_TEMPLATE, Pattern.compile(Pattern.quote(oldName))); List<Configuration> configurations = findByQuery(query); for (Configuration config : configurations) { final String newTemplate = config.template().replace(oldName, newName); db.findAndModify(DBQuery.is("_id", config.id()), new BasicDBObject(), new BasicDBObject(), false, config.toBuilder().template(newTemplate).build(), true, true); } }
@Override public List<Alert> loadRecentOfStreams(List<String> streamIds, DateTime since, int limit) { if (streamIds == null || streamIds.isEmpty()) { return Collections.emptyList(); } final DateTime effectiveSince = (since == null ? new DateTime(0L, DateTimeZone.UTC) : since); final DBQuery.Query query = DBQuery.and( getFindAnyStreamQuery(streamIds), DBQuery.greaterThanEquals(AlertImpl.FIELD_TRIGGERED_AT, effectiveSince) ); return Collections.unmodifiableList(this.coll.find(query) .limit(limit) .sort(DBSort.desc(AlertImpl.FIELD_TRIGGERED_AT)) .toArray()); }
@Override public long totalCountForStreams(List<String> streamIds, AlertState state) { if (streamIds == null || streamIds.isEmpty()) { return 0; } DBQuery.Query query = getFindAnyStreamQuery(streamIds); if (state != null && state != AlertState.ANY) { query = DBQuery.and(query, getFindByStateQuery(state)); } return this.coll.count(this.coll.serializeQuery(query)); }
@Override public DBQuery.Query buildQuery(String key, Object value) { return DBQuery.lessThan(key, value); } }
@Override public DBQuery.Query buildQuery(String key, Object value) { return DBQuery.greaterThanEquals(key, value); } }