Examples with XContentParser org.graylog.shaded.elasticsearch7.org.elasticsearch.common.xcontent.XContentParser used on opensource projects

Example 46 with XContentParser

use of org.graylog.shaded.elasticsearch7.org.elasticsearch.common.xcontent.XContentParser in project elasticsearch by elastic.

the class PrefixQueryBuilder method fromXContent.

public static PrefixQueryBuilder fromXContent(QueryParseContext parseContext) throws IOException {
    XContentParser parser = parseContext.parser();
    String fieldName = null;
    String value = null;
    String rewrite = null;
    String queryName = null;
    float boost = AbstractQueryBuilder.DEFAULT_BOOST;
    String currentFieldName = null;
    XContentParser.Token token;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (parseContext.isDeprecatedSetting(currentFieldName)) {
        // skip
        } else if (token == XContentParser.Token.START_OBJECT) {
            throwParsingExceptionOnMultipleFields(NAME, parser.getTokenLocation(), fieldName, currentFieldName);
            fieldName = currentFieldName;
            while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName();
                } else {
                    if (AbstractQueryBuilder.NAME_FIELD.match(currentFieldName)) {
                        queryName = parser.text();
                    } else if (PREFIX_FIELD.match(currentFieldName)) {
                        value = parser.textOrNull();
                    } else if (AbstractQueryBuilder.BOOST_FIELD.match(currentFieldName)) {
                        boost = parser.floatValue();
                    } else if (REWRITE_FIELD.match(currentFieldName)) {
                        rewrite = parser.textOrNull();
                    } else {
                        throw new ParsingException(parser.getTokenLocation(), "[prefix] query does not support [" + currentFieldName + "]");
                    }
                }
            }
        } else {
            throwParsingExceptionOnMultipleFields(NAME, parser.getTokenLocation(), fieldName, parser.currentName());
            fieldName = currentFieldName;
            value = parser.textOrNull();
        }
    }
    return new PrefixQueryBuilder(fieldName, value).rewrite(rewrite).boost(boost).queryName(queryName);
}

Example 47 with XContentParser

use of org.graylog.shaded.elasticsearch7.org.elasticsearch.common.xcontent.XContentParser in project elasticsearch by elastic.

the class QueryStringQueryBuilder method fromXContent.

