Examples with GeoPointFieldType org.opensearch.index.mapper.GeoPointFieldMapper.GeoPointFieldType used on opensource projects

Example 1 with GeoPointFieldType

use of org.opensearch.index.mapper.GeoPointFieldMapper.GeoPointFieldType in project OpenSearch by opensearch-project.

the class GeoDistanceQueryBuilder method doToQuery.

@Override
protected Query doToQuery(QueryShardContext shardContext) throws IOException {
    MappedFieldType fieldType = shardContext.fieldMapper(fieldName);
    if (fieldType == null) {
        if (ignoreUnmapped) {
            return new MatchNoDocsQuery();
        } else {
            throw new QueryShardException(shardContext, "failed to find geo_point field [" + fieldName + "]");
        }
    }
    if (!(fieldType instanceof GeoPointFieldType)) {
        throw new QueryShardException(shardContext, "field [" + fieldName + "] is not a geo_point field");
    }
    QueryValidationException exception = checkLatLon();
    if (exception != null) {
        throw new QueryShardException(shardContext, "couldn't validate latitude/ longitude values", exception);
    }
    if (GeoValidationMethod.isCoerce(validationMethod)) {
        GeoUtils.normalizePoint(center, true, true);
    }
    Query query = LatLonPoint.newDistanceQuery(fieldType.name(), center.lat(), center.lon(), this.distance);
    if (fieldType.hasDocValues()) {
        Query dvQuery = LatLonDocValuesField.newSlowDistanceQuery(fieldType.name(), center.lat(), center.lon(), this.distance);
        query = new IndexOrDocValuesQuery(query, dvQuery);
    }
    return query;
}

Example 2 with GeoPointFieldType

use of org.opensearch.index.mapper.GeoPointFieldMapper.GeoPointFieldType in project OpenSearch by opensearch-project.

the class GeoPolygonQueryBuilder method doToQuery.

@Override
protected Query doToQuery(QueryShardContext context) throws IOException {
    MappedFieldType fieldType = context.fieldMapper(fieldName);
    if (fieldType == null) {
        if (ignoreUnmapped) {
            return new MatchNoDocsQuery();
        } else {
            throw new QueryShardException(context, "failed to find geo_point field [" + fieldName + "]");
        }
    }
    if (!(fieldType instanceof GeoPointFieldType)) {
        throw new QueryShardException(context, "field [" + fieldName + "] is not a geo_point field");
    }
    List<GeoPoint> shell = new ArrayList<>(this.shell.size());
    for (GeoPoint geoPoint : this.shell) {
        shell.add(new GeoPoint(geoPoint));
    }
    final int shellSize = shell.size();
    // percolation queries we only ignore_malformed on 2.x created indexes
    if (!GeoValidationMethod.isIgnoreMalformed(validationMethod)) {
        for (GeoPoint point : shell) {
            if (!GeoUtils.isValidLatitude(point.lat())) {
                throw new QueryShardException(context, "illegal latitude value [{}] for [{}]", point.lat(), GeoPolygonQueryBuilder.NAME);
            }
            if (!GeoUtils.isValidLongitude(point.lon())) {
                throw new QueryShardException(context, "illegal longitude value [{}] for [{}]", point.lon(), GeoPolygonQueryBuilder.NAME);
            }
        }
    }
    if (GeoValidationMethod.isCoerce(validationMethod)) {
        for (GeoPoint point : shell) {
            GeoUtils.normalizePoint(point, true, true);
        }
    }
    double[] lats = new double[shellSize];
    double[] lons = new double[shellSize];
    GeoPoint p;
    for (int i = 0; i < shellSize; ++i) {
        p = shell.get(i);
        lats[i] = p.lat();
        lons[i] = p.lon();
    }
    Polygon polygon = new Polygon(lats, lons);
    Query query = LatLonPoint.newPolygonQuery(fieldType.name(), polygon);
    if (fieldType.hasDocValues()) {
        Query dvQuery = LatLonDocValuesField.newSlowPolygonQuery(fieldType.name(), polygon);
        query = new IndexOrDocValuesQuery(query, dvQuery);
    }
    return query;
}

Example 3 with GeoPointFieldType

use of org.opensearch.index.mapper.GeoPointFieldMapper.GeoPointFieldType in project OpenSearch by opensearch-project.

the class DecayFunctionBuilder method parseVariable.

private AbstractDistanceScoreFunction parseVariable(String fieldName, XContentParser parser, QueryShardContext context, MultiValueMode mode) throws IOException {
    // the field must exist, else we cannot read the value for the doc later
    MappedFieldType fieldType = context.fieldMapper(fieldName);
    if (fieldType == null) {
        throw new ParsingException(parser.getTokenLocation(), "unknown field [{}]", fieldName);
    }
    // dates and time and geo need special handling
    parser.nextToken();
    // TODO these ain't gonna work with runtime fields
    if (fieldType instanceof DateFieldMapper.DateFieldType) {
        return parseDateVariable(parser, context, fieldType, mode);
    } else if (fieldType instanceof GeoPointFieldType) {
        return parseGeoVariable(parser, context, fieldType, mode);
    } else if (fieldType instanceof NumberFieldMapper.NumberFieldType) {
        return parseNumberVariable(parser, context, fieldType, mode);
    } else {
        throw new ParsingException(parser.getTokenLocation(), "field [{}] is of type [{}], but only numeric types are supported.", fieldName, fieldType);
    }
}

Example 4 with GeoPointFieldType

use of org.opensearch.index.mapper.GeoPointFieldMapper.GeoPointFieldType in project OpenSearch by opensearch-project.

the class ExpressionScriptEngine method getDocValueSource.

