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

Introduction

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

Prototype

public static Bson and(final Bson... filters) 

Source Link

Document

Creates a filter that performs a logical AND of the provided list of filters.

Usage

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

License:Apache License

private Bson parseQuery(Query query) throws CatalogDBException {
    List<Bson> andBsonList = new ArrayList<>();
    List<Bson> annotationList = new ArrayList<>();
    // We declare variableMap here just in case we have different annotation queries
    Map<String, Variable> variableMap = null;

    if (query.containsKey(QueryParams.ANNOTATION.key())) {
        fixAnnotationQuery(query);/*from  w  w  w  . j a  v a  2  s . c om*/
    }

    for (Map.Entry<String, Object> entry : query.entrySet()) {
        String key = entry.getKey().split("\\.")[0];
        QueryParams queryParam = QueryParams.getParam(entry.getKey()) != null
                ? QueryParams.getParam(entry.getKey())
                : QueryParams.getParam(key);
        if (queryParam == null) {
            throw CatalogDBException.queryParamNotFound(key, "Samples");
        }
        try {
            switch (queryParam) {
            case ID:
                addOrQuery(PRIVATE_ID, queryParam.key(), query, queryParam.type(), andBsonList);
                break;
            case STUDY_ID:
                addOrQuery(PRIVATE_STUDY_ID, queryParam.key(), query, queryParam.type(), andBsonList);
                break;
            case ATTRIBUTES:
                addAutoOrQuery(entry.getKey(), entry.getKey(), query, queryParam.type(), andBsonList);
                break;
            case BATTRIBUTES:
                String mongoKey = entry.getKey().replace(QueryParams.BATTRIBUTES.key(),
                        QueryParams.ATTRIBUTES.key());
                addAutoOrQuery(mongoKey, entry.getKey(), query, queryParam.type(), andBsonList);
                break;
            case NATTRIBUTES:
                mongoKey = entry.getKey().replace(QueryParams.NATTRIBUTES.key(), QueryParams.ATTRIBUTES.key());
                addAutoOrQuery(mongoKey, entry.getKey(), query, queryParam.type(), andBsonList);
                break;
            case VARIABLE_SET_ID:
                addOrQuery(queryParam.key(), queryParam.key(), query, queryParam.type(), annotationList);
                break;
            case ANNOTATION:
                if (variableMap == null) {
                    long variableSetId = query.getLong(QueryParams.VARIABLE_SET_ID.key());
                    if (variableSetId > 0) {
                        variableMap = dbAdaptorFactory.getCatalogStudyDBAdaptor()
                                .getVariableSet(variableSetId, null).first().getVariables().stream()
                                .collect(Collectors.toMap(Variable::getName, Function.identity()));
                    }
                }
                addAnnotationQueryFilter(entry.getKey(), query, variableMap, annotationList);
                break;
            case ANNOTATION_SET_NAME:
                addOrQuery("name", queryParam.key(), query, queryParam.type(), annotationList);
                break;
            default:
                addAutoOrQuery(queryParam.key(), queryParam.key(), query, queryParam.type(), andBsonList);
                break;
            }
        } catch (Exception e) {
            if (e instanceof CatalogDBException) {
                throw e;
            } else {
                throw new CatalogDBException("Error parsing query : " + query.toJson(), e);
            }
        }
    }

    if (annotationList.size() > 0) {
        Bson projection = Projections.elemMatch(QueryParams.ANNOTATION_SETS.key(), Filters.and(annotationList));
        andBsonList.add(projection);
    }
    if (andBsonList.size() > 0) {
        return Filters.and(andBsonList);
    } else {
        return new Document();
    }
}

---

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

License:Apache License

