Examples with ElasticsearchParseException org.elasticsearch.ElasticsearchParseException used on opensource projects

Example 26 with ElasticsearchParseException

use of org.elasticsearch.ElasticsearchParseException in project elasticsearch by elastic.

the class DecayFunctionBuilder method parseGeoVariable.

private AbstractDistanceScoreFunction parseGeoVariable(XContentParser parser, QueryShardContext context, MappedFieldType fieldType, MultiValueMode mode) throws IOException {
    XContentParser.Token token;
    String parameterName = null;
    GeoPoint origin = new GeoPoint();
    String scaleString = null;
    String offsetString = "0km";
    double decay = 0.5;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            parameterName = parser.currentName();
        } else if (DecayFunctionBuilder.SCALE.equals(parameterName)) {
            scaleString = parser.text();
        } else if (DecayFunctionBuilder.ORIGIN.equals(parameterName)) {
            origin = GeoUtils.parseGeoPoint(parser);
        } else if (DecayFunctionBuilder.DECAY.equals(parameterName)) {
            decay = parser.doubleValue();
        } else if (DecayFunctionBuilder.OFFSET.equals(parameterName)) {
            offsetString = parser.text();
        } else {
            throw new ElasticsearchParseException("parameter [{}] not supported!", parameterName);
        }
    }
    if (origin == null || scaleString == null) {
        throw new ElasticsearchParseException("[{}] and [{}] must be set for geo fields.", DecayFunctionBuilder.ORIGIN, DecayFunctionBuilder.SCALE);
    }
    double scale = DistanceUnit.DEFAULT.parse(scaleString, DistanceUnit.DEFAULT);
    double offset = DistanceUnit.DEFAULT.parse(offsetString, DistanceUnit.DEFAULT);
    IndexGeoPointFieldData indexFieldData = context.getForField(fieldType);
    return new GeoFieldDataScoreFunction(origin, scale, decay, offset, getDecayFunction(), indexFieldData, mode);
}

Example 27 with ElasticsearchParseException

use of org.elasticsearch.ElasticsearchParseException in project elasticsearch by elastic.

the class GeoBoundingBoxQueryBuilder method fromXContent.

public static GeoBoundingBoxQueryBuilder fromXContent(QueryParseContext parseContext) throws IOException {
    XContentParser parser = parseContext.parser();
    String fieldName = null;
    double top = Double.NaN;
    double bottom = Double.NaN;
    double left = Double.NaN;
    double right = Double.NaN;
    float boost = AbstractQueryBuilder.DEFAULT_BOOST;
    String queryName = null;
    String currentFieldName = null;
    XContentParser.Token token;
    GeoValidationMethod validationMethod = null;
    boolean ignoreUnmapped = DEFAULT_IGNORE_UNMAPPED;
    GeoPoint sparse = new GeoPoint();
    String type = "memory";
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token == XContentParser.Token.START_OBJECT) {
            fieldName = currentFieldName;
            while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentFieldName = parser.currentName();
                    token = parser.nextToken();
                    if (parseContext.isDeprecatedSetting(currentFieldName)) {
                    // skip
                    } else if (FIELD_FIELD.match(currentFieldName)) {
                        fieldName = parser.text();
                    } else if (TOP_FIELD.match(currentFieldName)) {
                        top = parser.doubleValue();
                    } else if (BOTTOM_FIELD.match(currentFieldName)) {
                        bottom = parser.doubleValue();
                    } else if (LEFT_FIELD.match(currentFieldName)) {
                        left = parser.doubleValue();
                    } else if (RIGHT_FIELD.match(currentFieldName)) {
                        right = parser.doubleValue();
                    } else {
                        if (TOP_LEFT_FIELD.match(currentFieldName)) {
                            GeoUtils.parseGeoPoint(parser, sparse);
                            top = sparse.getLat();
                            left = sparse.getLon();
                        } else if (BOTTOM_RIGHT_FIELD.match(currentFieldName)) {
                            GeoUtils.parseGeoPoint(parser, sparse);
                            bottom = sparse.getLat();
                            right = sparse.getLon();
                        } else if (TOP_RIGHT_FIELD.match(currentFieldName)) {
                            GeoUtils.parseGeoPoint(parser, sparse);
                            top = sparse.getLat();
                            right = sparse.getLon();
                        } else if (BOTTOM_LEFT_FIELD.match(currentFieldName)) {
                            GeoUtils.parseGeoPoint(parser, sparse);
                            bottom = sparse.getLat();
                            left = sparse.getLon();
                        } else {
                            throw new ElasticsearchParseException("failed to parse [{}] query. unexpected field [{}]", NAME, currentFieldName);
                        }
                    }
                } else {
                    throw new ElasticsearchParseException("failed to parse [{}] query. field name expected but [{}] found", NAME, token);
                }
            }
        } else if (token.isValue()) {
            if (AbstractQueryBuilder.NAME_FIELD.match(currentFieldName)) {
                queryName = parser.text();
            } else if (AbstractQueryBuilder.BOOST_FIELD.match(currentFieldName)) {
                boost = parser.floatValue();
            } else if (VALIDATION_METHOD_FIELD.match(currentFieldName)) {
                validationMethod = GeoValidationMethod.fromString(parser.text());
            } else if (IGNORE_UNMAPPED_FIELD.match(currentFieldName)) {
                ignoreUnmapped = parser.booleanValue();
            } else if (TYPE_FIELD.match(currentFieldName)) {
                type = parser.text();
            } else {
                throw new ParsingException(parser.getTokenLocation(), "failed to parse [{}] query. unexpected field [{}]", NAME, currentFieldName);
            }
        }
    }
    //just keep the object
    final GeoPoint topLeft = sparse.reset(top, left);
    final GeoPoint bottomRight = new GeoPoint(bottom, right);
    GeoBoundingBoxQueryBuilder builder = new GeoBoundingBoxQueryBuilder(fieldName);
    builder.setCorners(topLeft, bottomRight);
    builder.queryName(queryName);
    builder.boost(boost);
    builder.type(GeoExecType.fromString(type));
    builder.ignoreUnmapped(ignoreUnmapped);
    if (validationMethod != null) {
        // ignore deprecated coerce/ignoreMalformed settings if validationMethod is set
        builder.setValidationMethod(validationMethod);
    }
    return builder;
}

