private long countMatchedEntities(SortaJobExecution sortaJobExecution, boolean isMatched) { double threshold = sortaJobExecution.getThreshold(); QueryRule validatedRule = new QueryRule(MatchingTaskContentMetaData.VALIDATED, EQUALS, isMatched); QueryRule thresholdRule = new QueryRule( MatchingTaskContentMetaData.SCORE, isMatched ? GREATER_EQUAL : LESS, threshold); QueryRule combinedRule = new QueryRule(asList(validatedRule, new QueryRule(isMatched ? OR : AND), thresholdRule)); return dataService.count( sortaJobExecution.getResultEntityName(), new QueryImpl<>(combinedRule)); }
/** * Create a boolean should query for composite tags containing multiple ontology terms * * @param multiOntologyTermIri * @return return a boolean should queryRule */ public QueryRule createShouldQueryRule(String multiOntologyTermIri) { QueryRule shouldQueryRule = new QueryRule(new ArrayList<QueryRule>()); shouldQueryRule.setOperator(Operator.SHOULD); for (String ontologyTermIri : multiOntologyTermIri.split(COMMA_CHAR)) { OntologyTerm ontologyTerm = ontologyService.getOntologyTerm(ontologyTermIri); List<String> queryTerms = parseOntologyTermQueries(ontologyTerm); Double termFrequency = getBestInverseDocumentFrequency(queryTerms); shouldQueryRule.getNestedRules().add(createBoostedDisMaxQueryRuleForTerms(queryTerms, termFrequency)); } return shouldQueryRule; }
private void transformQueryRule(QueryRule rule, String icd10EntityTypeId) { List<Object> queryValues; switch (rule.getOperator()) { case EQUALS: queryValues = singletonList(rule.getValue()); rule.setOperator(QueryRule.Operator.IN); break; case IN: //noinspection unchecked queryValues = (List<Object>) rule.getValue(); break; default: throw new IllegalStateException("Can't expand queries other than IN or EQUALS"); } List<Entity> diseaseTypes = dataService.findAll(icd10EntityTypeId, queryValues.stream()).collect(toList()); rule.setValue(expandDiseaseTypes(diseaseTypes)); }
/** * Returns <code>true</code> if a rule is 'IN' or 'EQUALS' on the attribute that should be * expanded */ private boolean isTransformableRule(QueryRule nestedRule, String expandAttribute) { return nestedRule != null && nestedRule.getField() != null && nestedRule.getField().equals(expandAttribute) && (nestedRule.getOperator() == QueryRule.Operator.IN || nestedRule.getOperator() == QueryRule.Operator.EQUALS); }
private static void getJoinQueryAttrsRec( EntityType entityType, List<QueryRule> rules, List<Attribute> joinAttrs) { for (QueryRule rule : rules) { if (rule.getField() != null) { Attribute attr = entityType.getAttribute(rule.getField()); if (attr != null && isPersistedInOtherTable(attr)) { joinAttrs.add(attr); } } if (rule.getNestedRules() != null && !rule.getNestedRules().isEmpty()) { getJoinQueryAttrsRec(entityType, rule.getNestedRules(), joinAttrs); } } }
/** * Create disMaxJunc query rule based a list of queryTerm. All queryTerms are lower cased and stop words are removed * * @param queryTerms * @return disMaxJunc queryRule */ public QueryRule createDisMaxQueryRuleForTerms(List<String> queryTerms) { List<QueryRule> rules = new ArrayList<QueryRule>(); queryTerms.stream().filter(StringUtils::isNotEmpty).map(this::escapeCharsExcludingCaretChar).forEach(query -> { rules.add(new QueryRule(AttributeMetadata.LABEL, Operator.FUZZY_MATCH, query)); rules.add(new QueryRule(AttributeMetadata.DESCRIPTION, Operator.FUZZY_MATCH, query)); }); QueryRule finalDisMaxQuery = new QueryRule(rules); finalDisMaxQuery.setOperator(Operator.DIS_MAX); return finalDisMaxQuery; }
private void validateQueryRule(QueryRule queryRule, EntityType entityType) { QueryRule.Operator operator = queryRule.getOperator(); switch (operator) { case AND: Object value = toQueryRuleValue(queryRule.getValue(), attr); queryRule.setValue(value); break; Object queryRuleValue = queryRule.getValue(); if (queryRuleValue != null && !(queryRuleValue instanceof String)) { queryRule.setValue(queryRuleValue.toString()); Object queryRuleValue = queryRule.getValue(); if (queryRuleValue != null) { if (!(queryRuleValue instanceof Iterable<?>)) { .map(value -> toQueryRuleValue(value, attr)) .collect(toList()); queryRule.setValue(values); case SHOULD: queryRule .getNestedRules() .forEach(nestedQueryRule -> validateQueryRule(nestedQueryRule, entityType)); break;
Lists.newArrayList(new QueryRule(AttributeMetadata.ID, Operator.IN, attributeIdentifiers)); if (!disMaxQueryRule.getNestedRules().isEmpty()) { finalQueryRules.addAll(Arrays.asList(new QueryRule(Operator.AND), disMaxQueryRule));
for (QueryRule r : q.getRules()) { Attribute attr = null; if (r.getField() != null) { attr = entityType.getAttribute(r.getField()); if (attr == null) { throw new MolgenisDataException(format("Unknown attribute [%s]", r.getField())); Operator operator = r.getOperator(); switch (operator) { case AND: break; case NESTED: QueryImpl<Entity> nestedQ = new QueryImpl<>(r.getNestedRules()); result .append('(') parameters.add("%" + PostgreSqlUtils.getPostgreSqlQueryValue(r.getValue(), attr) + '%'); break; case IN: Object inValue = r.getValue(); if (inValue == null) { throw new MolgenisDataException("Missing value for IN query"); equalsAttr = attr.getRefEntity().getIdAttribute(); } else { equalsAttr = entityType.getAttribute(r.getField());
/** * Examines a {@link Query} and finds the first {@link QueryRule} with operator {@link Operator#EQUALS} whose field * matches an attributeName. It returns the value of that first matching {@link QueryRule}. * * @param attributeName the query field name to match * @param q the query to search in * @return the value from the first matching query rule */ private static Object getFirstEqualsValueFor(String attributeName, Query<Entity> q) { return q.getRules() .stream() .filter(rule -> attributeName.equals(rule.getField()) && rule.getOperator() == Operator.EQUALS) .findFirst() .get() .getValue(); }
private static boolean isDistinctSelectRequiredRec( EntityType entityType, List<QueryRule> queryRules) { if (queryRules.isEmpty()) { return false; } for (QueryRule queryRule : queryRules) { if (queryRule.getOperator() == NESTED) { if (isDistinctSelectRequiredRec(entityType, queryRule.getNestedRules())) { return true; } } else { String queryRuleField = queryRule.getField(); if (queryRuleField != null) { String attrName = StringUtils.split(queryRuleField, '.')[0]; Attribute attr = entityType.getAttribute(attrName); if (attr == null) { throw new UnknownAttributeException(entityType, attrName); } if (isPersistedInOtherTable(attr)) { return true; } } } } return false; }
@Override public Stream<Entity> findAll(Query<Entity> q) { if (q.getRules().isEmpty()) return getEntities().stream(); if ((q.getRules().size() != 1) || (q.getRules().get(0).getOperator() != Operator.EQUALS)) { throw new MolgenisDataException("The only query allowed on this Repository is gene EQUALS"); } String geneSymbol = (String) q.getRules().get(0).getValue(); List<Entity> entities = getEntitiesByGeneSymbol().get(geneSymbol); return entities != null ? entities.stream() : Stream.empty(); }
/** * Create a disMaxJunc query rule based on the given search terms as well as the information from * given ontology terms * * @return disMaxJunc queryRule */ public QueryRule createDisMaxQueryRuleForAttribute( Set<String> searchTerms, Collection<OntologyTerm> ontologyTerms) { List<String> queryTerms = new ArrayList<>(); if (searchTerms != null) { queryTerms.addAll( searchTerms .stream() .filter(StringUtils::isNotBlank) .map(this::processQueryString) .collect(Collectors.toList())); } // Handle tags with only one ontologyterm ontologyTerms .stream() .filter(ontologyTerm -> !ontologyTerm.getIRI().contains(COMMA_CHAR)) .forEach(ot -> queryTerms.addAll(parseOntologyTermQueries(ot))); QueryRule disMaxQueryRule = createDisMaxQueryRuleForTerms(queryTerms); // Handle tags with multiple ontologyterms ontologyTerms .stream() .filter(ontologyTerm -> ontologyTerm.getIRI().contains(COMMA_CHAR)) .forEach(ot -> disMaxQueryRule.getNestedRules().add(createShouldQueryRule(ot.getIRI()))); return disMaxQueryRule; }
/** * Create a disMaxQueryRule with corresponding boosted value * * @return a disMaxQueryRule with boosted value */ public QueryRule createBoostedDisMaxQueryRuleForTerms( List<String> queryTerms, Double boostValue) { QueryRule finalDisMaxQuery = createDisMaxQueryRuleForTerms(queryTerms); if (boostValue != null && boostValue.intValue() != 0) { finalDisMaxQuery.setValue(boostValue); } return finalDisMaxQuery; }
/** * Create disMaxJunc query rule based a list of queryTerm. All queryTerms are lower cased and stop * words are removed * * @return disMaxJunc queryRule */ public QueryRule createDisMaxQueryRuleForTerms(List<String> queryTerms) { List<QueryRule> rules = new ArrayList<>(); queryTerms .stream() .filter(StringUtils::isNotEmpty) .map(this::escapeCharsExcludingCaretChar) .forEach( query -> { rules.add(new QueryRule(AttributeMetadata.LABEL, Operator.FUZZY_MATCH, query)); rules.add(new QueryRule(AttributeMetadata.DESCRIPTION, Operator.FUZZY_MATCH, query)); }); QueryRule finalDisMaxQuery = new QueryRule(rules); finalDisMaxQuery.setOperator(Operator.DIS_MAX); return finalDisMaxQuery; }
.newArrayList(new QueryRule(AttributeMetadata.ID, Operator.IN, attributeIdentifiers)); if (disMaxQueryRule.getNestedRules().size() > 0) finalQueryRules.addAll(Arrays.asList(new QueryRule(Operator.AND), disMaxQueryRule));
@Override public Stream<Entity> findAll(Query<Entity> q) { if (q.getRules().isEmpty()) return getIndex().values().stream(); if ((q.getRules().size() != 1) || (q.getRules().get(0).getOperator() != Operator.EQUALS) || !targetAttributeName .equals(q.getRules().get(0).getField())) { throw new MolgenisDataException( "The only query allowed on this Repository is '" + targetAttributeName + " EQUALS'"); } Entity result = getIndex().get(q.getRules().get(0).getValue()); return result == null ? Stream.empty() : Stream.of(result); }
@Override public Stream<Entity> findAll(Query<Entity> q) { if (q.getRules().isEmpty()) { return getEntities().stream(); } if ((q.getRules().size() != 1) || (q.getRules().get(0).getOperator() != Operator.EQUALS)) { throw new MolgenisDataException("The only query allowed on this Repository is gene EQUALS"); } String geneSymbol = (String) q.getRules().get(0).getValue(); List<Entity> entities = getEntitiesByGeneSymbol().get(geneSymbol); return entities != null ? entities.stream() : Stream.empty(); }
private static Optional<Object> getFirstEqualsValueFor(String attributeName, Query<Entity> q) { return q.getRules() .stream() .filter(rule -> attributeName.equals(rule.getField())) .filter(rule -> rule.getOperator() == QueryRule.Operator.EQUALS) .findFirst() .map(QueryRule::getValue); }