private static DoubleValuesSource getDocValueSource(String variable, SearchLookup lookup) throws ParseException {
    VariableContext[] parts = VariableContext.parse(variable);
    if (parts[0].text.equals("doc") == false) {
        throw new ParseException("Unknown variable [" + parts[0].text + "]", 0);
    }
    if (parts.length < 2 || parts[1].type != VariableContext.Type.STR_INDEX) {
        throw new ParseException("Variable 'doc' must be used with a specific field like: doc['myfield']", 3);
    }
    // .value is the default for doc['field'], its optional.
    String variablename = "value";
    String methodname = null;
    if (parts.length == 3) {
        if (parts[2].type == VariableContext.Type.METHOD) {
            methodname = parts[2].text;
        } else if (parts[2].type == VariableContext.Type.MEMBER) {
            variablename = parts[2].text;
        } else {
            throw new IllegalArgumentException("Only member variables or member methods may be accessed on a field when not accessing the field directly");
        }
    }
    // true if the variable is of type doc['field'].date.xxx
    boolean dateAccessor = false;
    if (parts.length > 3) {
        // access to the .date "object" within the field
        if (parts.length == 4 && ("date".equals(parts[2].text) || "getDate".equals(parts[2].text))) {
            if (parts[3].type == VariableContext.Type.METHOD) {
                methodname = parts[3].text;
                dateAccessor = true;
            } else if (parts[3].type == VariableContext.Type.MEMBER) {
                variablename = parts[3].text;
                dateAccessor = true;
            }
        }
        if (!dateAccessor) {
            throw new IllegalArgumentException("Variable [" + variable + "] does not follow an allowed format of either doc['field'] or doc['field'].method()");
        }
    }
    String fieldname = parts[1].text;
    MappedFieldType fieldType = lookup.doc().mapperService().fieldType(fieldname);
    if (fieldType == null) {
        throw new ParseException("Field [" + fieldname + "] does not exist in mappings", 5);
    }
    IndexFieldData<?> fieldData = lookup.doc().getForField(fieldType);
    final DoubleValuesSource valueSource;
    if (fieldType instanceof GeoPointFieldType) {
        // geo
        if (methodname == null) {
            valueSource = GeoField.getVariable(fieldData, fieldname, variablename);
        } else {
            valueSource = GeoField.getMethod(fieldData, fieldname, methodname);
        }
    } else if (fieldType instanceof DateFieldMapper.DateFieldType) {
        if (dateAccessor) {
            // date object
            if (methodname == null) {
                valueSource = DateObject.getVariable(fieldData, fieldname, variablename);
            } else {
                valueSource = DateObject.getMethod(fieldData, fieldname, methodname);
            }
        } else {
            // date field itself
            if (methodname == null) {
                valueSource = DateField.getVariable(fieldData, fieldname, variablename);
            } else {
                valueSource = DateField.getMethod(fieldData, fieldname, methodname);
            }
        }
    } else if (fieldData instanceof IndexNumericFieldData) {
        // number
        if (methodname == null) {
            valueSource = NumericField.getVariable(fieldData, fieldname, variablename);
        } else {
            valueSource = NumericField.getMethod(fieldData, fieldname, methodname);
        }
    } else {
        throw new ParseException("Field [" + fieldname + "] must be numeric, date, or geopoint", 5);
    }
    return valueSource;
}

Example 5 with GeoPointFieldType

use of org.opensearch.index.mapper.GeoPointFieldMapper.GeoPointFieldType in project OpenSearch by opensearch-project.

the class GeoBoundingBoxQueryBuilder method doToQuery.

@Override
public Query doToQuery(QueryShardContext context) {
    MappedFieldType fieldType = context.fieldMapper(fieldName);
    if (fieldType == null) {
        if (ignoreUnmapped) {
            return new MatchNoDocsQuery();
        } else {
            throw new QueryShardException(context, "failed to find geo_point field [" + fieldName + "]");
        }
    }
    if (!(fieldType instanceof GeoPointFieldType)) {
        throw new QueryShardException(context, "field [" + fieldName + "] is not a geo_point field");
    }
    QueryValidationException exception = checkLatLon();
    if (exception != null) {
        throw new QueryShardException(context, "couldn't validate latitude/ longitude values", exception);
    }
    GeoPoint luceneTopLeft = new GeoPoint(geoBoundingBox.topLeft());
    GeoPoint luceneBottomRight = new GeoPoint(geoBoundingBox.bottomRight());
    if (GeoValidationMethod.isCoerce(validationMethod)) {
        // Special case: if the difference between the left and right is 360 and the right is greater than the left, we are asking for
        // the complete longitude range so need to set longitude to the complete longitude range
        double right = luceneBottomRight.getLon();
        double left = luceneTopLeft.getLon();
        boolean completeLonRange = ((right - left) % 360 == 0 && right > left);
        GeoUtils.normalizePoint(luceneTopLeft, true, !completeLonRange);
        GeoUtils.normalizePoint(luceneBottomRight, true, !completeLonRange);
        if (completeLonRange) {
            luceneTopLeft.resetLon(-180);
            luceneBottomRight.resetLon(180);
        }
    }
    Query query = LatLonPoint.newBoxQuery(fieldType.name(), luceneBottomRight.getLat(), luceneTopLeft.getLat(), luceneTopLeft.getLon(), luceneBottomRight.getLon());
    if (fieldType.hasDocValues()) {
        Query dvQuery = LatLonDocValuesField.newSlowBoxQuery(fieldType.name(), luceneBottomRight.getLat(), luceneTopLeft.getLat(), luceneTopLeft.getLon(), luceneBottomRight.getLon());
        query = new IndexOrDocValuesQuery(query, dvQuery);
    }
    return query;
}