Example usage for com.mongodb.client.model Filters in

List of usage examples for com.mongodb.client.model Filters in

  1. HOME
  2. Java
  3. com.mongodb
  4. com.mongodb.client.model.*
  5. Filters
  6. in

Introduction

In this page you can find the example usage for com.mongodb.client.model Filters in.

Prototype

public static <TItem> Bson in(final String fieldName, final Iterable<TItem> values)

Source Link

Document

Creates a filter that matches all documents where the value of a field equals any value in the list of specified values.

Usage

From source file:org.lambda3.indra.core.impl.MongoVectorSpace.java

License:Open Source License

private void collectVectors(Set<String> terms, int limit) {
    Set<String> toFetch = terms.stream().filter(t -> !this.vectorsCache.containsKey(t))
            .collect(Collectors.toSet());

    logger.debug("Cache has {} vectors, need to fetch more {}", terms.size() - toFetch.size(), toFetch.size());

    if (!toFetch.isEmpty()) {
        logger.info("Collecting {} term vectors from {}", toFetch.size(), dbName);
        FindIterable<Document> docs = getColl().find(Filters.in(termFieldName, toFetch));
        if (docs != null) {
            docs.batchSize(toFetch.size());
            for (Document doc : docs) {
                this.vectorsCache.put(doc.getString(termFieldName), unmarshall(doc, limit));
            }/*from   w  ww. j  a va2s  .c om*/
        }
    }
}

From source file:org.lambda3.indra.mongo.MongoIndraTranslator.java

License:Open Source License

private Map<String, List<String>> doTranslate(Set<String> tokens) {
    MongoCollection<Document> lexColl = getLexCollection();
    FindIterable<Document> lexs = lexColl.find(Filters.in(TERM_FIELD, tokens));

    Map<String, List<String>> res = new HashMap<>();
    for (Document doc : lexs) {
        Document tr = (Document) doc.get(TRANSLATION_FIELD);

        if (tr != null) {
            tr.remove(NULL_VALUE);//w ww .  j  a  v  a  2s.com
            res.put(doc.getString(TERM_FIELD), getRelevantTranslations((Map) tr));
        }
    }

    return res;
}

From source file:org.lambda3.indra.mongo.MongoVectorSpace.java

License:Open Source License

@Override
protected Map<String, RealVector> collectVectors(Iterable<? extends String> terms) {
    logger.info("Collecting term vectors from {}", dbName);
    FindIterable<Document> docs = getTermsColl().find(Filters.in(TERM_FIELD_NAME, terms));
    Map<String, RealVector> vectors = new HashMap<>();
    if (docs != null) {
        for (Document doc : docs) {
            //BinaryCodecs.unmarshall(b, metadata.sparse, metadata.dimensions);
            //TODO other problem hrer vectors.put(doc.getString(TERM_FIELD_NAME), unmarshall(doc, getMetadata().getDimensions()));
        }/*from w w  w  . ja  va  2 s .  co  m*/
    }

    return vectors;
}

From source file:org.opencb.cellbase.lib.impl.MongoDBAdaptor.java

License:Apache License

private Bson createChunkQuery(Region region, int chunkSize) {
    int startChunkId = getChunkId(region.getStart(), chunkSize);
    int endChunkId = getChunkId(region.getEnd(), chunkSize);

    List<String> chunkIds = new ArrayList<>(endChunkId - startChunkId + 1);
    for (int chunkId = startChunkId; chunkId <= endChunkId; chunkId++) {
        chunkIds.add(region.getChromosome() + "_" + chunkId + "_" + chunkSize / 1000 + "k");
    }//from www.j  av  a2s.  c o m

    Bson chunk = Filters.in("_chunkIds", chunkIds);
    Bson start = Filters.lte("start", region.getEnd());
    Bson end = Filters.gte("end", region.getStart());
    return Filters.and(chunk, start, end);

    //        // We only use chunks if region queried belongs to a single chunk
    //        if (startChunkId == endChunkId) {
    //            logger.info("Querying by chunkId, {}, {}", startChunkId, endChunkId);
    //            Bson chunk = Filters.eq("_chunkIds", getChunkIdPrefix(region.getChromosomeInfo(), region.getStart(), chunkSize));
    //            Bson start = Filters.lte("start", region.getEnd());
    //            Bson end = Filters.gte("end", region.getStart());
    //            return Filters.and(chunk, start, end);
    //        } else {
    //            Bson chromosome = Filters.eq("chromosome", region.getChromosomeInfo());
    //            Bson start = Filters.lte("start", region.getEnd());
    //            Bson end = Filters.gte("end", region.getStart());
    //            return Filters.and(chromosome, start, end);
    //        }
}

