Example usage for org.apache.lucene.queryparser.flexible.core.util StringUtils toString

Introduction

In this page you can find the example usage for org.apache.lucene.queryparser.flexible.core.util StringUtils toString.

Prototype

public static String toString(Object obj) 

Source Link

Usage

From source file:com.github.vanroy.springdata.jest.CriteriaQueryProcessor.java

License:Apache License

private QueryBuilder processCriteriaEntry(Criteria.CriteriaEntry entry,
        /* OperationKey key, Object value,*/ String fieldName) {
    Object value = entry.getValue();
    if (value == null) {
        return null;
    }/* www. jav  a  2s.c o  m*/
    OperationKey key = entry.getKey();
    QueryBuilder query = null;

    String searchText = StringUtils.toString(value);

    Iterable<Object> collection = null;

    switch (key) {
    case EQUALS:
        query = queryStringQuery(searchText).field(fieldName)
                .defaultOperator(QueryStringQueryBuilder.Operator.AND);
        break;
    case CONTAINS:
        query = queryStringQuery("*" + searchText + "*").field(fieldName).analyzeWildcard(true);
        break;
    case STARTS_WITH:
        query = queryStringQuery(searchText + "*").field(fieldName).analyzeWildcard(true);
        break;
    case ENDS_WITH:
        query = queryStringQuery("*" + searchText).field(fieldName).analyzeWildcard(true);
        break;
    case EXPRESSION:
        query = queryStringQuery(searchText).field(fieldName);
        break;
    case LESS_EQUAL:
        query = rangeQuery(fieldName).lte(value);
        break;
    case GREATER_EQUAL:
        query = rangeQuery(fieldName).gte(value);
        break;
    case BETWEEN:
        Object[] ranges = (Object[]) value;
        query = rangeQuery(fieldName).from(ranges[0]).to(ranges[1]);
        break;
    case LESS:
        query = rangeQuery(fieldName).lt(value);
        break;
    case GREATER:
        query = rangeQuery(fieldName).gt(value);
        break;
    case FUZZY:
        query = fuzzyQuery(fieldName, searchText);
        break;
    case IN:
        query = boolQuery();
        collection = (Iterable<Object>) value;
        for (Object item : collection) {
            ((BoolQueryBuilder) query).should(queryStringQuery(item.toString()).field(fieldName));
        }
        break;
    case NOT_IN:
        query = boolQuery();
        collection = (Iterable<Object>) value;
        for (Object item : collection) {
            ((BoolQueryBuilder) query).mustNot(queryStringQuery(item.toString()).field(fieldName));
        }
        break;
    }
    return query;
}

---

From source file:com.mysema.query.elasticsearch.ElasticsearchSerializer.java

License:Apache License

public String asDBKey(Operation<?> expr, int index) {
    return StringUtils.toString(asDBValue(expr, index));
}

---

From source file:com.mysema.query.elasticsearch.ElasticsearchSerializer.java

License:Apache License