Example 28 with ElasticsearchParseException

use of org.elasticsearch.ElasticsearchParseException in project elasticsearch by elastic.

the class TermSuggestionBuilder method fromXContent.

public static TermSuggestionBuilder fromXContent(XContentParser parser) throws IOException {
    TermSuggestionBuilder tmpSuggestion = new TermSuggestionBuilder("_na_");
    XContentParser.Token token;
    String currentFieldName = null;
    String fieldname = null;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (token.isValue()) {
            if (SuggestionBuilder.ANALYZER_FIELD.match(currentFieldName)) {
                tmpSuggestion.analyzer(parser.text());
            } else if (SuggestionBuilder.FIELDNAME_FIELD.match(currentFieldName)) {
                fieldname = parser.text();
            } else if (SuggestionBuilder.SIZE_FIELD.match(currentFieldName)) {
                tmpSuggestion.size(parser.intValue());
            } else if (SuggestionBuilder.SHARDSIZE_FIELD.match(currentFieldName)) {
                tmpSuggestion.shardSize(parser.intValue());
            } else if (SUGGESTMODE_FIELD.match(currentFieldName)) {
                tmpSuggestion.suggestMode(SuggestMode.resolve(parser.text()));
            } else if (ACCURACY_FIELD.match(currentFieldName)) {
                tmpSuggestion.accuracy(parser.floatValue());
            } else if (SORT_FIELD.match(currentFieldName)) {
                tmpSuggestion.sort(SortBy.resolve(parser.text()));
            } else if (STRING_DISTANCE_FIELD.match(currentFieldName)) {
                tmpSuggestion.stringDistance(StringDistanceImpl.resolve(parser.text()));
            } else if (MAX_EDITS_FIELD.match(currentFieldName)) {
                tmpSuggestion.maxEdits(parser.intValue());
            } else if (MAX_INSPECTIONS_FIELD.match(currentFieldName)) {
                tmpSuggestion.maxInspections(parser.intValue());
            } else if (MAX_TERM_FREQ_FIELD.match(currentFieldName)) {
                tmpSuggestion.maxTermFreq(parser.floatValue());
            } else if (PREFIX_LENGTH_FIELD.match(currentFieldName)) {
                tmpSuggestion.prefixLength(parser.intValue());
            } else if (MIN_WORD_LENGTH_FIELD.match(currentFieldName)) {
                tmpSuggestion.minWordLength(parser.intValue());
            } else if (MIN_DOC_FREQ_FIELD.match(currentFieldName)) {
                tmpSuggestion.minDocFreq(parser.floatValue());
            } else {
                throw new ParsingException(parser.getTokenLocation(), "suggester[term] doesn't support field [" + currentFieldName + "]");
            }
        } else {
            throw new ParsingException(parser.getTokenLocation(), "suggester[term] parsing failed on [" + currentFieldName + "]");
        }
    }
    // now we should have field name, check and copy fields over to the suggestion builder we return
    if (fieldname == null) {
        throw new ElasticsearchParseException("the required field option [" + FIELDNAME_FIELD.getPreferredName() + "] is missing");
    }
    return new TermSuggestionBuilder(fieldname, tmpSuggestion);
}