public static QueryStringQueryBuilder fromXContent(QueryParseContext parseContext) throws IOException {
    XContentParser parser = parseContext.parser();
    String currentFieldName = null;
    XContentParser.Token token;
    String queryString = null;
    String defaultField = null;
    String analyzer = null;
    String quoteAnalyzer = null;
    String queryName = null;
    float boost = AbstractQueryBuilder.DEFAULT_BOOST;
    boolean autoGeneratePhraseQueries = QueryStringQueryBuilder.DEFAULT_AUTO_GENERATE_PHRASE_QUERIES;
    int maxDeterminizedStates = QueryStringQueryBuilder.DEFAULT_MAX_DETERMINED_STATES;
    boolean enablePositionIncrements = QueryStringQueryBuilder.DEFAULT_ENABLE_POSITION_INCREMENTS;
    boolean escape = QueryStringQueryBuilder.DEFAULT_ESCAPE;
    boolean useDisMax = QueryStringQueryBuilder.DEFAULT_USE_DIS_MAX;
    int fuzzyPrefixLength = QueryStringQueryBuilder.DEFAULT_FUZZY_PREFIX_LENGTH;
    int fuzzyMaxExpansions = QueryStringQueryBuilder.DEFAULT_FUZZY_MAX_EXPANSIONS;
    int phraseSlop = QueryStringQueryBuilder.DEFAULT_PHRASE_SLOP;
    float tieBreaker = QueryStringQueryBuilder.DEFAULT_TIE_BREAKER;
    Boolean analyzeWildcard = null;
    Boolean allowLeadingWildcard = null;
    String minimumShouldMatch = null;
    String quoteFieldSuffix = null;
    Boolean lenient = null;
    Operator defaultOperator = QueryStringQueryBuilder.DEFAULT_OPERATOR;
    String timeZone = null;
    Fuzziness fuzziness = QueryStringQueryBuilder.DEFAULT_FUZZINESS;
    String fuzzyRewrite = null;
    String rewrite = null;
    boolean splitOnWhitespace = DEFAULT_SPLIT_ON_WHITESPACE;
    Boolean useAllFields = null;
    Map<String, Float> fieldsAndWeights = new HashMap<>();
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token == XContentParser.Token.START_ARRAY) {
            if (FIELDS_FIELD.match(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                    String fField = null;
                    float fBoost = AbstractQueryBuilder.DEFAULT_BOOST;
                    char[] text = parser.textCharacters();
                    int end = parser.textOffset() + parser.textLength();
                    for (int i = parser.textOffset(); i < end; i++) {
                        if (text[i] == '^') {
                            int relativeLocation = i - parser.textOffset();
                            fField = new String(text, parser.textOffset(), relativeLocation);
                            fBoost = Float.parseFloat(new String(text, i + 1, parser.textLength() - relativeLocation - 1));
                            break;
                        }
                    }
                    if (fField == null) {
                        fField = parser.text();
                    }
                    fieldsAndWeights.put(fField, fBoost);
                }
            } else {
                throw new ParsingException(parser.getTokenLocation(), "[" + QueryStringQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");
            }
        } else if (token.isValue()) {
            if (QUERY_FIELD.match(currentFieldName)) {
                queryString = parser.text();
            } else if (DEFAULT_FIELD_FIELD.match(currentFieldName)) {
                defaultField = parser.text();
            } else if (DEFAULT_OPERATOR_FIELD.match(currentFieldName)) {
                defaultOperator = Operator.fromString(parser.text());
            } else if (ANALYZER_FIELD.match(currentFieldName)) {
                analyzer = parser.text();
            } else if (QUOTE_ANALYZER_FIELD.match(currentFieldName)) {
                quoteAnalyzer = parser.text();
            } else if (ALLOW_LEADING_WILDCARD_FIELD.match(currentFieldName)) {
                allowLeadingWildcard = parser.booleanValue();
            } else if (AUTO_GENERATE_PHRASE_QUERIES_FIELD.match(currentFieldName)) {
                autoGeneratePhraseQueries = parser.booleanValue();
            } else if (MAX_DETERMINIZED_STATES_FIELD.match(currentFieldName)) {
                maxDeterminizedStates = parser.intValue();
            } else if (LOWERCASE_EXPANDED_TERMS_FIELD.match(currentFieldName)) {
            // ignore, deprecated setting
            } else if (ENABLE_POSITION_INCREMENTS_FIELD.match(currentFieldName)) {
                enablePositionIncrements = parser.booleanValue();
            } else if (ESCAPE_FIELD.match(currentFieldName)) {
                escape = parser.booleanValue();
            } else if (USE_DIS_MAX_FIELD.match(currentFieldName)) {
                useDisMax = parser.booleanValue();
            } else if (FUZZY_PREFIX_LENGTH_FIELD.match(currentFieldName)) {
                fuzzyPrefixLength = parser.intValue();
            } else if (FUZZY_MAX_EXPANSIONS_FIELD.match(currentFieldName)) {
                fuzzyMaxExpansions = parser.intValue();
            } else if (FUZZY_REWRITE_FIELD.match(currentFieldName)) {
                fuzzyRewrite = parser.textOrNull();
            } else if (PHRASE_SLOP_FIELD.match(currentFieldName)) {
                phraseSlop = parser.intValue();
            } else if (Fuzziness.FIELD.match(currentFieldName)) {
                fuzziness = Fuzziness.parse(parser);
            } else if (AbstractQueryBuilder.BOOST_FIELD.match(currentFieldName)) {
                boost = parser.floatValue();
            } else if (TIE_BREAKER_FIELD.match(currentFieldName)) {
                tieBreaker = parser.floatValue();
            } else if (ANALYZE_WILDCARD_FIELD.match(currentFieldName)) {
                analyzeWildcard = parser.booleanValue();
            } else if (REWRITE_FIELD.match(currentFieldName)) {
                rewrite = parser.textOrNull();
            } else if (MINIMUM_SHOULD_MATCH_FIELD.match(currentFieldName)) {
                minimumShouldMatch = parser.textOrNull();
            } else if (QUOTE_FIELD_SUFFIX_FIELD.match(currentFieldName)) {
                quoteFieldSuffix = parser.textOrNull();
            } else if (LENIENT_FIELD.match(currentFieldName)) {
                lenient = parser.booleanValue();
            } else if (LOCALE_FIELD.match(currentFieldName)) {
            // ignore, deprecated setting
            } else if (ALL_FIELDS_FIELD.match(currentFieldName)) {
                useAllFields = parser.booleanValue();
            } else if (MAX_DETERMINIZED_STATES_FIELD.match(currentFieldName)) {
                maxDeterminizedStates = parser.intValue();
            } else if (TIME_ZONE_FIELD.match(currentFieldName)) {
                try {
                    timeZone = parser.text();
                } catch (IllegalArgumentException e) {
                    throw new ParsingException(parser.getTokenLocation(), "[" + QueryStringQueryBuilder.NAME + "] time_zone [" + parser.text() + "] is unknown");
                }
            } else if (AbstractQueryBuilder.NAME_FIELD.match(currentFieldName)) {
                queryName = parser.text();
            } else if (SPLIT_ON_WHITESPACE.match(currentFieldName)) {
                splitOnWhitespace = parser.booleanValue();
            } else {
                throw new ParsingException(parser.getTokenLocation(), "[" + QueryStringQueryBuilder.NAME + "] query does not support [" + currentFieldName + "]");
            }
        } else {
            throw new ParsingException(parser.getTokenLocation(), "[" + QueryStringQueryBuilder.NAME + "] unknown token [" + token + "] after [" + currentFieldName + "]");
        }
    }
    if (queryString == null) {
        throw new ParsingException(parser.getTokenLocation(), "[" + QueryStringQueryBuilder.NAME + "] must be provided with a [query]");
    }
    if ((useAllFields != null && useAllFields) && (defaultField != null || fieldsAndWeights.size() != 0)) {
        throw new ParsingException(parser.getTokenLocation(), "cannot use [all_fields] parameter in conjunction with [default_field] or [fields]");
    }
    QueryStringQueryBuilder queryStringQuery = new QueryStringQueryBuilder(queryString);
    queryStringQuery.fields(fieldsAndWeights);
    queryStringQuery.defaultField(defaultField);
    queryStringQuery.defaultOperator(defaultOperator);
    queryStringQuery.analyzer(analyzer);
    queryStringQuery.quoteAnalyzer(quoteAnalyzer);
    queryStringQuery.allowLeadingWildcard(allowLeadingWildcard);
    queryStringQuery.autoGeneratePhraseQueries(autoGeneratePhraseQueries);
    queryStringQuery.maxDeterminizedStates(maxDeterminizedStates);
    queryStringQuery.enablePositionIncrements(enablePositionIncrements);
    queryStringQuery.escape(escape);
    queryStringQuery.useDisMax(useDisMax);
    queryStringQuery.fuzzyPrefixLength(fuzzyPrefixLength);
    queryStringQuery.fuzzyMaxExpansions(fuzzyMaxExpansions);
    queryStringQuery.fuzzyRewrite(fuzzyRewrite);
    queryStringQuery.phraseSlop(phraseSlop);
    queryStringQuery.fuzziness(fuzziness);
    queryStringQuery.tieBreaker(tieBreaker);
    queryStringQuery.analyzeWildcard(analyzeWildcard);
    queryStringQuery.rewrite(rewrite);
    queryStringQuery.minimumShouldMatch(minimumShouldMatch);
    queryStringQuery.quoteFieldSuffix(quoteFieldSuffix);
    queryStringQuery.lenient(lenient);
    queryStringQuery.timeZone(timeZone);
    queryStringQuery.boost(boost);
    queryStringQuery.queryName(queryName);
    queryStringQuery.splitOnWhitespace(splitOnWhitespace);
    queryStringQuery.useAllFields(useAllFields);
    return queryStringQuery;
}

