import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
/**
 * Read from a stream.
 */
public GeoShapeQueryBuilder(StreamInput in) throws IOException {
    super(in);
    fieldName = in.readString();
    if (in.readBoolean()) {
        shape = in.readNamedWriteable(ShapeBuilder.class);
        indexedShapeId = null;
        indexedShapeType = null;
    } else {
        shape = null;
        indexedShapeId = in.readOptionalString();
        indexedShapeType = in.readOptionalString();
        indexedShapeIndex = in.readOptionalString();
        indexedShapePath = in.readOptionalString();
    }
    relation = ShapeRelation.readFromStream(in);
    strategy = in.readOptionalWriteable(SpatialStrategy::readFromStream);
    ignoreUnmapped = in.readBoolean();
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
/**
 * Read from a stream.
 */
public RangeQueryBuilder(StreamInput in) throws IOException {
    super(in);
    fieldName = in.readString();
    from = in.readGenericValue();
    to = in.readGenericValue();
    includeLower = in.readBoolean();
    includeUpper = in.readBoolean();
    timeZone = in.readOptionalTimeZone();
    String formatString = in.readOptionalString();
    if (formatString != null) {
        format = Joda.forPattern(formatString);
    }
    if (in.getVersion().onOrAfter(Version.V_5_2_0_UNRELEASED)) {
        String relationString = in.readOptionalString();
        if (relationString != null) {
            relation = ShapeRelation.getRelationByName(relationString);
        }
    }
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
@Override
public Query rangeQuery(String field, Object lowerTerm, Object upperTerm, boolean includeLower, boolean includeUpper,
                        ShapeRelation relation, @Nullable DateTimeZone timeZone, @Nullable DateMathParser parser,
                        QueryShardContext context) {
    DateTimeZone zone = (timeZone == null) ? DateTimeZone.UTC : timeZone;
    DateMathParser dateMathParser = (parser == null) ?
        new DateMathParser(DateFieldMapper.DEFAULT_DATE_TIME_FORMATTER) : parser;
    Long low = lowerTerm == null ? Long.MIN_VALUE :
        dateMathParser.parse(lowerTerm instanceof BytesRef ? ((BytesRef) lowerTerm).utf8ToString() : lowerTerm.toString(),
            context::nowInMillis, false, zone);
    Long high = upperTerm == null ? Long.MAX_VALUE :
        dateMathParser.parse(upperTerm instanceof BytesRef ? ((BytesRef) upperTerm).utf8ToString() : upperTerm.toString(),
            context::nowInMillis, false, zone);

    return super.rangeQuery(field, low, high, includeLower, includeUpper, relation, zone, dateMathParser, context);
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
public void testShapeFilterWithRandomGeoCollection() throws Exception {
    // Create a random geometry collection.
    GeometryCollectionBuilder gcb = RandomShapeGenerator.createGeometryCollection(random());

    logger.info("Created Random GeometryCollection containing {} shapes", gcb.numShapes());

    client().admin().indices().prepareCreate("test").addMapping("type", "location", "type=geo_shape,tree=quadtree")
            .execute().actionGet();

    XContentBuilder docSource = gcb.toXContent(jsonBuilder().startObject().field("location"), null).endObject();
    client().prepareIndex("test", "type", "1").setSource(docSource).setRefreshPolicy(IMMEDIATE).get();

    ShapeBuilder filterShape = (gcb.getShapeAt(randomIntBetween(0, gcb.numShapes() - 1)));

    GeoShapeQueryBuilder filter = QueryBuilders.geoShapeQuery("location", filterShape);
    filter.relation(ShapeRelation.INTERSECTS);
    SearchResponse result = client().prepareSearch("test").setTypes("type").setQuery(QueryBuilders.matchAllQuery())
            .setPostFilter(filter).get();
    assertSearchResponse(result);
    assertHitCount(result, 1);
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
public void testContainsShapeQuery() throws Exception {
    // Create a random geometry collection.
    Rectangle mbr = xRandomRectangle(random(), xRandomPoint(random()), true);
    GeometryCollectionBuilder gcb = createGeometryCollectionWithin(random(), mbr);

    client().admin().indices().prepareCreate("test").addMapping("type", "location", "type=geo_shape,tree=quadtree" )
            .execute().actionGet();

    XContentBuilder docSource = gcb.toXContent(jsonBuilder().startObject().field("location"), null).endObject();
    client().prepareIndex("test", "type", "1").setSource(docSource).setRefreshPolicy(IMMEDIATE).get();

    // index the mbr of the collection
    EnvelopeBuilder env = new EnvelopeBuilder(new Coordinate(mbr.getMinX(), mbr.getMaxY()), new Coordinate(mbr.getMaxX(), mbr.getMinY()));
    docSource = env.toXContent(jsonBuilder().startObject().field("location"), null).endObject();
    client().prepareIndex("test", "type", "2").setSource(docSource).setRefreshPolicy(IMMEDIATE).get();

    ShapeBuilder filterShape = (gcb.getShapeAt(randomIntBetween(0, gcb.numShapes() - 1)));
    GeoShapeQueryBuilder filter = QueryBuilders.geoShapeQuery("location", filterShape)
            .relation(ShapeRelation.CONTAINS);
    SearchResponse response = client().prepareSearch("test").setTypes("type").setQuery(QueryBuilders.matchAllQuery())
            .setPostFilter(filter).get();
    assertSearchResponse(response);

    assertThat(response.getHits().getTotalHits(), greaterThan(0L));
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
public void testGeoShape() throws IOException {
    GeoShapeQueryBuilder qb = geoShapeQuery(
            "pin.location",
            ShapeBuilders.newMultiPoint(
                    new CoordinatesBuilder()
                .coordinate(0, 0)
                .coordinate(0, 10)
                .coordinate(10, 10)
                .coordinate(10, 0)
                .coordinate(0, 0)
                .build()));
    qb.relation(ShapeRelation.WITHIN);

    qb = geoShapeQuery(
                "pin.location",
                "DEU",
                "countries");
    qb.relation(ShapeRelation.WITHIN)
        .indexedShapeIndex("shapes")
        .indexedShapePath("location");
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
public void testRangeQuery() throws Exception {
    Settings indexSettings = Settings.builder()
        .put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT).build();
    IndexSettings idxSettings = IndexSettingsModule.newIndexSettings(randomAsciiOfLengthBetween(1, 10), indexSettings);
    QueryShardContext context = new QueryShardContext(0, idxSettings, null, null, null, null, null, xContentRegistry(),
            null, null, () -> nowInMillis);
    RangeFieldMapper.RangeFieldType ft = new RangeFieldMapper.RangeFieldType(type);
    ft.setName(FIELDNAME);
    ft.setIndexOptions(IndexOptions.DOCS);

    ShapeRelation relation = RandomPicks.randomFrom(random(), ShapeRelation.values());
    boolean includeLower = random().nextBoolean();
    boolean includeUpper = random().nextBoolean();
    Object from = nextFrom();
    Object to = nextTo(from);

    assertEquals(getExpectedRangeQuery(relation, from, to, includeLower, includeUpper),
        ft.rangeQuery(from, to, includeLower, includeUpper, relation, context));
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
/**
 * Create a simple heatmap over the indexed docs and verify that no cell has
 * more than that number of docs
 */
public void testSimple() throws Exception {

    EnvelopeBuilder env = new EnvelopeBuilder(new Coordinate(mbr.getMinX(), mbr.getMaxY()),
            new Coordinate(mbr.getMaxX(), mbr.getMinY()));
    GeoShapeQueryBuilder geo = QueryBuilders.geoShapeQuery("location", env).relation(ShapeRelation.WITHIN);

    SearchResponse response2 = client().prepareSearch("idx")
            .addAggregation(heatmap("heatmap1").geom(geo).field("location").gridLevel(7).maxCells(100)).execute().actionGet();

    GeoHeatmap filter2 = response2.getAggregations().get("heatmap1");
    assertThat(filter2, notNullValue());
    assertThat(filter2.getName(), equalTo("heatmap1"));

    int maxHeatmapValue = 0;
    for (int i = 0; i < filter2.getCounts().length; i++) {
        maxHeatmapValue = Math.max(maxHeatmapValue, filter2.getCounts()[i]);
    }
    assertTrue(maxHeatmapValue <= numTag1Docs);
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
public static SpatialArgs getArgs(ShapeBuilder shape, ShapeRelation relation) {
    switch (relation) {
    case DISJOINT:
        return new SpatialArgs(SpatialOperation.IsDisjointTo, shape.build());
    case INTERSECTS:
        return new SpatialArgs(SpatialOperation.Intersects, shape.build());
    case WITHIN:
        return new SpatialArgs(SpatialOperation.IsWithin, shape.build());
    case CONTAINS:
        return new SpatialArgs(SpatialOperation.Contains, shape.build());
    default:
        throw new IllegalArgumentException("invalid relation [" + relation + "]");
    }
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
public void testInvalidRelation() throws IOException {
    ShapeBuilder shape = RandomShapeGenerator.createShapeWithin(random(), null);
    GeoShapeQueryBuilder builder = new GeoShapeQueryBuilder(GEO_SHAPE_FIELD_NAME, shape);
    builder.strategy(SpatialStrategy.TERM);
    expectThrows(IllegalArgumentException.class, () -> builder.relation(randomFrom(ShapeRelation.DISJOINT, ShapeRelation.WITHIN)));
    GeoShapeQueryBuilder builder2 = new GeoShapeQueryBuilder(GEO_SHAPE_FIELD_NAME, shape);
    builder2.relation(randomFrom(ShapeRelation.DISJOINT, ShapeRelation.WITHIN));
    expectThrows(IllegalArgumentException.class, () -> builder2.strategy(SpatialStrategy.TERM));
    GeoShapeQueryBuilder builder3 = new GeoShapeQueryBuilder(GEO_SHAPE_FIELD_NAME, shape);
    builder3.strategy(SpatialStrategy.TERM);
    expectThrows(IllegalArgumentException.class, () -> builder3.relation(randomFrom(ShapeRelation.DISJOINT, ShapeRelation.WITHIN)));
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
private Query getExpectedRangeQuery(ShapeRelation relation, Object from, Object to, boolean includeLower, boolean includeUpper) {
    switch (type) {
        case DATE:
            return getDateRangeQuery(relation, (DateTime)from, (DateTime)to, includeLower, includeUpper);
        case INTEGER:
            return getIntRangeQuery(relation, (int)from, (int)to, includeLower, includeUpper);
        case LONG:
            return getLongRangeQuery(relation, (long)from, (long)to, includeLower, includeUpper);
        case DOUBLE:
            return getDoubleRangeQuery(relation, (double)from, (double)to, includeLower, includeUpper);
        default:
            return getFloatRangeQuery(relation, (float)from, (float)to, includeLower, includeUpper);
    }
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
private Query getIntRangeQuery(ShapeRelation relation, int from, int to, boolean includeLower, boolean includeUpper) {
    int[] lower = new int[] {from + (includeLower ? 0 : 1)};
    int[] upper = new int[] {to - (includeUpper ? 0 : 1)};
    if (relation == ShapeRelation.WITHIN) {
        return IntRangeField.newWithinQuery(FIELDNAME, lower, upper);
    } else if (relation == ShapeRelation.CONTAINS) {
        return IntRangeField.newContainsQuery(FIELDNAME, lower, upper);
    }
    return IntRangeField.newIntersectsQuery(FIELDNAME, lower, upper);
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
private Query getLongRangeQuery(ShapeRelation relation, long from, long to, boolean includeLower, boolean includeUpper) {
    long[] lower = new long[] {from + (includeLower ? 0 : 1)};
    long[] upper = new long[] {to - (includeUpper ? 0 : 1)};
    if (relation == ShapeRelation.WITHIN) {
        return LongRangeField.newWithinQuery(FIELDNAME, lower, upper);
    } else if (relation == ShapeRelation.CONTAINS) {
        return LongRangeField.newContainsQuery(FIELDNAME, lower, upper);
    }
    return LongRangeField.newIntersectsQuery(FIELDNAME, lower, upper);
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
private Query getFloatRangeQuery(ShapeRelation relation, float from, float to, boolean includeLower, boolean includeUpper) {
    float[] lower = new float[] {includeLower ? from : Math.nextUp(from)};
    float[] upper = new float[] {includeUpper ? to : Math.nextDown(to)};
    if (relation == ShapeRelation.WITHIN) {
        return FloatRangeField.newWithinQuery(FIELDNAME, lower, upper);
    } else if (relation == ShapeRelation.CONTAINS) {
        return FloatRangeField.newContainsQuery(FIELDNAME, lower, upper);
    }
    return FloatRangeField.newIntersectsQuery(FIELDNAME, lower, upper);
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
private Query getDoubleRangeQuery(ShapeRelation relation, double from, double to, boolean includeLower, boolean includeUpper) {
    double[] lower = new double[] {includeLower ? from : Math.nextUp(from)};
    double[] upper = new double[] {includeUpper ? to : Math.nextDown(to)};
    if (relation == ShapeRelation.WITHIN) {
        return DoubleRangeField.newWithinQuery(FIELDNAME, lower, upper);
    } else if (relation == ShapeRelation.CONTAINS) {
        return DoubleRangeField.newContainsQuery(FIELDNAME, lower, upper);
    }
    return DoubleRangeField.newIntersectsQuery(FIELDNAME, lower, upper);
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
private SpatialArgs getArgs(Shape shape, ShapeRelation relation) {
    switch (relation) {
        case INTERSECTS:
            return new SpatialArgs(SpatialOperation.Intersects, shape);
        case DISJOINT:
            return new SpatialArgs(SpatialOperation.IsDisjointTo, shape);
        case WITHIN:
            return new SpatialArgs(SpatialOperation.IsWithin, shape);
    }
    throw invalidMatchType(relation.getRelationName());
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
private GeoShapeQueryBuilder(String name, ShapeBuilder shape, String indexedShapeId, String indexedShapeType, ShapeRelation relation) {
    this.name = name;
    this.shape = shape;
    this.indexedShapeId = indexedShapeId;
    this.relation = relation;
    this.indexedShapeType = indexedShapeType;
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
public static SpatialArgs getArgs(ShapeBuilder shape, ShapeRelation relation) {
    switch(relation) {
    case DISJOINT:
        return new SpatialArgs(SpatialOperation.IsDisjointTo, shape.build());
    case INTERSECTS:
        return new SpatialArgs(SpatialOperation.Intersects, shape.build());
    case WITHIN:
        return new SpatialArgs(SpatialOperation.IsWithin, shape.build());
    case CONTAINS:
        return new SpatialArgs(SpatialOperation.Contains, shape.build());
    default:
        throw new IllegalArgumentException("");

    }
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
@org.junit.Test
public void t_queryByEsQueryDo2()throws Exception {
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    QueryBuilder qb = QueryBuilders.matchAllQuery();
    searchSourceBuilder.query(qb);
    ShapeBuilder shapeBuilder = ShapeBuilder.newPoint(new Coordinate(116.402257, 39.914548));
    QueryBuilder qb2 = QueryBuilders.geoShapeQuery("geometry", shapeBuilder, ShapeRelation.CONTAINS);

    QueryBuilder qb3 = QueryBuilders.boolQuery().must(qb).filter(qb2);
    searchSourceBuilder.query(qb3);
   iEsQueryDao.query(searchSourceBuilder,"twitter","user","user2");
    /*logger.info(JSON.toJSONString(es));
    Assert.assertNotEquals("1", es.getStatus());*/
}
 

import org.elasticsearch.common.geo.ShapeRelation; //导入依赖的package包/类
public void testSpecificShapes() throws Exception {
    createPrecalculatedIndex();
    ShapeBuilder query = ShapeBuilders.newEnvelope(new Coordinate(50, 90), new Coordinate(180, 20));
    GeoShapeQueryBuilder geo = QueryBuilders.geoShapeQuery("location", query).relation(ShapeRelation.WITHIN);
    
    String expected = "\"aggregations\":{\"heatmap1\":{\"grid_level\":4,\"rows\":7,\"columns\":6,\"min_x\":45.0,\"min_y\":11.25,"+
         "\"max_x\":180.0,\"max_y\":90.0,\"counts\":[[0,0,2,1,0,0],[0,0,1,1,0,0],[0,1,1,1,0,0],[0,0,1,1,0,0],[0,0,1,1,0,0],[],[]]}}}";

    assertHeatmapContents(geo, expected, 4, "test");
}