@Nullable
@Override//from  w  w w .j a va  2  s .c om
public Object visit(Operation<?> expr, @Nullable BoolQueryBuilder context) {
    Preconditions.checkNotNull(context);
    Operator<?> op = expr.getOperator();
    if (op == Ops.EQ) {
        Expression<?> keyArg = expr.getArg(0);
        String value = StringUtils.toString(asDBValue(expr, 1));
        if (keyArg instanceof Path<?> && isIdPath((Path<?>) expr.getArg(0))) {
            return QueryBuilders.idsQuery().ids(value);
        } else {
            // Currently all queries are made with ignore case sensitive
            // Because the query to get exact value have to be run on a not_analyzed field
            return QueryBuilders.queryString(value).field(asDBKey(expr, 0));
        }

    } else if (op == Ops.EQ_IGNORE_CASE) {
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryString(value).field(asDBKey(expr, 0));

    } else if (op == Ops.NE) {
        // Decompose the query as NOT and EQ query
        return visit(OperationImpl.create(Boolean.class, Ops.NOT,
                OperationImpl.create(Boolean.class, Ops.EQ, expr.getArg(0), expr.getArg(1))), context);

    } else if (op == Ops.STRING_IS_EMPTY) {
        return QueryBuilders.queryString("").field(asDBKey(expr, 0));

    } else if (op == Ops.AND || op == Ops.OR) {
        Operation<?> left = (Operation<?>) expr.getArg(0);
        Operation<?> right = (Operation<?>) expr.getArg(1);
        // Perform the left expression
        QueryBuilder leftResult = visitSubAndOr(op, context, left);
        // Perform the right expression
        QueryBuilder rightResult = visitSubAndOr(op, context, right);

        if (op == Ops.AND) {
            safeMust(context, leftResult);
            safeMust(context, rightResult);
        } else {
            safeShould(context, leftResult);
            safeShould(context, rightResult);
        }
        return null;

    } else if (op == Ops.IN) {

        int constIndex = 0;
        int exprIndex = 1;
        if (expr.getArg(1) instanceof Constant<?>) {
            constIndex = 1;
            exprIndex = 0;
        }
        Expression<?> keyExpr = expr.getArg(exprIndex);
        if (keyExpr instanceof Path<?> && isIdPath((Path<?>) keyExpr)) {
            IdsQueryBuilder idsQuery = QueryBuilders.idsQuery();
            // Hope this is the only case for Elasticsearch ids
            Collection<?> values = (Collection<?>) ((Constant<?>) expr.getArg(constIndex)).getConstant();
            for (Object value : values) {
                idsQuery.addIds(StringUtils.toString(value));
            }
            return idsQuery;
        } else {
            // Currently all queries are made with ignore case sensitive
            // Because the query to get exact value have to be run on a not_analyzed field
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            String key = asDBKey(expr, exprIndex);
            if (Collection.class.isAssignableFrom(expr.getArg(constIndex).getType())) {
                Collection<?> values = (Collection<?>) ((Constant<?>) expr.getArg(constIndex)).getConstant();
                for (Object value : values) {
                    boolQuery.should(QueryBuilders.queryString(StringUtils.toString(value)).field(key));
                }
                return boolQuery;

            } else {
            }
        }

    } else if (op == Ops.NOT_IN) {
        // Decompose the query as NOT and IN query
        return visit(OperationImpl.create(Boolean.class, Ops.NOT,
                OperationImpl.create(Boolean.class, Ops.IN, expr.getArg(1))), context);

    } else if (op == Ops.BETWEEN) {
        Object from = asDBValue(expr, 1);
        Object to = asDBValue(expr, 2);
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).from(from).to(to);

    } else if (op == Ops.LT) {
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).lt(asDBValue(expr, 1));

    } else if (op == Ops.GT) {
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).gt(asDBValue(expr, 1));

    } else if (op == Ops.LOE) {
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).lte(asDBValue(expr, 1));

    } else if (op == Ops.GOE) {
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).gte(asDBValue(expr, 1));

    } else if (op == Ops.STARTS_WITH) {
        // Currently all queries are made with ignore case sensitive
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryString(value + "*").field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.STARTS_WITH_IC) {
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryString(value + "*").field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.ENDS_WITH) {
        // Currently all queries are made with ignore case sensitive
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryString("*" + value).field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.ENDS_WITH_IC) {
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryString("*" + value).field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.STRING_CONTAINS) {
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryString("*" + value + "*").field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.NOT) {
        // Handle the not's child
        BoolQueryBuilder subContext = QueryBuilders.boolQuery();
        QueryBuilder result = (QueryBuilder) expr.getArg(0).accept(this, subContext);
        if (result == null) {
            result = subContext;
        }
        return QueryBuilders.boolQuery().mustNot(result);

    }

    throw new UnsupportedOperationException("Illegal operation " + expr);
}

---

From source file:com.mysema.query.elasticsearch.ElasticsearchSerializerTest.java

License:Apache License

public static QueryBuilder eq(String key, Object value) {
    return QueryBuilders.queryString(StringUtils.toString(value)).field(key);
}

---

From source file:com.querydsl.elasticsearch.ElasticsearchSerializer.java

License:Apache License

