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])); }
@Nullable public Collector findByNameAndOs(String name, String operatingSystem) { return db.findOne( DBQuery.and( DBQuery.is("name", name), DBQuery.is("node_operating_system", operatingSystem)) ); }
@Nullable public Collector findByNameExcludeId(String name, String id) { return db.findOne( DBQuery.and( DBQuery.is("name", name), DBQuery.notEquals("_id", id)) ); }
@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)); }
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 int delete(String roleName) { final DBQuery.Query nameMatchesAndNotReadonly = and(is(READ_ONLY, false), is(NAME_LOWER, roleName.toLowerCase(Locale.ENGLISH))); return dbCollection.remove(nameMatchesAndNotReadonly).getN(); }
@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 Optional<Alert> getLastTriggeredAlert(String streamId, String conditionId) { final List<AlertImpl> alert = this.coll.find( DBQuery.and( DBQuery.is(AlertImpl.FIELD_STREAM_ID, streamId), DBQuery.is(AlertImpl.FIELD_CONDITION_ID, conditionId) ) ) .sort(DBSort.desc(AlertImpl.FIELD_TRIGGERED_AT)) .limit(1) .toArray(); if (alert == null || alert.size() == 0) { return Optional.empty(); } return Optional.of(alert.get(0)); }
@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 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); } }
@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; }
@Override public List<Alert> listForStreamIds(List<String> streamIds, AlertState state, int skip, int limit) { if (streamIds == null || streamIds.isEmpty()) { return Collections.emptyList(); } DBQuery.Query query = getFindAnyStreamQuery(streamIds); if (state != null && state != AlertState.ANY) { query = DBQuery.and(query, getFindByStateQuery(state)); } return Collections.unmodifiableList(this.coll.find(query) .sort(DBSort.desc(AlertImpl.FIELD_TRIGGERED_AT)) .skip(skip) .limit(limit) .toArray()); }
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); } }
public boolean hasConflict(ConfigurationVariable variable) { final DBQuery.Query query; if (isNullOrEmpty(variable.id())) { query = DBQuery.is(ConfigurationVariable.FIELD_NAME, variable.name()); } else { // updating an existing variable, don't match against itself query = DBQuery.and( DBQuery.is(ConfigurationVariable.FIELD_NAME, variable.name()), DBQuery.notEquals("_id", variable.id() ) ); } return db.getCount(query) > 0; }
public Optional<IndexFieldTypesDTO> upsert(IndexFieldTypesDTO dto) { final WriteResult<IndexFieldTypesDTO, ObjectId> update = db.update( DBQuery.and( DBQuery.is(IndexFieldTypesDTO.FIELD_INDEX_NAME, dto.indexName()), DBQuery.is(IndexFieldTypesDTO.FIELD_INDEX_SET_ID, dto.indexSetId()) ), dto, true, false ); final Object upsertedId = update.getUpsertedId(); if (upsertedId instanceof ObjectId) { return get(((ObjectId) upsertedId).toHexString()); } else if (upsertedId instanceof String) { return get((String) upsertedId); } return Optional.empty(); }
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(); } }
@Override public int delete(String roleName) { final DBQuery.Query nameMatchesAndNotReadonly = and(is(READ_ONLY, false), is(NAME_LOWER, roleName.toLowerCase(Locale.ENGLISH))); return dbCollection.remove(nameMatchesAndNotReadonly).getN(); }
@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 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 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; }