public VariantQueryResult<Variant> query(Query query, QueryOptions options) { query = preProcessQuery(query, options); return dbAdaptor.get(query, options); }
protected ProgressLogger buildCreateStatsProgressLogger(VariantDBAdaptor variantDBAdaptor, Query readerQuery, QueryOptions options) { boolean skipCount = options.getBoolean(QueryOptions.SKIP_COUNT, false); return new ProgressLogger("Calculated stats:", () -> { if (skipCount) { return 0L; } else { numStatsToLoad = variantDBAdaptor.count(readerQuery).first(); return numStatsToLoad; } }, 200).setBatchSize(5000); }
/** * The query won't use the search index, either because is not available, not necessary, or forbidden. * * @param query Query * @param options QueryOptions * @param iterator Shall the resulting object be an iterator instead of a QueryResult * @return QueryResult or Iterator with the variants that matches the query * @throws StorageEngineException StorageEngineException */ protected Object getOrIteratorNotSearchIndex(Query query, QueryOptions options, boolean iterator) throws StorageEngineException { VariantDBAdaptor dbAdaptor = getDBAdaptor(); if (iterator) { return dbAdaptor.iterator(query, options); } else { setDefaultTimeout(options); return dbAdaptor.get(query, options).setSource(getStorageEngineId()); } }
/** /** * Fetch all variants resulting of executing the query in the database. Returned fields are taken from * the 'include' and 'exclude' fields at options. * * @param variants Iterator with variants to filter * @param query Query to be executed in the database to filter variants * @param options Query modifiers, accepted values are: include, exclude, limit, skip, sort and count * @return A QueryResult with the result of the query */ default VariantQueryResult<Variant> get(Iterator<?> variants, Query query, QueryOptions options) { return iterator(variants, query, options) .toQueryResult(getSamplesMetadataIfRequested(query, options, getStudyConfigurationManager())); }
@Override public void get(Request request, StreamObserver<Variant> responseObserver) { try { // Creating the datastore Query and QueryOptions objects from the gRPC request Map of Strings Query query = genericGrpcService.createQuery(request); QueryOptions queryOptions = genericGrpcService.createQueryOptions(request); // checkAuthorizedHosts(query, request.getIp()); VariantDBAdaptor variantDBAdaptor = getVariantDBAdaptor(request); // Iterator iterator = geneDBAdaptor.nativeIterator(query, queryOptions); Iterator iterator = variantDBAdaptor.iterator(query, queryOptions); while (iterator.hasNext()) { org.opencb.biodata.models.variant.Variant next = (org.opencb.biodata.models.variant.Variant) iterator.next(); Variant convert = convert(next); responseObserver.onNext(convert); } responseObserver.onCompleted(); variantDBAdaptor.close(); } catch (IllegalAccessException | InstantiationException | ClassNotFoundException | StorageEngineException e) { e.printStackTrace(); // } catch (NotAuthorizedHostException e) { // e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }
@Override public void count(Request request, StreamObserver<GenericServiceModel.LongResponse> responseObserver) { try { // Creating the datastore Query object from the gRPC request Map of Strings Query query = genericGrpcService.createQuery(request); // checkAuthorizedHosts(query, request.getIp()); VariantDBAdaptor variantDBAdaptor = getVariantDBAdaptor(request); QueryResult<Long> queryResult = variantDBAdaptor.count(query); responseObserver.onNext(LongResponse.newBuilder().setValue(queryResult.getResult().get(0)).build()); responseObserver.onCompleted(); variantDBAdaptor.close(); } catch (IllegalAccessException | InstantiationException | ClassNotFoundException | StorageEngineException e) { e.printStackTrace(); // } catch (NotAuthorizedHostException | NotAuthorizedUserException e) { // e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }
public CatalogVariantMetadataFactory(CatalogManager catalogManager, VariantDBAdaptor dbAdaptor, String sessionId) { super(dbAdaptor.getStudyConfigurationManager()); this.catalogManager = catalogManager; this.sessionId = sessionId; }
protected VariantDBIterator getVariantsToIndex(boolean overwrite, Query query, QueryOptions queryOptions, VariantDBAdaptor dbAdaptor) throws StorageEngineException { if (!overwrite) { query.put(VariantQueryUtils.VARIANTS_TO_INDEX.key(), true); } return dbAdaptor.iterator(query, queryOptions); }
.append(VariantQueryParam.SAMPLE.key(), samples); VariantDBIterator iterator = dbAdaptor.iterator(query, queryOptions); ProgressLogger progressLogger = new ProgressLogger("Variants loaded in Solr:", () -> dbAdaptor.count(query).first(), 200); variantSearchManager.load(collectionName, iterator, progressLogger, VariantSearchLoadListener.empty()); } else { throw new StorageEngineException("Solr is not alive!"); dbAdaptor.close(); } catch (Exception e) { getStudyConfigurationManager().lockAndUpdate(study, studyConfiguration -> {
int expectedCount = variantStorageEngine.getDBAdaptor().count(query).first().intValue(); assertEquals(expectedCount, variantSearchManager.query(collection, new Query(), new QueryOptions()).getNumTotalResults()); Variant expected = variantStorageEngine.getDBAdaptor().get(query.append(ID.key(), actual.toString()), null).first();
@Test public void testNativeQuery() { int count = 0; for (VariantDBIterator iterator = dbAdaptor.iterator(new Query(), new QueryOptions(VariantHadoopDBAdaptor.NATIVE, true)); iterator.hasNext();) { Variant variant = iterator.next(); // System.out.println(variant.toJson()); count++; } Assert.assertEquals(dbAdaptor.count(new Query()).first().intValue(), count); }
options.put("interval", interval); queryResult = dbAdaptor.getFrequency(query, regions.get(0), interval); queryResult = dbAdaptor.get(query, options);
StudyConfigurationManager studyConfigurationManager = dbAdaptor.getStudyConfigurationManager(); int i = 1; for (int fileId = 77; fileId <= 93; fileId++) { dbAdaptor.close(); studyConfigurationManager.close();
@Override public void close() throws StorageEngineException { if (dbAdaptor != null) { try { dbAdaptor.close(); } catch (IOException e) { throw new StorageEngineException("Error closing DBAdaptor", e); } } }
public QueryResult groupBy(Query query, String field, QueryOptions options) { return dbAdaptor.groupBy(query, field, options); }
public VariantQueryResult<Variant> getPhased(String variant, String studyName, String sampleName, QueryOptions options, int windowsSize) throws StorageEngineException { setDefaultTimeout(options); return getDBAdaptor().getPhased(variant, studyName, sampleName, options, windowsSize); }
public QueryResult rank(Query query, String field, int numResults, boolean asc) throws StorageEngineException { return getDBAdaptor().rank(query, field, numResults, asc); }
public QueryResult getFrequency(Query query, Region region, int regionIntervalSize) throws StorageEngineException { return getDBAdaptor().getFrequency(query, region, regionIntervalSize); }
public VariantWriterFactory(VariantDBAdaptor dbAdaptor) { studyConfigurationManager = dbAdaptor.getStudyConfigurationManager(); }