@Nullable
@Override//ww  w  .  j  a v a  2 s.c  o  m
public Object visit(Operation<?> expr, @Nullable BoolQueryBuilder context) {
    Preconditions.checkNotNull(context);
    Operator op = expr.getOperator();
    if (op == Ops.EQ) {
        Expression<?> keyArg = expr.getArg(0);
        String value = StringUtils.toString(asDBValue(expr, 1));
        if (keyArg instanceof Path<?> && isIdPath((Path<?>) expr.getArg(0))) {
            return QueryBuilders.idsQuery().ids(value);
        } else {
            // Currently all queries are made with ignore case sensitive
            // Because the query to get exact value have to be run on a not_analyzed field
            return QueryBuilders.queryString(value).field(asDBKey(expr, 0));
        }

    } else if (op == Ops.EQ_IGNORE_CASE) {
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryString(value).field(asDBKey(expr, 0));

    } else if (op == Ops.NE) {
        // Decompose the query as NOT and EQ query
        return visit(
                Expressions.predicate(Ops.NOT, Expressions.predicate(Ops.EQ, expr.getArg(0), expr.getArg(1))),
                context);

    } else if (op == Ops.STRING_IS_EMPTY) {
        return QueryBuilders.queryString("").field(asDBKey(expr, 0));

    } else if (op == Ops.AND || op == Ops.OR) {
        Operation<?> left = (Operation<?>) expr.getArg(0);
        Operation<?> right = (Operation<?>) expr.getArg(1);
        // Perform the left expression
        QueryBuilder leftResult = visitSubAndOr(op, context, left);
        // Perform the right expression
        QueryBuilder rightResult = visitSubAndOr(op, context, right);

        if (op == Ops.AND) {
            safeMust(context, leftResult);
            safeMust(context, rightResult);
        } else {
            safeShould(context, leftResult);
            safeShould(context, rightResult);
        }
        return null;

    } else if (op == Ops.IN) {

        int constIndex = 0;
        int exprIndex = 1;
        if (expr.getArg(1) instanceof Constant<?>) {
            constIndex = 1;
            exprIndex = 0;
        }
        Expression<?> keyExpr = expr.getArg(exprIndex);
        if (keyExpr instanceof Path<?> && isIdPath((Path<?>) keyExpr)) {
            IdsQueryBuilder idsQuery = QueryBuilders.idsQuery();
            // Hope this is the only case for Elasticsearch ids
            Collection<?> values = (Collection<?>) ((Constant<?>) expr.getArg(constIndex)).getConstant();
            for (Object value : values) {
                idsQuery.addIds(StringUtils.toString(value));
            }
            return idsQuery;
        } else {
            // Currently all queries are made with ignore case sensitive
            // Because the query to get exact value have to be run on a not_analyzed field
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            String key = asDBKey(expr, exprIndex);
            if (Collection.class.isAssignableFrom(expr.getArg(constIndex).getType())) {
                Collection<?> values = (Collection<?>) ((Constant<?>) expr.getArg(constIndex)).getConstant();
                for (Object value : values) {
                    boolQuery.should(QueryBuilders.queryString(StringUtils.toString(value)).field(key));
                }
                return boolQuery;

            }
        }

    } else if (op == Ops.NOT_IN) {
        // Decompose the query as NOT and IN query
        return visit(Expressions.predicate(Ops.NOT, Expressions.predicate(Ops.IN, expr.getArg(1))), context);

    } else if (op == Ops.BETWEEN) {
        Object from = asDBValue(expr, 1);
        Object to = asDBValue(expr, 2);
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).from(from).to(to);

    } else if (op == Ops.LT) {
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).lt(asDBValue(expr, 1));

    } else if (op == Ops.GT) {
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).gt(asDBValue(expr, 1));

    } else if (op == Ops.LOE) {
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).lte(asDBValue(expr, 1));

    } else if (op == Ops.GOE) {
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).gte(asDBValue(expr, 1));

    } else if (op == Ops.STARTS_WITH) {
        // Currently all queries are made with ignore case sensitive
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryString(value + "*").field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.STARTS_WITH_IC) {
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryString(value + "*").field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.ENDS_WITH) {
        // Currently all queries are made with ignore case sensitive
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryString("*" + value).field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.ENDS_WITH_IC) {
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryString("*" + value).field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.STRING_CONTAINS) {
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryString("*" + value + "*").field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.NOT) {
        // Handle the not's child
        BoolQueryBuilder subContext = QueryBuilders.boolQuery();
        QueryBuilder result = (QueryBuilder) expr.getArg(0).accept(this, subContext);
        if (result == null) {
            result = subContext;
        }
        return QueryBuilders.boolQuery().mustNot(result);

    }

    throw new UnsupportedOperationException("Illegal operation " + expr);
}

---

From source file:com.querydsl.elasticsearch2.ElasticsearchSerializer.java

License:Apache License

