private String checkStringValue(String value) { if (value == null) { throw new VariantQueryException("Unable to query null text field"); } if (value.contains("'")) { throw new VariantQueryException("Unable to query text field with \"'\" : " + value); } return value; }
public static VariantQueryException studyNotFound(String study, Collection<String> availableStudies) { return new VariantQueryException("Study { name: \"" + study + "\" } not found." + (availableStudies == null || availableStudies.isEmpty() ? "" : " Available studies: " + availableStudies)); }
public static VariantQueryException missingStudyForFile(String file, Collection<String> availableStudies) { return new VariantQueryException("Unknown file \"" + file + "\". Please, specify the study belonging." + (availableStudies == null || availableStudies.isEmpty() ? "" : " Available studies: " + availableStudies)); }
public static VariantQueryException missingStudyFor(String resource, String value, Collection<String> availableStudies) { return new VariantQueryException("Unknown " + resource + " " + value + ". Please, specify the study belonging." + (availableStudies == null || availableStudies.isEmpty() ? "" : " Available studies: " + availableStudies)); }
private static VariantQueryException cohortNotFound(Number cohortId, String cohortName, int studyId, Collection<String> availableCohorts) { List<String> availableCohortsList = availableCohorts == null ? Collections.emptyList() : new ArrayList<>(availableCohorts); availableCohortsList.sort(String::compareTo); return new VariantQueryException("Cohort { " + (cohortId != null ? "id: " + cohortId + ' ' : "") + (cohortName != null && cohortId != null ? ", " : "") + (cohortName != null ? "name: \"" + cohortName + "\" " : "") + "} not found in study { id: " + studyId + " }." + (availableCohortsList.isEmpty() ? "" : " Available cohorts: " + availableCohortsList)); }
public static VariantQueryException unsupportedVariantQueryFilters(Collection<? extends QueryParam> params, String extra) { return new VariantQueryException("Unsupported variant query filters '" + params .stream() .map(QueryParam::key) .collect(Collectors.toList()) + '.' + (StringUtils.isEmpty(extra) ? "" : (' ' + extra))); } }
public static String parseNumericOperator(String op) { String parsedOp = parseOperator(op); if (parsedOp.equals("LIKE")) { throw new VariantQueryException("Unable to use REGEX operator (" + op + ") with numerical fields"); } return parsedOp; }
public static VariantQueryException missingStudyForSamples(Collection<String> samples, Collection<String> availableStudies) { if (samples.size() == 1) { return missingStudyForSample(samples.iterator().next(), availableStudies); } return new VariantQueryException("Unknown samples " + samples + ". Please, specify the study belonging." + (availableStudies == null || availableStudies.isEmpty() ? "" : " Available studies: " + availableStudies)); }
private QueryBuilder addQueryIntegerFilter(String key, String value, final QueryBuilder builder, VariantQueryUtils.QueryOperation op) { return this.addQueryFilter(key, value, builder, op, elem -> { try { return Integer.parseInt(elem); } catch (NumberFormatException e) { throw new VariantQueryException("Unable to parse int " + elem, e); } }); }
public static String parseBooleanOperator(String op) { String parsedOp = parseOperator(op); if (!parsedOp.equals("=") && !parsedOp.equals("!=")) { throw new VariantQueryException("Unable to use operator (" + op + ") with boolean fields"); } return parsedOp; }
public VariantIterable iterable(String sessionId) throws CatalogException, StorageEngineException { return (query, options) -> { try { return iterator(query, options, sessionId); } catch (CatalogException | StorageEngineException e) { throw new VariantQueryException("Error getting variant iterator", e); } }; }
public static VariantQueryException unsupportedVariantQueryFilter(QueryParam param, String storageEngineId, String extra) { return new VariantQueryException("Unsupported variant query filter '" + param.key() + "' with storage engine '" + storageEngineId + "'." + (StringUtils.isEmpty(extra) ? "" : (' ' + extra))); }
public static VariantQueryException wrongReleaseException(VariantQueryParam param, String value, int release) { return new VariantQueryException("Unable to have '" + value + "' within '" + param.key() + "' filter. " + "Not part of release " + release); }
public static VariantQueryException missingParam(QueryParam queryParam, String message) { return new VariantQueryException("Missing param \"" + queryParam.key() + "\" . " + message); }
public static VariantQueryException malformedParam(QueryParam queryParam, String value, String message) { return new VariantQueryException("Malformed \"" + queryParam.key() + "\" query : \"" + value + "\". " + message); }
private Set<String> getSamplesSet(Variant variant, Set<String> samples) { if (variant.getStudies().size() != 1) { throw new VariantQueryException("Unable to process with " + variant.getStudies().size() + " studies."); } samples.addAll(variant.getStudies().get(0).getSamplesName()); if (samples.isEmpty()) { throw new VariantQueryException("Unable to get samples!"); } return samples; }
public VariantAnnotationMetadata getSaved(String name) { ProjectMetadata.VariantAnnotationMetadata saved = null; for (ProjectMetadata.VariantAnnotationMetadata annotation : getSaved()) { if (annotation.getName().equals(name)) { saved = annotation; } } if (saved == null) { throw new VariantQueryException("Variant Annotation snapshot \"" + name + "\" not found!"); } return saved; }
public static VariantQueryException mixedAndOrOperators(VariantQueryParam param1, VariantQueryParam param2) { return new VariantQueryException("Unable to mix AND (" + AND + ") and OR (" + OR + ") across filters " + "\"" + param1.key() + "\" and \"" + param2.key() + "\"."); }
protected void setDefaultTimeout(QueryOptions options) { int defaultTimeout = getOptions().getInt(DEFAULT_TIMEOUT.key(), DEFAULT_TIMEOUT.defaultValue()); int maxTimeout = getOptions().getInt(MAX_TIMEOUT.key(), MAX_TIMEOUT.defaultValue()); int timeout = options.getInt(QueryOptions.TIMEOUT, defaultTimeout); if (timeout > maxTimeout) { throw new VariantQueryException("Invalid timeout '" + timeout + "'. Max timeout is " + maxTimeout); } else if (timeout < 0) { throw new VariantQueryException("Invalid timeout '" + timeout + "'. Timeout must be positive"); } options.put(QueryOptions.TIMEOUT, timeout); }
@Test public void testFailSearchNotAvailable() throws StorageEngineException { VariantQueryException exception = new VariantQueryException("Unable to use search index. SearchEngine is not available"); thrown.expect(exception.getClass()); thrown.expectMessage(exception.getMessage()); variantStorageEngine.getConfiguration().getSearch().setActive(false); variantStorageEngine.doIntersectWithSearch(new Query(ANNOT_TRAIT.key(), "myTrait"), new QueryOptions(USE_SEARCH_INDEX, VariantStorageEngine.UseSearchIndex.YES)); }