From source file:org.opencb.commons.datastore.mongodb.MongoDBQueryUtils.java

License:Apache License

public static Bson createAutoFilter(String mongoDbField, String queryParam, Query query, QueryParam.Type type,
        LogicalOperator operator) throws NumberFormatException {

    List<String> queryParamList = query.getAsStringList(queryParam, getLogicalSeparator(operator));

    if (LogicalOperator.OR.equals(operator)
            && queryParamsOperatorAlwaysMatchesOperator(type, queryParamList, ComparisonOperator.EQUALS)) {
        // It is better to perform a $in operation
        return Filters.in(mongoDbField, removeOperatorsFromQueryParamList(type, queryParamList));
    } else if (LogicalOperator.AND.equals(operator)
            && queryParamsOperatorAlwaysMatchesOperator(type, queryParamList, ComparisonOperator.NOT_EQUALS)) {
        // It is better to perform a $nin operation
        return Filters.nin(mongoDbField, removeOperatorsFromQueryParamList(type, queryParamList));
    } else {//from w w  w.  jav a2 s . c om
        List<Bson> bsonList = new ArrayList<>(queryParamList.size());
        for (String queryItem : queryParamList) {
            Matcher matcher = getPattern(type).matcher(queryItem);
            String op = "";
            String queryValueString = queryItem;
            if (matcher.find()) {
                op = matcher.group(1);
                queryValueString = matcher.group(2);
            }
            ComparisonOperator comparator = getComparisonOperator(op, type);
            switch (type) {
            case STRING:
            case TEXT:
            case TEXT_ARRAY:
                bsonList.add(createFilter(mongoDbField, queryValueString, comparator));
                break;
            case LONG:
            case LONG_ARRAY:
            case INTEGER:
            case INTEGER_ARRAY:
                bsonList.add(createFilter(mongoDbField, Long.parseLong(queryValueString), comparator));
                break;
            case DOUBLE:
            case DECIMAL:
            case DECIMAL_ARRAY:
                bsonList.add(createFilter(mongoDbField, Double.parseDouble(queryValueString), comparator));
                break;
            case BOOLEAN:
            case BOOLEAN_ARRAY:
                bsonList.add(createFilter(mongoDbField, Boolean.parseBoolean(queryValueString), comparator));
                break;
            case DATE:
            case TIMESTAMP:
                List<String> dateList = new ArrayList<>();
                dateList.add(queryValueString);
                if (!matcher.group(3).isEmpty()) {
                    dateList.add(matcher.group(4));
                    comparator = ComparisonOperator.BETWEEN;
                }
                bsonList.add(createDateFilter(mongoDbField, dateList, comparator, type));
                break;
            default:
                break;
            }
        }

        Bson filter;
        if (bsonList.size() == 0) {
            filter = Filters.size(queryParam, 0);
        } else if (bsonList.size() == 1) {
            filter = bsonList.get(0);
        } else {
            if (operator.equals(LogicalOperator.OR)) {
                filter = Filters.or(bsonList);
            } else {
                filter = Filters.and(bsonList);
            }
        }

        return filter;
    }
}

From source file:org.opencb.commons.datastore.mongodb.MongoDBQueryUtils.java

License:Apache License