@Nullable
@Override// w  w w. j  a  v a 2  s  .co  m
public Object visit(Operation<?> expr, @Nullable BoolQueryBuilder context) {
    Preconditions.checkNotNull(context);
    Operator op = expr.getOperator();
    if (op == Ops.EQ) {
        Expression<?> keyArg = expr.getArg(0);
        String value = StringUtils.toString(asDBValue(expr, 1));
        if (keyArg instanceof Path<?> && isIdPath((Path<?>) expr.getArg(0))) {
            return QueryBuilders.idsQuery().ids(value);
        } else {
            // Currently all queries are made with ignore case sensitive
            // Because the query to get exact value have to be run on a not_analyzed field
            return QueryBuilders.queryStringQuery(value).field(asDBKey(expr, 0));
        }

    } else if (op == Ops.EQ_IGNORE_CASE) {
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryStringQuery(value).field(asDBKey(expr, 0));

    } else if (op == Ops.NE) {
        // Decompose the query as NOT and EQ query
        return visit(
                Expressions.predicate(Ops.NOT, Expressions.predicate(Ops.EQ, expr.getArg(0), expr.getArg(1))),
                context);

    } else if (op == Ops.STRING_IS_EMPTY) {
        return QueryBuilders.queryStringQuery("").field(asDBKey(expr, 0));

    } else if (op == Ops.AND || op == Ops.OR) {
        Operation<?> left = (Operation<?>) expr.getArg(0);
        Operation<?> right = (Operation<?>) expr.getArg(1);
        // Perform the left expression
        QueryBuilder leftResult = visitSubAndOr(op, context, left);
        // Perform the right expression
        QueryBuilder rightResult = visitSubAndOr(op, context, right);

        if (op == Ops.AND) {
            safeMust(context, leftResult);
            safeMust(context, rightResult);
        } else {
            safeShould(context, leftResult);
            safeShould(context, rightResult);
        }
        return null;

    } else if (op == Ops.IN) {

        int constIndex = 0;
        int exprIndex = 1;
        if (expr.getArg(1) instanceof Constant<?>) {
            constIndex = 1;
            exprIndex = 0;
        }
        Expression<?> keyExpr = expr.getArg(exprIndex);
        if (keyExpr instanceof Path<?> && isIdPath((Path<?>) keyExpr)) {
            IdsQueryBuilder idsQuery = QueryBuilders.idsQuery();
            // Hope this is the only case for Elasticsearch ids
            Collection<?> values = (Collection<?>) ((Constant<?>) expr.getArg(constIndex)).getConstant();
            for (Object value : values) {
                idsQuery.addIds(StringUtils.toString(value));
            }
            return idsQuery;
        } else {
            // Currently all queries are made with ignore case sensitive
            // Because the query to get exact value have to be run on a not_analyzed field
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            String key = asDBKey(expr, exprIndex);
            if (Collection.class.isAssignableFrom(expr.getArg(constIndex).getType())) {
                Collection<?> values = (Collection<?>) ((Constant<?>) expr.getArg(constIndex)).getConstant();
                for (Object value : values) {
                    boolQuery.should(QueryBuilders.queryStringQuery(StringUtils.toString(value)).field(key));
                }
                return boolQuery;

            }
        }

    } else if (op == Ops.NOT_IN) {
        // Decompose the query as NOT and IN query
        return visit(Expressions.predicate(Ops.NOT, Expressions.predicate(Ops.IN, expr.getArg(1))), context);

    } else if (op == Ops.BETWEEN) {
        Object from = asDBValue(expr, 1);
        Object to = asDBValue(expr, 2);
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).from(from).to(to);

    } else if (op == Ops.LT) {
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).lt(asDBValue(expr, 1));

    } else if (op == Ops.GT) {
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).gt(asDBValue(expr, 1));

    } else if (op == Ops.LOE) {
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).lte(asDBValue(expr, 1));

    } else if (op == Ops.GOE) {
        return QueryBuilders.rangeQuery(asDBKey(expr, 0)).gte(asDBValue(expr, 1));

    } else if (op == Ops.STARTS_WITH) {
        // Currently all queries are made with ignore case sensitive
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryStringQuery(value + "*").field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.STARTS_WITH_IC) {
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryStringQuery(value + "*").field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.ENDS_WITH) {
        // Currently all queries are made with ignore case sensitive
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryStringQuery("*" + value).field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.ENDS_WITH_IC) {
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryStringQuery("*" + value).field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.STRING_CONTAINS) {
        String value = StringUtils.toString(asDBValue(expr, 1));
        return QueryBuilders.queryStringQuery("*" + value + "*").field(asDBKey(expr, 0)).analyzeWildcard(true);

    } else if (op == Ops.NOT) {
        // Handle the not's child
        BoolQueryBuilder subContext = QueryBuilders.boolQuery();
        QueryBuilder result = (QueryBuilder) expr.getArg(0).accept(this, subContext);
        if (result == null) {
            result = subContext;
        }
        return QueryBuilders.boolQuery().mustNot(result);

    }

    throw new UnsupportedOperationException("Illegal operation " + expr);
}

---

From source file:com.querydsl.elasticsearch2.ElasticsearchSerializerTest.java

