ElasticSearch检索--数组、坐标范围、脚本排序、聚合

Cancer9507

已于 2024-05-15 14:16:15 修改

阅读量843

点赞数

CC 4.0 BY-SA版权

分类专栏： ElasticSearch 文章标签： elasticsearch 大数据搜索引擎

于 2023-08-01 16:33:54 首次发布

本文链接：https://blog.youkuaiyun.com/Cancer9507/article/details/132045514

ElasticSearch 专栏收录该内容

1 篇文章

订阅专栏

文章介绍了如何在ElasticSearch中使用嵌套数据类型进行数组查询，包括布尔查询、地理位置范围检索（半径、坐标范围、多边形）以及脚本排序和聚合功能的应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

ElasticSearch检索

数组

查询只要满足数组中一条数据的结果

采用nested 数据类型

{
    "dynamic": "false",
    "properties": {
        "projectTypeList": {
            "properties": {
                "id": {
                    "type": "integer"
                },
                "level": {
                    "type": "byte"
                },
                "name": {
                    "type": "keyword"
                },
                "order": {
                    "type": "integer"
                },
                "parentId": {
                    "type": "integer"
                }
            }
        },
        "projectStateList": {
            "type": "nested",
            "properties": {
                "boardId": {
                    "type": "integer"
                },
                "boardName": {
                    "type": "keyword"
                },
                "ownerId": {
                    "type": "keyword"
                },
                "ebid": {
                    "type": "keyword"
                },
                "version": {
                    "type": "keyword"
                }
            }
        }
    }
}

            if (CollectionUtils.isNotEmpty(bo.getProjectStateList())) {
                BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
                for (Integer projectState : bo.getProjectStateList()) {
                    BoolQueryBuilder temp = QueryBuilders.boolQuery();
                    NestedQueryBuilder nestedQuery = QueryBuilders
                            .nestedQuery("projectStateList", temp, ScoreMode.None);
                    QueryBuilder projectStateQueryBuilder = QueryBuilders
                            .termQuery("projectStateList.boardId", projectState);
                    temp.must(projectStateQueryBuilder);
                    if (StringUtils.isNotBlank(bo.getOwnerId())) {
                        QueryBuilder ownerIdQueryBuilder = QueryBuilders
                                .termQuery("projectStateList.ownerId", bo.getOwnerId());
                        temp.must(ownerIdQueryBuilder);
                    }
                    if (StringUtils.isNotBlank(bo.getEbid())) {
                        QueryBuilder ebidQueryBuilder = QueryBuilders
                                .termQuery("projectStateList.ebid", bo.getEbid());
                        temp.must(ebidQueryBuilder);
                    }
                    queryBuilder.should(nestedQuery);
                }
                boolQueryBuilder.must(queryBuilder);
            } else {
                BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
                BoolQueryBuilder temp = QueryBuilders.boolQuery();
                NestedQueryBuilder nestedQuery = QueryBuilders
                        .nestedQuery("projectStateList", temp, ScoreMode.None);
                if (StringUtils.isNotBlank(bo.getOwnerId())) {
                    QueryBuilder ownerIdQueryBuilder = QueryBuilders
                            .termQuery("projectStateList.ownerId", bo.getOwnerId());
                    temp.must(ownerIdQueryBuilder);
                }
                if (StringUtils.isNotBlank(bo.getEbid())) {
                    QueryBuilder ebidQueryBuilder = QueryBuilders
                            .termQuery("projectStateList.ebid", bo.getEbid());
                    temp.must(ebidQueryBuilder);
                }
                queryBuilder.should(nestedQuery);
                boolQueryBuilder.must(queryBuilder);
            }

坐标，经纬度

范围检索：1、半径检索；2、坐标范围检索；3、四至
location : lat + “,” + lng

{
    "dynamic": "false",
    "properties": {
        "lat": {
            "type": "float"
        },
        "lng": {
            "type": "float"
        },
        "location": {
            "type": "geo_point"
        }
    }
}

        // 左上右下坐标
        if (StringUtils.isNoneBlank(bo.getMaxLat(), bo.getMaxLng(), bo.getMinLat(),
                bo.getMinLng())) {
            GeoBoundingBoxQueryBuilder locationBoxQueryBuilder = QueryBuilders
                    .geoBoundingBoxQuery("location")
                    .setCornersOGC(new GeoPoint(bo.getMinLat() + "," + bo.getMinLng()),
                            new GeoPoint(bo.getMaxLat() + "," + bo.getMaxLng()));
            boolQueryBuilder.filter(locationBoxQueryBuilder);
        }

        // 半径
        if (StringUtils.isNoneBlank(bo.getCenterX(), bo.getCenterY(), bo.getTargetDistance())) {
            GeoDistanceQueryBuilder locationDistanceQueryBuilder = QueryBuilders
                    .geoDistanceQuery("location")
                    .point(new GeoPoint(bo.getCenterY() + "," + bo.getCenterX()))
                    .distance(bo.getTargetDistance(), DistanceUnit.METERS);
            boolQueryBuilder.filter(locationDistanceQueryBuilder);
        }

        // 多边形
        if (StringUtils.isNotBlank(bo.getFScope())) {
            List<GeoPoint> points = Arrays.asList(StringUtils.split(bo.getFScope(), "|")).stream()
                    .map(p -> new GeoPoint(StringUtils.substringAfter(p, ",") + ","
                            + StringUtils.substringBefore(p, ",")))
                    .collect(Collectors.toList());

            GeoPolygonQueryBuilder locationPolygonQueryBuilder = QueryBuilders
                    .geoPolygonQuery("location", points);
            boolQueryBuilder.filter(locationPolygonQueryBuilder);
        }

ScriptSort 脚本排序

		 String content="if (doc['cityId'].value == "+"'"+bo.getCityIdOrder()+"') {return 0; } else { return 1; }";
            ScriptSortBuilder scriptSortBuilder = new ScriptSortBuilder(
                    new Script(
                            ScriptType.INLINE, // 脚本类型
                            Script.DEFAULT_SCRIPT_LANG, // 脚本语言
                            content, // 脚本内容
                            Collections.emptyMap() // 这里没有用到脚本参数，所以传递一个空map
                    ),
                    ScriptSortBuilder.ScriptSortType.NUMBER // 脚本返回的类型是数值
            ).order(SortOrder.ASC);
            sourceBuilder.sort(scriptSortBuilder);

Aggregation 聚合

            // nest 数组字段聚合
            sourceBuilder.aggregation(
                    AggregationBuilders.nested("boardCount", "boradInfoDocList")
                            .subAggregation(AggregationBuilders.terms("by_ebid").size(500)
                                    .field("boradInfoDocList.ebid")
                                    .subAggregation(AggregationBuilders.terms("by_boardId")
                                            .size(500).field("boradInfoDocList.boardId")
                                            .subAggregation(AggregationBuilders
                                                    .topHits("comareaName").size(1)
                                                    .fetchSource("comareaName", null)))));

            //普通字段聚合
            sourceBuilder.aggregation(AggregationBuilders.terms("districtId")
                        .field("districtId").size(500).subAggregation(AggregationBuilders
                            .topHits("districtName").size(1).fetchSource("districtName", null)));
            
            // 字段求平均
            sourceBuilder.aggregation(AggregationBuilders.avg("avgRent").field("avgRent"));