public CatalogVariantMetadataFactory(CatalogManager catalogManager, VariantDBAdaptor dbAdaptor, String sessionId) { super(dbAdaptor.getStudyConfigurationManager()); this.catalogManager = catalogManager; this.sessionId = sessionId; }
public VariantWriterFactory(VariantDBAdaptor dbAdaptor) { studyConfigurationManager = dbAdaptor.getStudyConfigurationManager(); }
/** * Returns all the possible samples to be returned by an specific query. * * @param query Query to execute * @param options Query Options * @return Map key: StudyId, value: list of sampleIds */ default Map<Integer, List<Integer>> getReturnedSamples(Query query, QueryOptions options) { return VariantQueryUtils.getIncludeSamples(query, options, getStudyConfigurationManager()); }
default List<Integer> getReturnedStudies(Query query, QueryOptions options) { return VariantQueryUtils.getIncludeStudies(query, options, getStudyConfigurationManager()); } /**
public StudyConfigurationManager getStudyConfigurationManager() { return getDBAdaptor().getStudyConfigurationManager(); } }
public void loadStats(VariantDBAdaptor variantDBAdaptor, URI uri, StudyConfiguration studyConfiguration, QueryOptions options) throws IOException, StorageEngineException { URI variantStatsUri = Paths.get(uri.getPath() + VARIANT_STATS_SUFFIX).toUri(); URI sourceStatsUri = Paths.get(uri.getPath() + SOURCE_STATS_SUFFIX).toUri(); boolean updateStats = options.getBoolean(Options.UPDATE_STATS.key(), false); checkAndUpdateCalculatedCohorts(studyConfiguration, variantStatsUri, updateStats); logger.info("starting stats loading from {} and {}", variantStatsUri, sourceStatsUri); long start = System.currentTimeMillis(); loadVariantStats(variantStatsUri, studyConfiguration, options); // loadSourceStats(variantDBAdaptor, sourceStatsUri, studyConfiguration, options); logger.info("finishing stats loading, time: {}ms", System.currentTimeMillis() - start); variantDBAdaptor.getStudyConfigurationManager().updateStudyConfiguration(studyConfiguration, options); }
protected StudyConfiguration preCalculateStats(Map<String, Set<String>> cohorts, StudyConfiguration studyConfiguration, boolean overwrite, boolean updateStats, ObjectMap options) throws StorageEngineException { return dbAdaptor.getStudyConfigurationManager().lockAndUpdate(studyConfiguration.getStudyName(), sc -> { dbAdaptor.getStudyConfigurationManager().registerCohorts(sc, cohorts); checkAndUpdateStudyConfigurationCohorts(sc, cohorts, overwrite, updateStats, getAggregation(sc, options)); return sc; }); }
@Override public void deleteAnnotation(String name, ObjectMap options) throws StorageEngineException, VariantAnnotatorException { mongoDbAdaptor.dropAnnotationCollection(name); dbAdaptor.getStudyConfigurationManager().lockAndUpdateProject(project -> { removeAnnotationSnapshot(name, project); return project; }); } }
public void loadSourceStats(VariantDBAdaptor variantDBAdaptor, URI uri, String study, QueryOptions options) throws IOException { StudyConfigurationManager studyConfigurationManager = variantDBAdaptor.getStudyConfigurationManager(); StudyConfiguration studyConfiguration = studyConfigurationManager.getStudyConfiguration(study, options).first(); loadSourceStats(variantDBAdaptor, uri, studyConfiguration, options); }
public void importData(URI inputUri) throws StorageEngineException, IOException { VariantMetadataImporter metadataImporter = new VariantMetadataImporter(); VariantMetadata metadata = metadataImporter.importMetaData(inputUri, dbAdaptor.getStudyConfigurationManager()); importData(inputUri, metadata); }
public void loadStats(VariantDBAdaptor variantDBAdaptor, URI uri, String study, QueryOptions options) throws IOException, StorageEngineException { StudyConfigurationManager studyConfigurationManager = variantDBAdaptor.getStudyConfigurationManager(); StudyConfiguration studyConfiguration = studyConfigurationManager.getStudyConfiguration(study, options).first(); loadStats(variantDBAdaptor, uri, studyConfiguration, options); }
/** /** * 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())); }
protected final URI postLoad(URI input, URI output, List<Integer> fileIds) throws StorageEngineException { if (fileIds == null || fileIds.isEmpty()) { fileIds = Collections.singletonList(getFileId()); } int studyId = getStudyId(); long lock = dbAdaptor.getStudyConfigurationManager().lockStudy(studyId); // Check loaded variants BEFORE updating the StudyConfiguration checkLoadedVariants(fileIds, getStudyConfiguration()); StudyConfiguration studyConfiguration; try { //Update StudyConfiguration studyConfiguration = getStudyConfiguration(true); securePostLoad(fileIds, studyConfiguration); dbAdaptor.getStudyConfigurationManager().updateStudyConfiguration(studyConfiguration, new QueryOptions()); } finally { dbAdaptor.getStudyConfigurationManager().unLockStudy(studyId, lock); } return input; }
@Override public void securePostLoad(List<Integer> fileIds, StudyConfiguration studyConfiguration) throws StorageEngineException { super.securePostLoad(fileIds, studyConfiguration); BatchFileOperation.Status status = dbAdaptor.getStudyConfigurationManager() .setStatus(studyConfiguration, BatchFileOperation.Status.READY, "load", fileIds); if (status != BatchFileOperation.Status.DONE) { logger.warn("Unexpected status " + status); } }
@Override public URI preLoad(URI input, URI output) throws StorageEngineException { getOrCreateStudyConfiguration(false); int studyId = getStudyId(); VariantFileMetadata fileMetadata = readVariantFileMetadata(input); //Get the studyConfiguration. If there is no StudyConfiguration, create a empty one. dbAdaptor.getStudyConfigurationManager().lockAndUpdate(studyId, studyConfiguration -> { securePreLoad(studyConfiguration, fileMetadata); privateStudyConfiguration = studyConfiguration; return studyConfiguration; }); return input; }
public static StudyConfiguration stats(VariantStatisticsManager vsm, QueryOptions options, StudyConfiguration studyConfiguration, Map<String, Set<String>> cohorts, Map<String, Integer> cohortIds, VariantDBAdaptor dbAdaptor, URI resolve) throws IOException, StorageEngineException { if (vsm instanceof DefaultVariantStatisticsManager) { DefaultVariantStatisticsManager dvsm = (DefaultVariantStatisticsManager) vsm; URI stats = dvsm.createStats(dbAdaptor, resolve, cohorts, cohortIds, studyConfiguration, options); dvsm.loadStats(dbAdaptor, stats, studyConfiguration, options); } else { studyConfiguration.getCohortIds().putAll(cohortIds); cohorts.forEach((cohort, samples) -> { Set<Integer> sampleIds = samples.stream().map(studyConfiguration.getSampleIds()::get).collect(Collectors.toSet()); studyConfiguration.getCohorts().put(cohortIds.get(cohort), sampleIds); }); dbAdaptor.getStudyConfigurationManager().updateStudyConfiguration(studyConfiguration, null); vsm.calculateStatistics(studyConfiguration.getStudyName(), new ArrayList<>(cohorts.keySet()), options); } return dbAdaptor.getStudyConfigurationManager().getStudyConfiguration(studyConfiguration.getStudyId(), null).first(); }
@Override protected void load() throws Exception { super.load(); StudyConfigurationManager scm = dbAdaptor.getStudyConfigurationManager(); for (String studyName : scm.getStudyNames(null)) { StudyConfiguration sc = scm.getStudyConfiguration(studyName, null).first(); ArrayList<String> samples = new ArrayList<>(sc.getSampleIds().keySet()); samples.sort(String::compareTo); variantStorageEngine.searchIndexSamples(sc.getStudyName(), samples.subList(0, samples.size() / 2)); variantStorageEngine.searchIndexSamples(sc.getStudyName(), samples.subList(samples.size() / 2, samples.size())); } }
@Override public URI postLoad(URI input, URI output) throws StorageEngineException { logger.info("Post load file " + input); VariantFileMetadata fileMetadata = readVariantFileMetadata(input); fileMetadata.setId(String.valueOf(getFileId())); dbAdaptor.getStudyConfigurationManager().updateVariantFileMetadata(getStudyId(), fileMetadata); return super.postLoad(input, output); }
public StudyConfiguration stats(QueryOptions options, StudyConfiguration studyConfiguration, Map<String, Set<String>> cohorts, URI output) throws IOException, StorageEngineException { options.put(DefaultVariantStatisticsManager.OUTPUT, output.toString()); variantStorageEngine.calculateStats(studyConfiguration.getStudyName(), cohorts, options); return dbAdaptor.getStudyConfigurationManager().getStudyConfiguration(studyConfiguration.getStudyId(), null).first(); }
protected VariantQueryResult<Variant> query(Query query, QueryOptions options) { try { query = preProcessQuery(query, options); StudyConfigurationManager scm = dbAdaptor.getStudyConfigurationManager(); String collection = VariantSearchUtils.inferSpecificSearchIndexSamplesCollection(query, options, scm, DB_NAME); // Do not execute this test if the query is not covered by the specific search index collection Assume.assumeThat(query.toJson(), collection, CoreMatchers.notNullValue()); if (options.getInt(QueryOptions.LIMIT, 0) <= 0) { options = new QueryOptions(options); options.put(QueryOptions.LIMIT, 100000); } return variantStorageEngine.getVariantSearchManager().query(collection, query, options); } catch (StorageEngineException | VariantSearchException | IOException e) { e.printStackTrace(); Assert.fail(e.getMessage()); } return null; }