public static boolean isValidParam(Query query, QueryParam param, boolean discardNegated) { boolean validParam = isValidParam(query, param); if (!discardNegated || !validParam) { return validParam; } else { String strValue = query.getString(param.key()); return splitValue(strValue, checkOperator(strValue)) .stream() .anyMatch((v) -> !isNegated(v)); // Discard negated } }
/** * Build an OR/AND-condition with all consequence types from the input list. It uses the VariantDBAdaptorUtils * to parse the consequence type (accession or term) into an integer. * * @param cts List of consequence types * @param op Boolean operator (OR / AND) * @return OR/AND-condition string */ private String buildConsequenceTypeOrAnd(List<String> cts, String op) { StringBuilder sb = new StringBuilder(); for (String ct : cts) { if (sb.length() > 0) { sb.append(op); } sb.append("soAcc:\"").append(VariantQueryUtils.parseConsequenceType(ct)).append("\""); } return sb.toString(); }
if (isValidParam(query, INCLUDE_SAMPLE)) { String samplesString = query.getString(VariantQueryParam.INCLUDE_SAMPLE.key()); if (samplesString.equals(ALL)) { if (isValidParam(query, SAMPLE)) { String value = query.getString(SAMPLE.key()); samples = splitValue(value, checkOperator(value)) .stream() .filter((v) -> !isNegated(v)) // Discard negated .collect(Collectors.toList()); if (isValidParam(query, GENOTYPE)) { HashMap<Object, List<String>> map = new LinkedHashMap<>(); parseGenotypeFilter(query.getString(GENOTYPE.key()), map); if (samples == null) { samples = new ArrayList<>(map.size()); if (isValidParam(query, FORMAT)) { Map<String, String> formatMap = parseFormat(query).getValue(); if (samples == null) { samples = new ArrayList<>(formatMap.size());
public static boolean isIncludeSamplesDefined(Query query, Set<VariantField> fields) { if (getIncludeSamplesList(query, fields) != null) { return true; } return isValidParam(query, FILE, true) || isValidParam(query, INCLUDE_FILE, true); }
public static boolean isIncludeFilesDefined(Query query, Set<VariantField> fields) { if (getIncludeFilesList(query, fields) != null) { return true; } return isValidParam(query, SAMPLE, true) || isValidParam(query, INCLUDE_SAMPLE, false) || isValidParam(query, GENOTYPE, false); }
/** * Splits the string with the specified operation. * * @param value Value to split * @return List of values, without the delimiter */ public static Pair<QueryOperation, List<String>> splitValue(String value) { QueryOperation operation = checkOperator(value); return Pair.of(operation, splitValue(value, operation)); }
if (VariantQueryUtils.isValidParam(query, ANNOT_CLINICAL_SIGNIFICANCE)) { String v = query.getString(ANNOT_CLINICAL_SIGNIFICANCE.key()); VariantQueryUtils.QueryOperation operator = VariantQueryUtils.checkOperator(v); List<String> values = VariantQueryUtils.splitValue(v, operator); List<String> clinicalSignificanceList = new ArrayList<>(values.size()); for (String clinicalSignificance : values) { if (isValidParam(query, ANNOT_SIFT)) { String sift = query.getString(ANNOT_SIFT.key()); String[] split = splitOperator(sift); if (StringUtils.isNotEmpty(split[0])) { throw VariantQueryException.malformedParam(ANNOT_SIFT, sift); if (isValidParam(query, ANNOT_PROTEIN_SUBSTITUTION)) { String proteinSubstitution = query.getString(ANNOT_PROTEIN_SUBSTITUTION.key()); if (proteinSubstitution.contains("sift")) { if (isValidParam(query, ANNOT_POLYPHEN)) { String polyphen = query.getString(ANNOT_POLYPHEN.key()); String[] split = splitOperator(polyphen); if (StringUtils.isNotEmpty(split[0])) { throw VariantQueryException.malformedParam(ANNOT_POLYPHEN, polyphen); if (isValidParam(query, ANNOT_PROTEIN_SUBSTITUTION)) { String proteinSubstitution = query.getString(ANNOT_PROTEIN_SUBSTITUTION.key()); if (proteinSubstitution.contains("sift")) { StudyConfiguration defaultStudyConfiguration = getDefaultStudyConfiguration(query, options, getStudyConfigurationManager()); QueryOperation formatOperator = null;
if (isValidParam(query, STUDY)) { String value = query.getString(STUDY.key()); QueryOperation operation = checkOperator(value); List<String> values = splitValue(value, operation); StringBuilder sb = new StringBuilder(); Iterator<String> iterator = values.iterator(); String study = iterator.next(); Integer studyId = studyConfigurationManager.getStudyId(study, false, studies); if (isNegated(study)) { sb.append("\"").append(getStudyColumn(studyId).column()).append("\" IS NULL "); } else { List<String> includeFiles = getIncludeFilesList(query); QueryOperation filtersOperation = null; List<String> filterValues = Collections.emptyList(); if (isValidParam(query, FILTER)) { String value = query.getString(FILTER.key()); filtersOperation = checkOperator(value); filterValues = splitValue(value, filtersOperation); if (!filterValues.isEmpty()) { if (CollectionUtils.isEmpty(includeFiles)) { if (isValidParam(query, QUAL)) { String value = query.getString(QUAL.key()); qualOperation = checkOperator(value); qualValues = splitValue(value, qualOperation); if (!qualValues.isEmpty()) { if (CollectionUtils.isEmpty(includeFiles)) {
final StudyConfiguration defaultStudyConfiguration = getDefaultStudyConfiguration(query, null, studyConfigurationManager); if (isValidParam(query, STUDY)) { String value = query.getString(STUDY.key()); List<String> fileNames = Collections.emptyList(); QueryOperation filesOperation = QueryOperation.OR; if (isValidParam(query, FILE)) { String filesValue = query.getString(FILE.key()); filesOperation = checkOperator(filesValue); fileNames = splitValue(filesValue, filesOperation); .filter(value -> !isNegated(value)) .map(value -> { Integer fileId = studyConfigurationManager.getFileIdPair(value, false, defaultStudyConfiguration).getValue(); }) .collect(Collectors.toList()); } else if (isValidParam(query, INCLUDE_FILE)) { List<String> files = getIncludeFilesList(query); if (files != null) { fileIds = new ArrayList<>(files.size()); if (isValidParam(query, FILTER) || isValidParam(query, QUAL) || isValidParam(query, INFO)) { String filterValue = query.getString(FILTER.key()); QueryOperation filterOperation = checkOperator(filterValue); List<String> filterValues = splitValue(filterValue, filterOperation); Pair<QueryOperation, Map<String, String>> infoParamPair = parseInfo(query); QueryOperation infoOperator = infoParamPair.getKey();
throws StorageEngineException { if (!VariantStorageEngine.UseSearchIndex.from(options).equals(VariantStorageEngine.UseSearchIndex.NO)) { // YES or AUTO if (isValidParam(query, VariantQueryParam.STUDY)) { if (VariantQueryUtils.splitValue(query.getString(VariantQueryParam.STUDY.key())).getValue().size() > 1) { if (isValidParam(query, INFO)) { if (isValidParam(query, VariantQueryParam.GENOTYPE)) { HashMap<Object, List<String>> map = new HashMap<>(); parseGenotypeFilter(query.getString(VariantQueryParam.GENOTYPE.key()), map); if (isValidParam(query, VariantQueryParam.FORMAT)) { validFormatFilter = true; formatMap = parseFormat(query).getValue(); for (String formatFilter : splitValue(formatFilters).getValue()) { String formatKey = splitOperator(formatFilter)[0]; if (!ACCEPTED_FORMAT_FILTERS.contains(formatKey)) { if (!isValidParam(query, VariantQueryParam.SAMPLE, true) && !validGenotypeFilter && !validFormatFilter && !isValidParam(query, VariantQueryParam.FILE, true)) { VariantQueryUtils.parseSelectElements(query, options, studyConfigurationManager); StudyConfiguration studyConfiguration = selectVariantElements.getStudyConfigurations().get(studyId); Set<String> samples = new HashSet<>(); if (isValidParam(query, VariantQueryParam.SAMPLE)) {
if (isValidParam(query, REGION)) { regions = Region.parseRegions(query.getString(REGION.key())); query.remove(REGION.key()); if (isValidParam(query, ANNOT_GENE_REGIONS)) { regions = Region.parseRegions(query.getString(ANNOT_GENE_REGIONS.key())); query.remove(ANNOT_GENE_REGIONS.key()); regions = mergeRegions(regions); StudyConfiguration defaultStudyConfiguration = VariantQueryUtils.getDefaultStudyConfiguration(query, null, scm); if (isValidParam(query, GENOTYPE)) { queryOperation = parseGenotypeFilter(query.getString(GENOTYPE.key()), map); valid &= !isNegated(gt); } else if (isValidParam(query, SAMPLE)) { queryOperation = VariantQueryUtils.checkOperator(samplesStr); List<String> samples = VariantQueryUtils.splitValue(samplesStr, queryOperation); samples.stream().filter(s -> !isNegated(s)).forEach(sample -> samplesMap.put(sample, Collections.emptyList()));
Function<String, Object> valueParser, Function<String[], String> extraFilters, List<String> filters, Function<String, Integer> arrayIdxParser) { if (isValidParam(query, param)) { List<String> subFilters = new LinkedList<>(); String stringValue = query.getString(param.key()); QueryOperation logicOperation = checkOperator(stringValue); if (logicOperation == null) { logicOperation = QueryOperation.AND; for (String rawValue : splitValue(stringValue, logicOperation)) { String[] keyOpValue = splitOperator(rawValue); Column column = columnParser.apply(keyOpValue, rawValue);
logger.debug("region = {}", region); addRegionFilter(scan, region); } else if (isValidParam(query, ID)) { List<String> ids = query.getAsStringList(ID.key()); if (ids.size() != 1) { throw VariantQueryException.malformedParam(ID, ids.toString(), "Unsupported multiple variant ids filter"); Variant variant = VariantQueryUtils.toVariant(ids.get(0)); addVariantIdFilter(scan, variant); regionOrVariant = variant; if (isValidParam(query, ANNOTATION_EXISTS)) { if (!query.getBoolean(ANNOTATION_EXISTS.key())) { final StudyConfiguration defaultStudyConfiguration = getDefaultStudyConfiguration(query, options, studyConfigurationManager); if (isValidParam(query, FILE)) { String value = query.getString(FILE.key()); VariantQueryUtils.QueryOperation operation = checkOperator(value); List<String> values = splitValue(value, operation); FilterList subFilters; if (operation == QueryOperation.OR) { Pair<Integer, Integer> fileIdPair = studyConfigurationManager.getFileIdPair(file, false, defaultStudyConfiguration); byte[] column = buildFileColumnKey(fileIdPair.getKey(), fileIdPair.getValue()); if (isNegated(file)) { subFilters.addFilter(missingColumnFilter(column)); } else { if (isValidParam(query, GENOTYPE)) {
public static List<String> getIncludeStudiesList(Query query, Set<VariantField> fields) { List<String> studies; if (!fields.contains(VariantField.STUDIES)) { studies = Collections.emptyList(); } else if (isValidParam(query, INCLUDE_STUDY)) { String includeStudy = query.getString(VariantQueryParam.INCLUDE_STUDY.key()); if (NONE.equals(includeStudy)) { studies = Collections.emptyList(); } else if (ALL.equals(includeStudy)) { studies = null; } else { studies = query.getAsStringList(VariantQueryParam.INCLUDE_STUDY.key()); } } else if (isValidParam(query, STUDY)) { String value = query.getString(VariantQueryParam.STUDY.key()); studies = new ArrayList<>(splitValue(value, checkOperator(value))); studies.removeIf(VariantQueryUtils::isNegated); // if empty, all the studies if (studies.isEmpty()) { studies = null; } } else { studies = null; } return studies; }
if (!isValidParam(query, FORMAT)) { return Pair.of(null, Collections.emptyMap()); return parseMultiKeyValueFilter(FORMAT, value); } else { QueryOperation operator = checkOperator(value); QueryOperation samplesOperator; Pair<QueryOperation, List<String>> pair = splitValue(sampleFilter); samples = new LinkedList<>(pair.getValue()); samplesOperator = pair.getKey(); samplesOperator = parseGenotypeFilter(query.getString(GENOTYPE.key()), genotypeMap); samples = genotypeMap.keySet().stream().map(Object::toString).collect(Collectors.toList());
VariantQueryUtils.VariantQueryXref xref = VariantQueryUtils.parseXrefs(query); if (!xref.getIds().isEmpty() || !xref.getVariants().isEmpty() || !xref.getOtherXrefs().isEmpty()) { if (isValidParam(query, GENOTYPE)) { HashMap<Object, List<String>> gtMap = new HashMap<>(); VariantQueryUtils.parseGenotypeFilter(query.getString(GENOTYPE.key()), gtMap); for (List<String> gts : gtMap.values()) { boolean valid = true; valid &= !isNegated(gt); if (isValidParam(query, SAMPLE, true)) { return true;
if (isNegated(str)) { str = removeNegation(str); String[] split = VariantQueryUtils.splitStudyResource(str); if (split.length == 2) { String study = split[0];
BiConsumer<String, QueryBuilder> addFilter) { final List<String> list; QueryOperation operation = checkOperator(value); list = splitValue(value, operation); String[] populationFrequencySplit = splitOperator(populationFrequency); String population = populationFrequencySplit[0]; String operator = populationFrequencySplit[1];
QueryOperation queryOperation = VariantQueryUtils.parseGenotypeFilter(query.getString(key), genotypeSamples); boolean addOperator = false; if (MapUtils.isNotEmpty(genotypeSamples)) { Pair<QueryOperation, Map<String, String>> parsedSampleFormats = VariantQueryUtils.parseFormat(query); String logicOpStr = parsedSampleFormats.getKey() == QueryOperation.AND ? " AND " : " OR "; StringBuilder sb = new StringBuilder(); for (String sampleId : parsedSampleFormats.getValue().keySet()) { Pair<QueryOperation, List<String>> formats = VariantQueryUtils.splitValue(parsedSampleFormats.getValue().get(sampleId)); if (formats.getValue().size() > 1) { throw VariantQueryException.malformedParam(VariantQueryParam.FORMAT, query.getString(VariantQueryParam.FORMAT.key()), sb.append(logicOpStr); String[] split = VariantQueryUtils.splitOperator(parsedSampleFormats.getValue().get(sampleId)); if (split[0] == null) { throw VariantQueryException.malformedParam(VariantQueryParam.FORMAT, query.getString(VariantQueryParam.FORMAT.key()),
SelectVariantElements selectElements = VariantQueryUtils.parseSelectElements(query, options, studyConfigurationManager.get()); List<Scan> scans = hbaseQueryParser.parseQueryMultiRegion(selectElements, query, options); try { Table table = getConnection().getTable(TableName.valueOf(variantTable)); String unknownGenotype = null; if (isValidParam(query, UNKNOWN_GENOTYPE)) { unknownGenotype = query.getString(UNKNOWN_GENOTYPE.key()); List<String> formats = getIncludeFormats(query); Iterator<ResultScanner> resScans = scans.stream().map(scan -> { try { logger.info("Query : " + VariantQueryUtils.printQuery(query)); VariantSqlQueryParser.VariantPhoenixSQLQuery phoenixQuery = queryParser.parse(query, options); String sql = phoenixQuery.getSql(); List<String> formats = getIncludeFormats(query); String unknownGenotype = null; if (isValidParam(query, UNKNOWN_GENOTYPE)) { unknownGenotype = query.getString(UNKNOWN_GENOTYPE.key());