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

Example 46 with XContentParser

use of 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.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.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.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.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;
}