Example 29 with ElasticsearchParseException

use of org.elasticsearch.ElasticsearchParseException in project elasticsearch by elastic.

the class SnapshotShardFailure method fromXContent.

/**
     * Deserializes snapshot failure information from JSON
     *
     * @param parser JSON parser
     * @return snapshot failure information
     */
public static SnapshotShardFailure fromXContent(XContentParser parser) throws IOException {
    SnapshotShardFailure snapshotShardFailure = new SnapshotShardFailure();
    XContentParser.Token token = parser.currentToken();
    String index = null;
    String index_uuid = IndexMetaData.INDEX_UUID_NA_VALUE;
    int shardId = -1;
    if (token == XContentParser.Token.START_OBJECT) {
        while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
            if (token == XContentParser.Token.FIELD_NAME) {
                String currentFieldName = parser.currentName();
                token = parser.nextToken();
                if (token.isValue()) {
                    if ("index".equals(currentFieldName)) {
                        index = parser.text();
                    } else if ("index_uuid".equals(currentFieldName)) {
                        index_uuid = parser.text();
                    } else if ("node_id".equals(currentFieldName)) {
                        snapshotShardFailure.nodeId = parser.text();
                    } else if ("reason".equals(currentFieldName)) {
                        snapshotShardFailure.reason = parser.text();
                    } else if ("shard_id".equals(currentFieldName)) {
                        shardId = parser.intValue();
                    } else if ("status".equals(currentFieldName)) {
                        snapshotShardFailure.status = RestStatus.valueOf(parser.text());
                    } else {
                        throw new ElasticsearchParseException("unknown parameter [{}]", currentFieldName);
                    }
                }
            } else {
                throw new ElasticsearchParseException("unexpected token [{}]", token);
            }
        }
    } else {
        throw new ElasticsearchParseException("unexpected token [{}]", token);
    }
    if (index == null) {
        throw new ElasticsearchParseException("index name was not set");
    }
    if (shardId == -1) {
        throw new ElasticsearchParseException("index shard was not set");
    }
    snapshotShardFailure.shardId = new ShardId(index, index_uuid, shardId);
    return snapshotShardFailure;
}

Example 30 with ElasticsearchParseException

use of org.elasticsearch.ElasticsearchParseException in project elasticsearch by elastic.

the class GeoContextMapping method parseContext.

/**
     * Parse a set of {@link CharSequence} contexts at index-time.
     * Acceptable formats:
     *
     *  <ul>
     *     <li>Array: <pre>[<i>&lt;GEO POINT&gt;</i>, ..]</pre></li>
     *     <li>String/Object/Array: <pre>&quot;GEO POINT&quot;</pre></li>
     *  </ul>
     *
     * see {@link GeoUtils#parseGeoPoint(String, GeoPoint)} for GEO POINT
     */
@Override
public Set<CharSequence> parseContext(ParseContext parseContext, XContentParser parser) throws IOException, ElasticsearchParseException {
    if (fieldName != null) {
        FieldMapper mapper = parseContext.docMapper().mappers().getMapper(fieldName);
        if (!(mapper instanceof GeoPointFieldMapper)) {
            throw new ElasticsearchParseException("referenced field must be mapped to geo_point");
        }
    }
    final Set<CharSequence> contexts = new HashSet<>();
    Token token = parser.currentToken();
    if (token == Token.START_ARRAY) {
        token = parser.nextToken();
        // Test if value is a single point in <code>[lon, lat]</code> format
        if (token == Token.VALUE_NUMBER) {
            double lon = parser.doubleValue();
            if (parser.nextToken() == Token.VALUE_NUMBER) {
                double lat = parser.doubleValue();
                if (parser.nextToken() == Token.END_ARRAY) {
                    contexts.add(stringEncode(lon, lat, precision));
                } else {
                    throw new ElasticsearchParseException("only two values [lon, lat] expected");
                }
            } else {
                throw new ElasticsearchParseException("latitude must be a numeric value");
            }
        } else {
            while (token != Token.END_ARRAY) {
                GeoPoint point = GeoUtils.parseGeoPoint(parser);
                contexts.add(stringEncode(point.getLon(), point.getLat(), precision));
                token = parser.nextToken();
            }
        }
    } else if (token == Token.VALUE_STRING) {
        final String geoHash = parser.text();
        final CharSequence truncatedGeoHash = geoHash.subSequence(0, Math.min(geoHash.length(), precision));
        contexts.add(truncatedGeoHash);
    } else {
        // or a single location
        GeoPoint point = GeoUtils.parseGeoPoint(parser);
        contexts.add(stringEncode(point.getLon(), point.getLat(), precision));
    }
    return contexts;
}