Example 48 with XContentParser

use of org.graylog.shaded.elasticsearch7.org.elasticsearch.common.xcontent.XContentParser in project elasticsearch by elastic.

the class MatchPhraseQueryBuilder method fromXContent.

public static MatchPhraseQueryBuilder fromXContent(QueryParseContext parseContext) throws IOException {
    XContentParser parser = parseContext.parser();
    String fieldName = null;
    Object value = null;
    float boost = AbstractQueryBuilder.DEFAULT_BOOST;
    String analyzer = null;
    int slop = MatchQuery.DEFAULT_PHRASE_SLOP;
    String queryName = null;
    String currentFieldName = null;
    XContentParser.Token token;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (parseContext.isDeprecatedSetting(currentFieldName)) {
        // skip
        } else if (token == XContentParser.Token.START_OBJECT) {
            throwParsingExceptionOnMultipleFields(NAME, parser.getTokenLocation(), fieldName, currentFieldName);
            fieldName = currentFieldName;
            while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName();
                } else if (token.isValue()) {
                    if (MatchQueryBuilder.QUERY_FIELD.match(currentFieldName)) {
                        value = parser.objectText();
                    } else if (MatchQueryBuilder.ANALYZER_FIELD.match(currentFieldName)) {
                        analyzer = parser.text();
                    } else if (AbstractQueryBuilder.BOOST_FIELD.match(currentFieldName)) {
                        boost = parser.floatValue();
                    } else if (SLOP_FIELD.match(currentFieldName)) {
                        slop = parser.intValue();
                    } else if (AbstractQueryBuilder.NAME_FIELD.match(currentFieldName)) {
                        queryName = parser.text();
                    } else {
                        throw new ParsingException(parser.getTokenLocation(), "[" + NAME + "] query does not support [" + currentFieldName + "]");
                    }
                } else {
                    throw new ParsingException(parser.getTokenLocation(), "[" + NAME + "] unknown token [" + token + "] after [" + currentFieldName + "]");
                }
            }
        } else {
            throwParsingExceptionOnMultipleFields(NAME, parser.getTokenLocation(), fieldName, parser.currentName());
            fieldName = parser.currentName();
            value = parser.objectText();
        }
    }
    MatchPhraseQueryBuilder matchQuery = new MatchPhraseQueryBuilder(fieldName, value);
    matchQuery.analyzer(analyzer);
    matchQuery.slop(slop);
    matchQuery.queryName(queryName);
    matchQuery.boost(boost);
    return matchQuery;
}