@Override
public QueryResult<VariableSet> getAllVariableSets(long studyId, QueryOptions options)
        throws CatalogDBException {

    long startTime = startQuery();

    List<Bson> mongoQueryList = new LinkedList<>();

    for (Map.Entry<String, Object> entry : options.entrySet()) {
        String key = entry.getKey().split("\\.")[0];
        try {//from   ww  w.java2 s .com
            if (isDataStoreOption(key) || isOtherKnownOption(key)) {
                continue; //Exclude DataStore options
            }
            StudyDBAdaptor.VariableSetParams option = StudyDBAdaptor.VariableSetParams.getParam(key) != null
                    ? StudyDBAdaptor.VariableSetParams.getParam(key)
                    : StudyDBAdaptor.VariableSetParams.getParam(entry.getKey());
            switch (option) {
            case STUDY_ID:
                addCompQueryFilter(option, option.name(), PRIVATE_ID, options, mongoQueryList);
                break;
            default:
                String optionsKey = "variableSets." + entry.getKey().replaceFirst(option.name(), option.key());
                addCompQueryFilter(option, entry.getKey(), optionsKey, options, mongoQueryList);
                break;
            }
        } catch (IllegalArgumentException e) {
            throw new CatalogDBException(e);
        }
    }

    /*
    QueryResult<DBObject> queryResult = studyCollection.aggregate(Arrays.<DBObject>asList(
        new BasicDBObject("$match", new BasicDBObject(PRIVATE_ID, studyId)),
        new BasicDBObject("$project", new BasicDBObject("variableSets", 1)),
        new BasicDBObject("$unwind", "$variableSets"),
        new BasicDBObject("$match", new BasicDBObject("$and", mongoQueryList))
    ), filterOptions(options, FILTER_ROUTE_STUDIES));
    */

    List<Bson> aggregation = new ArrayList<>();
    aggregation.add(Aggregates.match(Filters.eq(PRIVATE_ID, studyId)));
    aggregation.add(Aggregates.project(Projections.include("variableSets")));
    aggregation.add(Aggregates.unwind("$variableSets"));
    if (mongoQueryList.size() > 0) {
        aggregation.add(Aggregates.match(Filters.and(mongoQueryList)));
    }

    QueryResult<Document> queryResult = studyCollection.aggregate(aggregation,
            filterOptions(options, FILTER_ROUTE_STUDIES));

    List<VariableSet> variableSets = parseObjects(queryResult, Study.class).stream()
            .map(study -> study.getVariableSets().get(0)).collect(Collectors.toList());

    return endQuery("", startTime, variableSets);
}

---

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

License:Apache License

private Bson parseQuery(Query query) throws CatalogDBException {
    List<Bson> andBsonList = new ArrayList<>();

    for (Map.Entry<String, Object> entry : query.entrySet()) {
        String key = entry.getKey().split("\\.")[0];
        QueryParams queryParam = QueryParams.getParam(entry.getKey()) != null
                ? QueryParams.getParam(entry.getKey())
                : QueryParams.getParam(key);
        try {//from  w w  w  .jav a2  s.  c  om
            switch (queryParam) {
            case ID:
                addOrQuery(PRIVATE_ID, queryParam.key(), query, queryParam.type(), andBsonList);
                break;
            case ATTRIBUTES:
                addAutoOrQuery(entry.getKey(), entry.getKey(), query, queryParam.type(), andBsonList);
                break;
            case BATTRIBUTES:
                String mongoKey = entry.getKey().replace(QueryParams.BATTRIBUTES.key(),
                        QueryParams.ATTRIBUTES.key());
                addAutoOrQuery(mongoKey, entry.getKey(), query, queryParam.type(), andBsonList);
                break;
            case NATTRIBUTES:
                mongoKey = entry.getKey().replace(QueryParams.NATTRIBUTES.key(), QueryParams.ATTRIBUTES.key());
                addAutoOrQuery(mongoKey, entry.getKey(), query, queryParam.type(), andBsonList);
                break;

            default:
                addAutoOrQuery(queryParam.key(), queryParam.key(), query, queryParam.type(), andBsonList);
                break;
            }
        } catch (Exception e) {
            throw new CatalogDBException(e);
        }
    }

    if (andBsonList.size() > 0) {
        return Filters.and(andBsonList);
    } else {
        return new Document();
    }
}

---

From source file:org.opencb.opencga.storage.mongodb.variant.adaptors.VariantSourceMongoDBAdaptor.java

License:Apache License

protected Bson parseQuery(Query query) {
    LinkedList<Bson> filters = new LinkedList<>();
    if (query.containsKey(VariantSourceQueryParam.STUDY_ID.key())) {
        List<String> studyIds = query.getAsStringList(VariantSourceQueryParam.STUDY_ID.key());
        filters.add(Filters.in(VariantSourceQueryParam.STUDY_ID.key(), studyIds));
    }//w w w  .j a  v  a  2s.  c  o  m
    if (query.containsKey(VariantSourceQueryParam.FILE_ID.key())) {
        List<String> studyIds = query.getAsStringList(VariantSourceQueryParam.FILE_ID.key());
        filters.add(Filters.in(VariantSourceQueryParam.FILE_ID.key(), studyIds));
    }

    return Filters.and(filters);
}

---

From source file:step.plugins.datatable.DataTableServices.java

License:Open Source License