public static <T> Bson createFilter(String mongoDbField, List<T> queryValues, ComparisonOperator comparator,
        LogicalOperator operator) {//  w  w w .jav  a2  s .  c  o m
    Bson filter = null;

    if (queryValues != null && queryValues.size() > 0) {

        if (comparator.equals(ComparisonOperator.IN) || comparator.equals(ComparisonOperator.NOT_IN)
                || comparator.equals(ComparisonOperator.ALL)) {
            switch (comparator) {
            case IN:
                filter = Filters.in(mongoDbField, queryValues);
                break;
            case NOT_IN:
                filter = Filters.nin(mongoDbField, queryValues);
                break;
            case ALL:
                filter = Filters.all(mongoDbField, queryValues);
                break;
            default:
                break;
            }
        } else {
            // If there is only on element in the array then it does not make sense to create an OR or AND filter
            if (queryValues.size() == 1) {
                filter = createFilter(mongoDbField, queryValues.get(0), comparator);
            } else {
                List<Bson> bsonList = new ArrayList<>(queryValues.size());
                for (T queryItem : queryValues) {
                    Bson filter1 = createFilter(mongoDbField, queryItem, comparator);
                    if (filter1 != null) {
                        bsonList.add(filter1);
                    }
                }

                if (operator.equals(LogicalOperator.OR)) {
                    filter = Filters.or(bsonList);
                } else {
                    filter = Filters.and(bsonList);
                }
            }

        }
    }

    return filter;
}

From source file:org.opencb.opencga.catalog.db.mongodb.CatalogMongoMetaDBAdaptor.java

License:Apache License

@Override
public QueryResult<StudyAclEntry> getDaemonAcl(List<String> members) throws CatalogDBException {
    long startTime = startQuery();

    Bson match = Aggregates.match(Filters.eq(PRIVATE_ID, "METADATA"));
    Bson unwind = Aggregates.unwind("$" + CatalogCohortDBAdaptor.QueryParams.ACL.key());
    Bson match2 = Aggregates.match(Filters.in(CatalogCohortDBAdaptor.QueryParams.ACL_MEMBER.key(), members));
    Bson project = Aggregates.project(Projections.include(CatalogCohortDBAdaptor.QueryParams.ID.key(),
            CatalogCohortDBAdaptor.QueryParams.ACL.key()));

    QueryResult<Document> aggregate = metaCollection.aggregate(Arrays.asList(match, unwind, match2, project),
            null);//from  w  w  w.  ja  v a  2s  . c  om
    StudyAclEntry result = null;
    if (aggregate.getNumResults() == 1) {
        result = parseObject(((Document) aggregate.getResult().get(0).get("acl")), StudyAclEntry.class);
    }
    return endQuery("get daemon Acl", startTime, Arrays.asList(result));
}

From source file:org.opencb.opencga.catalog.db.mongodb.CatalogMongoMetaDBAdaptor.java

License:Apache License

@Override
public QueryResult<AuthenticationOrigin> getAuthenticationOrigin(String authId) throws CatalogDBException {
    long startTime = startQuery();

    Bson match = Aggregates.match(Filters.eq(PRIVATE_ID, "METADATA"));
    Bson unwind = Aggregates.unwind("$authenticationOrigins");
    Bson match2 = Aggregates.match(Filters.in("authenticationOrigins.id", authId));
    Bson project = Aggregates.project(Projections.include("authenticationOrigins"));

    QueryResult<Document> aggregate = metaCollection.aggregate(Arrays.asList(match, unwind, match2, project),
            null);//from w ww. j  a va  2 s.  c o  m
    AuthenticationOrigin result = null;
    if (aggregate.getNumResults() == 1) {
        result = parseObject(((Document) aggregate.getResult().get(0).get("authenticationOrigins")),
                AuthenticationOrigin.class);
    }
    return endQuery("get authenticationOrigin", startTime, Arrays.asList(result));
}

From source file:org.opencb.opencga.catalog.db.mongodb.CatalogMongoStudyDBAdaptor.java

License:Apache License

