Examples with FIELD_NOT_ANALYZED org.molgenis.data.elasticsearch.FieldConstants.FIELD_NOT_ANALYZED used on opensource projects

Example 1 with FIELD_NOT_ANALYZED

use of org.molgenis.data.elasticsearch.FieldConstants.FIELD_NOT_ANALYZED in project molgenis by molgenis.

the class QueryGenerator method createQueryClauseIn.

private QueryBuilder createQueryClauseIn(QueryRule queryRule, EntityType entityType) {
    List<Attribute> attributePath = getAttributePath(queryRule.getField(), entityType);
    Attribute attr = attributePath.get(attributePath.size() - 1);
    Object queryRuleValue = queryRule.getValue();
    if (queryRuleValue == null) {
        throw new MolgenisQueryException("Query value cannot be null");
    }
    if (!(queryRuleValue instanceof Iterable<?>)) {
        throw new MolgenisQueryException("Query value must be a Iterable instead of [" + queryRuleValue.getClass().getSimpleName() + "]");
    }
    Object[] queryValues = StreamSupport.stream(((Iterable<?>) queryRuleValue).spliterator(), false).map(aQueryRuleValue -> getQueryValue(attr, aQueryRuleValue)).toArray();
    QueryBuilder queryBuilder;
    String fieldName = getQueryFieldName(attr);
    AttributeType dataType = attr.getDataType();
    switch(dataType) {
        case BOOL:
        case DATE:
        case DATE_TIME:
        case DECIMAL:
        case EMAIL:
        case ENUM:
        case HTML:
        case HYPERLINK:
        case INT:
        case LONG:
        case SCRIPT:
        case STRING:
        case TEXT:
            if (useNotAnalyzedField(attr)) {
                fieldName = fieldName + '.' + FIELD_NOT_ANALYZED;
            }
            // note: inFilter expects array, not iterable
            queryBuilder = QueryBuilders.termsQuery(fieldName, queryValues);
            queryBuilder = nestedQueryBuilder(attributePath, queryBuilder);
            break;
        case CATEGORICAL:
        case CATEGORICAL_MREF:
        case MREF:
        case XREF:
        case FILE:
        case ONE_TO_MANY:
            if (attributePath.size() > 1) {
                throw new UnsupportedOperationException("Can not filter on references deeper than 1.");
            }
            Attribute refIdAttr = attr.getRefEntity().getIdAttribute();
            List<Attribute> refAttributePath = concat(attributePath.stream(), of(refIdAttr)).collect(toList());
            String indexFieldName = getQueryFieldName(refAttributePath);
            if (useNotAnalyzedField(refIdAttr)) {
                indexFieldName = indexFieldName + '.' + FIELD_NOT_ANALYZED;
            }
            queryBuilder = QueryBuilders.termsQuery(indexFieldName, queryValues);
            queryBuilder = QueryBuilders.nestedQuery(fieldName, queryBuilder, ScoreMode.Avg);
            break;
        case COMPOUND:
            throw new MolgenisQueryException("Illegal data type [" + dataType + "] for operator [" + QueryRule.Operator.IN + "]");
        default:
            throw new UnexpectedEnumException(dataType);
    }
    return QueryBuilders.constantScoreQuery(queryBuilder);
}