private BackendDataTableDataResponse getTableData(@PathParam("id") String collectionID,
        MultivaluedMap<String, String> params, List<Bson> sessionQueryFragments) throws Exception {
    BackendDataTable table = dataTableRegistry.getTable(collectionID);

    List<Bson> queryFragments = new ArrayList<>();
    for (String key : params.keySet()) {
        Matcher m = columnSearchPattern.matcher(key);
        Matcher searchMatcher = searchPattern.matcher(key);
        if (m.matches()) {
            int columnID = Integer.parseInt(m.group(1));
            ColumnDef column = table.getColumnByID(columnID);
            String searchValue = params.getFirst(key);

            if (searchValue != null && searchValue.length() > 0) {
                if (column.getQueryFactory() != null) {
                    queryFragments.add(column.getQueryFactory().createQuery(column.getValue(), searchValue));
                }//from  ww  w .j a  v  a  2s  .  c  o  m
            }
        } else if (searchMatcher.matches()) {
            String searchValue = params.getFirst(key);
            if (searchValue != null && searchValue.length() > 0) {
                // TODO implement full text search
            }
        }
    }

    int draw = Integer.parseInt(params.getFirst("draw"));

    int skip = Integer.parseInt(params.getFirst("start"));
    int limit = Integer.parseInt(params.getFirst("length"));

    int sortColumnID = Integer.parseInt(params.getFirst("order[0][column]"));
    ColumnDef sortColumn = table.getColumnByID(sortColumnID);
    String sortDir = params.getFirst("order[0][dir]");

    SearchOrder order = null;
    if (sortColumn.getValue() != null) {
        order = new SearchOrder(sortColumn.getValue(), sortDir.equals("asc") ? 1 : -1);
    }

    if (table.getQuery() != null) {
        JsonObject filter = null;
        if (params.containsKey("params")) {
            JsonReader reader = Json.createReader(new StringReader(params.getFirst("params")));
            filter = reader.readObject();

        }
        Bson fragment = table.getQuery().buildAdditionalQuery(filter);
        if (fragment != null) {
            queryFragments.add(fragment);
        }
    }

    if (sessionQueryFragments != null) {
        queryFragments.addAll(sessionQueryFragments);
    }

    Bson query = queryFragments.size() > 0 ? Filters.and(queryFragments) : new Document();

    if (params.containsKey("export")) {
        String reportID = params.getFirst("export");
        exportTaskManager.createExportTask(reportID, new ExportTask(table, query, order));
    }

    CollectionFind<Document> find = table.getCollection().find(query, order, skip, limit);

    Iterator<Document> it = find.getIterator();
    List<Document> objects = new ArrayList<>();
    while (it.hasNext()) {
        objects.add(it.next());
    }

    String[][] data = new String[objects.size()][table.getColumns().size()];
    for (int i = 0; i < objects.size(); i++) {
        Document row = objects.get(i);
        String[] rowFormatted = formatRow(table.getColumns(), row);
        data[i] = rowFormatted;
    }
    BackendDataTableDataResponse response = new BackendDataTableDataResponse(draw, find.getRecordsTotal(),
            find.getRecordsFiltered(), data);

    return response;
}

---

From source file:step.plugins.datatable.TableService.java

License:Open Source License

private BackendDataTableDataResponse getTableData(@PathParam("id") String collectionID,
        MultivaluedMap<String, String> params, List<Bson> sessionQueryFragments) throws Exception {
    Collection collection = collectionRegistry.get(collectionID);
    if (collection == null) {
        // no custom collection. use default collection
        collection = new Collection(database, collectionID);
    }/*from  w w  w .ja v  a 2s.  c  o m*/

    Map<Integer, String> columnNames = getColumnNamesMap(params);

    List<Bson> queryFragments = createQueryFragments(params, columnNames);

    int draw = Integer.parseInt(params.getFirst("draw"));
    int skip = Integer.parseInt(params.getFirst("start"));
    int limit = Integer.parseInt(params.getFirst("length"));

    int sortColumnID = Integer.parseInt(params.getFirst("order[0][column]"));
    String sortColumnName = columnNames.get(sortColumnID);

    String sortDir = params.getFirst("order[0][dir]");
    SearchOrder order = new SearchOrder(sortColumnName, sortDir.equals("asc") ? 1 : -1);

    if (sessionQueryFragments != null) {
        queryFragments.addAll(sessionQueryFragments);
    }

    Bson query = queryFragments.size() > 0 ? Filters.and(queryFragments) : new Document();

    CollectionFind<Document> find = collection.find(query, order, skip, limit);

    Iterator<Document> it = find.getIterator();
    List<Document> objects = new ArrayList<>();
    while (it.hasNext()) {
        objects.add(it.next());
    }

    String[][] data = new String[objects.size()][1];
    for (int i = 0; i < objects.size(); i++) {
        Document row = objects.get(i);
        String[] rowFormatted = new String[columnNames.size()];
        rowFormatted[0] = row.toJson();
        data[i] = rowFormatted;
    }
    BackendDataTableDataResponse response = new BackendDataTableDataResponse(draw, find.getRecordsTotal(),
            find.getRecordsFiltered(), data);

    return response;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• »