License:Apache License

public static QueryBuilder eq(String key, Object value) {
    return QueryBuilders.queryStringQuery(StringUtils.toString(value)).field(key);
}

---

From source file:com.sindicetech.siren.qparser.keyword.builders.NodeTermRangeQueryNodeBuilder.java

License:Open Source License

public NodeQuery build(final QueryNode queryNode) throws QueryNodeException {
    final TermRangeQueryNode rangeNode = (TermRangeQueryNode) queryNode;
    final FieldQueryNode upper = rangeNode.getUpperBound();
    final FieldQueryNode lower = rangeNode.getLowerBound();

    final String field = StringUtils.toString(rangeNode.getField());
    String lowerText = lower.getTextAsString();
    String upperText = upper.getTextAsString();

    if (lowerText.length() == 0) {
        lowerText = null;/*from   w w  w  . ja v  a2s.c  o m*/
    }

    if (upperText.length() == 0) {
        upperText = null;
    }

    final NodeTermRangeQuery rangeQuery = NodeTermRangeQuery.newStringRange(field, lowerText, upperText,
            rangeNode.isLowerInclusive(), rangeNode.isUpperInclusive());

    final MultiNodeTermQuery.RewriteMethod method = (MultiNodeTermQuery.RewriteMethod) queryNode
            .getTag(MultiNodeTermRewriteMethodProcessor.TAG_ID);

    if (method != null) {
        rangeQuery.setRewriteMethod(method);
    }

    // if it is tagged as a span query
    if (rangeNode.getTag(QueryTypeProcessor.QUERYTYPE_TAG) == QueryTypeProcessor.SPAN_QUERYTYPE) {
        return new MultiTermSpanQuery<>(rangeQuery);
    } else {
        return rangeQuery;
    }
}

---

From source file:org.sindice.siren.qparser.keyword.builders.NodeTermRangeQueryNodeBuilder.java

License:Apache License

public NodeTermRangeQuery build(final QueryNode queryNode) throws QueryNodeException {
    final TermRangeQueryNode rangeNode = (TermRangeQueryNode) queryNode;
    final FieldQueryNode upper = rangeNode.getUpperBound();
    final FieldQueryNode lower = rangeNode.getLowerBound();

    final String field = StringUtils.toString(rangeNode.getField());
    String lowerText = lower.getTextAsString();
    String upperText = upper.getTextAsString();

    if (lowerText.length() == 0) {
        lowerText = null;/*from w ww  .j  a v a2s .co m*/
    }

    if (upperText.length() == 0) {
        upperText = null;
    }

    final NodeTermRangeQuery rangeQuery = NodeTermRangeQuery.newStringRange(field, lowerText, upperText,
            rangeNode.isLowerInclusive(), rangeNode.isUpperInclusive());

    final MultiNodeTermQuery.RewriteMethod method = (MultiNodeTermQuery.RewriteMethod) queryNode
            .getTag(MultiNodeTermRewriteMethodProcessor.TAG_ID);
    if (method != null) {
        rangeQuery.setRewriteMethod(method);
    }
    return rangeQuery;
}

---

From source file:org.springframework.data.elasticsearch.core.CriteriaQueryProcessor.java

License:Apache License

private QueryBuilder processCriteriaEntry(OperationKey key, Object value, String fieldName) {
    if (value == null) {
        return null;
    }/*w ww  .  j  av  a2  s. c om*/
    QueryBuilder query = null;

    String searchText = StringUtils.toString(value);

    switch (key) {
    case EQUALS:
        query = queryString(searchText).field(fieldName);
        break;
    case CONTAINS:
        query = queryString("*" + searchText + "*").field(fieldName).analyzeWildcard(true);
        break;
    case STARTS_WITH:
        query = queryString(searchText + "*").field(fieldName).analyzeWildcard(true);
        break;
    case ENDS_WITH:
        query = queryString("*" + searchText).field(fieldName).analyzeWildcard(true);
        break;
    case EXPRESSION:
        query = queryString((String) value).field(fieldName);
        break;
    case BETWEEN:
        Object[] ranges = (Object[]) value;
        query = rangeQuery(fieldName).from(ranges[0]).to(ranges[1]);
        break;
    case FUZZY:
        query = fuzzyQuery(fieldName, (String) value);
        break;
    case IN:
        query = boolQuery();
        Iterable<Object> collection = (Iterable<Object>) value;
        for (Object item : collection) {
            ((BoolQueryBuilder) query).should(queryString((String) item).field(fieldName));
        }
        break;
    }

    return query;
}

---