Example 49 with XContentParser

use of org.graylog.shaded.elasticsearch7.org.elasticsearch.common.xcontent.XContentParser in project elasticsearch by elastic.

the class MatchQueryBuilder method fromXContent.

public static MatchQueryBuilder fromXContent(QueryParseContext parseContext) throws IOException {
    XContentParser parser = parseContext.parser();
    String fieldName = null;
    MatchQuery.Type type = MatchQuery.Type.BOOLEAN;
    Object value = null;
    float boost = AbstractQueryBuilder.DEFAULT_BOOST;
    String minimumShouldMatch = null;
    String analyzer = null;
    Operator operator = MatchQueryBuilder.DEFAULT_OPERATOR;
    int slop = MatchQuery.DEFAULT_PHRASE_SLOP;
    Fuzziness fuzziness = null;
    int prefixLength = FuzzyQuery.defaultPrefixLength;
    int maxExpansion = FuzzyQuery.defaultMaxExpansions;
    boolean fuzzyTranspositions = FuzzyQuery.defaultTranspositions;
    String fuzzyRewrite = null;
    boolean lenient = MatchQuery.DEFAULT_LENIENCY;
    Float cutOffFrequency = null;
    ZeroTermsQuery zeroTermsQuery = MatchQuery.DEFAULT_ZERO_TERMS_QUERY;
    String queryName = null;
    String currentFieldName = null;
    XContentParser.Token token;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (parseContext.isDeprecatedSetting(currentFieldName)) {
        // skip
        } else if (token == XContentParser.Token.START_OBJECT) {
            throwParsingExceptionOnMultipleFields(NAME, parser.getTokenLocation(), fieldName, currentFieldName);
            fieldName = currentFieldName;
            while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName();
                } else if (token.isValue()) {
                    if (QUERY_FIELD.match(currentFieldName)) {
                        value = parser.objectText();
                    } else if (TYPE_FIELD.match(currentFieldName)) {
                        String tStr = parser.text();
                        if ("boolean".equals(tStr)) {
                            type = MatchQuery.Type.BOOLEAN;
                        } else if ("phrase".equals(tStr)) {
                            type = MatchQuery.Type.PHRASE;
                        } else if ("phrase_prefix".equals(tStr) || ("phrasePrefix".equals(tStr))) {
                            type = MatchQuery.Type.PHRASE_PREFIX;
                        } else {
                            throw new ParsingException(parser.getTokenLocation(), "[" + NAME + "] query does not support type " + tStr);
                        }
                    } else if (ANALYZER_FIELD.match(currentFieldName)) {
                        analyzer = parser.text();
                    } else if (AbstractQueryBuilder.BOOST_FIELD.match(currentFieldName)) {
                        boost = parser.floatValue();
                    } else if (SLOP_FIELD.match(currentFieldName)) {
                        slop = parser.intValue();
                    } else if (Fuzziness.FIELD.match(currentFieldName)) {
                        fuzziness = Fuzziness.parse(parser);
                    } else if (PREFIX_LENGTH_FIELD.match(currentFieldName)) {
                        prefixLength = parser.intValue();
                    } else if (MAX_EXPANSIONS_FIELD.match(currentFieldName)) {
                        maxExpansion = parser.intValue();
                    } else if (OPERATOR_FIELD.match(currentFieldName)) {
                        operator = Operator.fromString(parser.text());
                    } else if (MINIMUM_SHOULD_MATCH_FIELD.match(currentFieldName)) {
                        minimumShouldMatch = parser.textOrNull();
                    } else if (FUZZY_REWRITE_FIELD.match(currentFieldName)) {
                        fuzzyRewrite = parser.textOrNull();
                    } else if (FUZZY_TRANSPOSITIONS_FIELD.match(currentFieldName)) {
                        fuzzyTranspositions = parser.booleanValue();
                    } else if (LENIENT_FIELD.match(currentFieldName)) {
                        lenient = parser.booleanValue();
                    } else if (CUTOFF_FREQUENCY_FIELD.match(currentFieldName)) {
                        cutOffFrequency = parser.floatValue();
                    } else if (ZERO_TERMS_QUERY_FIELD.match(currentFieldName)) {
                        String zeroTermsDocs = parser.text();
                        if ("none".equalsIgnoreCase(zeroTermsDocs)) {
                            zeroTermsQuery = MatchQuery.ZeroTermsQuery.NONE;
                        } else if ("all".equalsIgnoreCase(zeroTermsDocs)) {
                            zeroTermsQuery = MatchQuery.ZeroTermsQuery.ALL;
                        } else {
                            throw new ParsingException(parser.getTokenLocation(), "Unsupported zero_terms_docs value [" + zeroTermsDocs + "]");
                        }
                    } else if (AbstractQueryBuilder.NAME_FIELD.match(currentFieldName)) {
                        queryName = parser.text();
                    } else {
                        throw new ParsingException(parser.getTokenLocation(), "[" + NAME + "] query does not support [" + currentFieldName + "]");
                    }
                } else {
                    throw new ParsingException(parser.getTokenLocation(), "[" + NAME + "] unknown token [" + token + "] after [" + currentFieldName + "]");
                }
            }
        } else {
            throwParsingExceptionOnMultipleFields(NAME, parser.getTokenLocation(), fieldName, parser.currentName());
            fieldName = parser.currentName();
            value = parser.objectText();
        }
    }
    if (value == null) {
        throw new ParsingException(parser.getTokenLocation(), "No text specified for text query");
    }
    MatchQueryBuilder matchQuery = new MatchQueryBuilder(fieldName, value);
    matchQuery.operator(operator);
    matchQuery.type(type);
    matchQuery.analyzer(analyzer);
    matchQuery.slop(slop);
    matchQuery.minimumShouldMatch(minimumShouldMatch);
    if (fuzziness != null) {
        matchQuery.fuzziness(fuzziness);
    }
    matchQuery.fuzzyRewrite(fuzzyRewrite);
    matchQuery.prefixLength(prefixLength);
    matchQuery.fuzzyTranspositions(fuzzyTranspositions);
    matchQuery.maxExpansions(maxExpansion);
    matchQuery.lenient(lenient);
    if (cutOffFrequency != null) {
        matchQuery.cutoffFrequency(cutOffFrequency);
    }
    matchQuery.zeroTermsQuery(zeroTermsQuery);
    matchQuery.queryName(queryName);
    matchQuery.boost(boost);
    return matchQuery;
}