@Override
public QueryResult<Group> getGroup(long studyId, @Nullable String groupId, List<String> userIds)
        throws CatalogDBException {
    long startTime = startQuery();
    checkStudyId(studyId);/*from w w  w . j ava  2s .  c om*/
    for (String userId : userIds) {
        dbAdaptorFactory.getCatalogUserDBAdaptor().checkUserExists(userId);
    }
    if (groupId != null && groupId.length() > 0 && !groupExists(studyId, groupId)) {
        throw new CatalogDBException("Group \"" + groupId + "\" does not exist in study " + studyId);
    }

    /*
    * List<Bson> aggregation = new ArrayList<>();
    aggregation.add(Aggregates.match(Filters.elemMatch(QueryParams.VARIABLE_SET.key(),
        Filters.eq(VariableSetParams.ID.key(), variableSetId))));
    aggregation.add(Aggregates.project(Projections.include(QueryParams.VARIABLE_SET.key())));
    aggregation.add(Aggregates.unwind("$" + QueryParams.VARIABLE_SET.key()));
    aggregation.add(Aggregates.match(Filters.eq(QueryParams.VARIABLE_SET_ID.key(), variableSetId)));
    QueryResult<VariableSet> queryResult = studyCollection.aggregate(aggregation, variableSetConverter, new QueryOptions());
    * */
    List<Bson> aggregation = new ArrayList<>();
    aggregation.add(Aggregates.match(Filters.eq(PRIVATE_ID, studyId)));
    aggregation.add(Aggregates.project(Projections.include(QueryParams.GROUPS.key())));
    aggregation.add(Aggregates.unwind("$" + QueryParams.GROUPS.key()));

    //        Document query = new Document(PRIVATE_ID, studyId);
    //        List<Bson> groupQuery = new ArrayList<>();
    if (userIds.size() > 0) {
        aggregation.add(Aggregates.match(Filters.in(QueryParams.GROUP_USER_IDS.key(), userIds)));
        //            groupQuery.add(Filters.in("userIds", userIds));
    }
    if (groupId != null && groupId.length() > 0) {
        aggregation.add(Aggregates.match(Filters.eq(QueryParams.GROUP_NAME.key(), groupId)));
        //            groupQuery.add(Filters.eq("id", groupId));
    }

    //        Bson projection = new Document(QueryParams.GROUPS.key(), new Document("$elemMatch", groupQuery));

    QueryResult<Document> queryResult = studyCollection.aggregate(aggregation, null);

    //        QueryResult<Document> queryResult = studyCollection.find(query, projection, null);
    List<Study> studies = CatalogMongoDBUtils.parseStudies(queryResult);
    List<Group> groups = new ArrayList<>();
    studies.stream().filter(study -> study.getGroups() != null)
            .forEach(study -> groups.addAll(study.getGroups()));
    return endQuery("getGroup", startTime, groups);
}

From source file:org.opencb.opencga.catalog.db.mongodb.CatalogMongoStudyDBAdaptor.java

License:Apache License

@Deprecated
@Override/*  w  w w .  j av  a 2 s . c  o  m*/
public QueryResult<Role> getRole(long studyId, String userId, String groupId, String roleId,
        QueryOptions options) throws CatalogDBException {
    long startTime = startQuery();

    Bson query = new Document(PRIVATE_ID, studyId);
    List<Bson> roleQuery = new ArrayList<>();
    List<String> userIds = new ArrayList<>();
    if (userId != null) {
        userIds.add(userId);
    }
    if (groupId != null) {
        userIds.add(groupId);
    }
    if (userIds.size() > 0) {
        roleQuery.add(Filters.in("userIds", userIds));
    }
    if (roleId != null) {
        roleQuery.add(Filters.eq("id", roleId));
    }
    Bson projection = Projections.elemMatch(QueryParams.ROLES.key(), Filters.and(roleQuery));

    QueryResult<Document> queryResult = studyCollection.find(query, projection,
            filterOptions(options, FILTER_ROUTE_STUDIES + QueryParams.ROLES.key() + "."));
    List<Study> studies = CatalogMongoDBUtils.parseStudies(queryResult);
    List<Role> roles = new ArrayList<>(1);
    //        studies.stream().filter(study -> study.getRoles() != null).forEach(study -> {
    //            roles.addAll(study.getRoles());
    //        });
    return endQuery("getRole", startTime, roles);
}