Example 50 with XContentParser

use of org.graylog.shaded.elasticsearch7.org.elasticsearch.common.xcontent.XContentParser in project elasticsearch by elastic.

the class MoreLikeThisQueryBuilder method fromXContent.

public static MoreLikeThisQueryBuilder fromXContent(QueryParseContext parseContext) throws IOException {
    XContentParser parser = parseContext.parser();
    // document inputs
    List<String> fields = null;
    List<String> likeTexts = new ArrayList<>();
    List<String> unlikeTexts = new ArrayList<>();
    List<Item> likeItems = new ArrayList<>();
    List<Item> unlikeItems = new ArrayList<>();
    // term selection parameters
    int maxQueryTerms = MoreLikeThisQueryBuilder.DEFAULT_MAX_QUERY_TERMS;
    int minTermFreq = MoreLikeThisQueryBuilder.DEFAULT_MIN_TERM_FREQ;
    int minDocFreq = MoreLikeThisQueryBuilder.DEFAULT_MIN_DOC_FREQ;
    int maxDocFreq = MoreLikeThisQueryBuilder.DEFAULT_MAX_DOC_FREQ;
    int minWordLength = MoreLikeThisQueryBuilder.DEFAULT_MIN_WORD_LENGTH;
    int maxWordLength = MoreLikeThisQueryBuilder.DEFAULT_MAX_WORD_LENGTH;
    List<String> stopWords = null;
    String analyzer = null;
    // query formation parameters
    String minimumShouldMatch = MoreLikeThisQueryBuilder.DEFAULT_MINIMUM_SHOULD_MATCH;
    float boostTerms = MoreLikeThisQueryBuilder.DEFAULT_BOOST_TERMS;
    boolean include = MoreLikeThisQueryBuilder.DEFAULT_INCLUDE;
    // other parameters
    boolean failOnUnsupportedField = MoreLikeThisQueryBuilder.DEFAULT_FAIL_ON_UNSUPPORTED_FIELDS;
    float boost = AbstractQueryBuilder.DEFAULT_BOOST;
    String queryName = null;
    XContentParser.Token token;
    String currentFieldName = null;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if (Field.LIKE.match(currentFieldName)) {
                parseLikeField(parseContext, likeTexts, likeItems);
            } else if (Field.UNLIKE.match(currentFieldName)) {
                parseLikeField(parseContext, unlikeTexts, unlikeItems);
            } else if (Field.LIKE_TEXT.match(currentFieldName)) {
                likeTexts.add(parser.text());
            } else if (Field.MAX_QUERY_TERMS.match(currentFieldName)) {
                maxQueryTerms = parser.intValue();
            } else if (Field.MIN_TERM_FREQ.match(currentFieldName)) {
                minTermFreq = parser.intValue();
            } else if (Field.MIN_DOC_FREQ.match(currentFieldName)) {
                minDocFreq = parser.intValue();
            } else if (Field.MAX_DOC_FREQ.match(currentFieldName)) {
                maxDocFreq = parser.intValue();
            } else if (Field.MIN_WORD_LENGTH.match(currentFieldName)) {
                minWordLength = parser.intValue();
            } else if (Field.MAX_WORD_LENGTH.match(currentFieldName)) {
                maxWordLength = parser.intValue();
            } else if (Field.ANALYZER.match(currentFieldName)) {
                analyzer = parser.text();
            } else if (Field.MINIMUM_SHOULD_MATCH.match(currentFieldName)) {
                minimumShouldMatch = parser.text();
            } else if (Field.BOOST_TERMS.match(currentFieldName)) {
                boostTerms = parser.floatValue();
            } else if (Field.INCLUDE.match(currentFieldName)) {
                include = parser.booleanValue();
            } else if (Field.FAIL_ON_UNSUPPORTED_FIELD.match(currentFieldName)) {
                failOnUnsupportedField = parser.booleanValue();
            } else if ("boost".equals(currentFieldName)) {
                boost = parser.floatValue();
            } else if ("_name".equals(currentFieldName)) {
                queryName = parser.text();
            } else {
                throw new ParsingException(parser.getTokenLocation(), "[mlt] query does not support [" + currentFieldName + "]");
            }
        } else if (token == XContentParser.Token.START_ARRAY) {
            if (Field.FIELDS.match(currentFieldName)) {
                fields = new ArrayList<>();
                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                    fields.add(parser.text());
                }
            } else if (Field.LIKE.match(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                    parseLikeField(parseContext, likeTexts, likeItems);
                }
            } else if (Field.UNLIKE.match(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                    parseLikeField(parseContext, unlikeTexts, unlikeItems);
                }
            } else if (Field.IDS.match(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                    if (!token.isValue()) {
                        throw new IllegalArgumentException("ids array element should only contain ids");
                    }
                    likeItems.add(new Item(null, null, parser.text()));
                }
            } else if (Field.DOCS.match(currentFieldName)) {
                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                    if (token != XContentParser.Token.START_OBJECT) {
                        throw new IllegalArgumentException("docs array element should include an object");
                    }
                    likeItems.add(Item.parse(parser, new Item()));
                }
            } else if (Field.STOP_WORDS.match(currentFieldName)) {
                stopWords = new ArrayList<>();
                while ((token = parser.nextToken()) != XContentParser.Token.END_ARRAY) {
                    stopWords.add(parser.text());
                }
            } else {
                throw new ParsingException(parser.getTokenLocation(), "[mlt] query does not support [" + currentFieldName + "]");
            }
        } else if (token == XContentParser.Token.START_OBJECT) {
            if (Field.LIKE.match(currentFieldName)) {
                parseLikeField(parseContext, likeTexts, likeItems);
            } else if (Field.UNLIKE.match(currentFieldName)) {
                parseLikeField(parseContext, unlikeTexts, unlikeItems);
            } else {
                throw new ParsingException(parser.getTokenLocation(), "[mlt] query does not support [" + currentFieldName + "]");
            }
        }
    }
    if (likeTexts.isEmpty() && likeItems.isEmpty()) {
        throw new ParsingException(parser.getTokenLocation(), "more_like_this requires 'like' to be specified");
    }
    if (fields != null && fields.isEmpty()) {
        throw new ParsingException(parser.getTokenLocation(), "more_like_this requires 'fields' to be non-empty");
    }
    String[] fieldsArray = fields == null ? null : fields.toArray(new String[fields.size()]);
    String[] likeTextsArray = likeTexts.isEmpty() ? null : likeTexts.toArray(new String[likeTexts.size()]);
    String[] unlikeTextsArray = unlikeTexts.isEmpty() ? null : unlikeTexts.toArray(new String[unlikeTexts.size()]);
    Item[] likeItemsArray = likeItems.isEmpty() ? null : likeItems.toArray(new Item[likeItems.size()]);
    Item[] unlikeItemsArray = unlikeItems.isEmpty() ? null : unlikeItems.toArray(new Item[unlikeItems.size()]);
    MoreLikeThisQueryBuilder moreLikeThisQueryBuilder = new MoreLikeThisQueryBuilder(fieldsArray, likeTextsArray, likeItemsArray).unlike(unlikeTextsArray).unlike(unlikeItemsArray).maxQueryTerms(maxQueryTerms).minTermFreq(minTermFreq).minDocFreq(minDocFreq).maxDocFreq(maxDocFreq).minWordLength(minWordLength).maxWordLength(maxWordLength).analyzer(analyzer).minimumShouldMatch(minimumShouldMatch).boostTerms(boostTerms).include(include).failOnUnsupportedField(failOnUnsupportedField).boost(boost).queryName(queryName);
    if (stopWords != null) {
        moreLikeThisQueryBuilder.stopWords(stopWords);
    }
    return moreLikeThisQueryBuilder;
}