Elasticsearch实战 按时间段和动态字段查询更新

最新推荐文章于 2025-02-13 16:05:20 发布
最新推荐文章于 2025-02-13 16:05:20 发布
阅读量972 收藏
点赞数
分类专栏： Elasticsearch 文章标签： 开发语言 elasticsearch java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fajingfajing/article/details/129122912
版权

整体查询条件

{
    "query": {
        "bool": {
            "must": [
                {
                    "range": {
                        "attack_time": {
                            "from": "2023-02-07 16:00:00",
                            "to": "2023-02-07 16:00:03",
                            "include_lower": true,
                            "include_upper": true,
                            "boost": 1
                        }
                    }
                },
                {
                    "bool": {
                        "must": [
                            {
                                "bool": {
                                    "should": [
                                        {
                                            "bool": {
                                                "must": [
                                                    {
                                                        "bool": {
                                                            "should": [
                                                                {
                                                                    "wildcard": {
                                                                        "alarm_level": {
                                                                            "wildcard": "*高*",
                                                                            "boost": 1
                                                                        }
                                                                    }
                                                                },
                                                                {
                                                                    "wildcard": {
                                                                        "alarm_level": {
                                                                            "wildcard": "*低*",
                                                                            "boost": 1
                                                                        }
                                                                    }
                                                                }
                                                            ],
                                                            "adjust_pure_negative": true,
                                                            "boost": 1
                                                        }
                                                    },
                                                    {
                                                        "terms": {
                                                            "log_format_type": [
                                                                "3"
                                                            ],
                                                            "boost": 1
                                                        }
                                                    }
                                                ],
                                                "adjust_pure_negative": true,
                                                "boost": 1
                                            }
                                        },
                                        {
                                            "bool": {
                                                "must": [
                                                    {
                                                        "range": {
                                                            "alarm_level_id": {
                                                                "from": "2",
                                                                "to": null,
                                                                "include_lower": false,
                                                                "include_upper": true,
                                                                "boost": 1
                                                            }
                                                        }
                                                    }
                                                ],
                                                "adjust_pure_negative": true,
                                                "boost": 1
                                            }
                                        }
                                    ],
                                    "adjust_pure_negative": true,
                                    "boost": 1
                                }
                            },
                            {
                                "terms": {
                                    "alarm_level_id": [
                                        3
                                    ],
                                    "boost": 1
                                }
                            },
                            {
                                "bool": {
                                    "must_not": [
                                        {
                                            "script": {
                                                "script": {
                                                    "source": "def seconds = doc['attack_time'].value.getHourOfDay()*3600+doc['attack_time'].value.getMinuteOfDay()*60+doc['attack_time'].value.getSecondOfDay(); return (doc['attack_time'].value.dayOfWeek)==params.week_day && seconds>params.begin_seconds && seconds<=params.end_seconds",
                                                    "lang": "painless",
                                                    "params": {
                                                        "end_seconds": 17999,
                                                        "week_day": 2,
                                                        "begin_seconds": 0
                                                    }
                                                },
                                                "boost": 1
                                            }
                                        }
                                    ],
                                    "adjust_pure_negative": true,
                                    "boost": 1
                                }
                            }
                        ],
                        "adjust_pure_negative": true,
                        "boost": 1
                    }
                }
            ],
            "adjust_pure_negative": true,
            "boost": 1
        }
    }
}

核心功能Java代码

时间范围

BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("attack_time");
rangeQueryBuilder.from(startTime);
rangeQueryBuilder.to(endTime);
boolQueryBuilder.must(rangeQueryBuilder);

字段拼装过滤

        BoolQueryBuilder boolQueryBuilderOr = new BoolQueryBuilder();
        BoolQueryBuilder boolQueryBuilderAnd = new BoolQueryBuilder();
        JSONArray fields = configItem.getJSONArray("fields");
        for (int i = 0; i < fields.size(); i++) {
            JSONObject jsonField = fields.getJSONObject(i);
            AlarmRelationEnum relation = AlarmRelationEnum.getValue(jsonField.getInt("relation"));
            String field = jsonField.getStr("field");
            String keyword = jsonField.getStr("keyword");
            switch (relation) {
                case INCLUDE:
                    BoolQueryBuilder boolQueryBuilderInclude = new BoolQueryBuilder();
                    for (String s : keyword.split(",")) {
                        boolQueryBuilderInclude.should(QueryBuilders.wildcardQuery(field, "*" + s + "*"));
                    }
                    boolQueryBuilderAnd.must(boolQueryBuilderInclude);
                    break;
                case EQUAL:
                    boolQueryBuilderAnd.must(QueryBuilders.termsQuery(field, keyword.split(",")));
                    break;
                case NOT_EQUAL:
                    boolQueryBuilderAnd.mustNot(QueryBuilders.termQuery(field, keyword.split(",")));
                    break;
                case GREATER:
                    boolQueryBuilderAnd.must(QueryBuilders.rangeQuery(field).gt(keyword));
                    break;
                case GREATER_EQUAL:
                    boolQueryBuilderAnd.must(QueryBuilders.rangeQuery(field).gte(keyword));
                    break;
                case LESSER:
                    boolQueryBuilderAnd.must(QueryBuilders.rangeQuery(field).lt(keyword));
                    break;
                case LESSER_EQUAL:
                    boolQueryBuilderAnd.must(QueryBuilders.rangeQuery(field).lte(keyword));
                    break;
                default:
                    break;
            }
            if (i == fields.size() - 1) {
                boolQueryBuilderOr.should(boolQueryBuilderAnd);
            } else {
                if (jsonField.getStr("logic").equals("OR")) {
                    boolQueryBuilderOr.should(boolQueryBuilderAnd);
                    boolQueryBuilderAnd = new BoolQueryBuilder();
                }
            }
        }

过滤时间段

BoolQueryBuilder boolQueryValidTime = QueryBuilders.boolQuery();
            String code = "def seconds = doc['attack_time'].value.getHourOfDay()*3600" +
                    "+doc['attack_time'].value.getMinuteOfDay()*60" +
                    "+doc['attack_time'].value.getSecondOfDay(); " +
                    "return (doc['attack_time'].value.dayOfWeek)==params.week_day " +
                    "&& seconds>params.begin_seconds && seconds<=params.end_seconds";

            JSONArray weekTimes = configItem.getJSONArray("weekTimes");
            for (int j = 0; j < weekTimes.size(); j++) {
                JSONObject jsonObject = weekTimes.getJSONObject(j);

                String[] beginTimeSplit = jsonObject.getStr("beginTime").split(":");
                Integer beginSeconds = Integer.parseInt(beginTimeSplit[0]) * 3600
                        + Integer.parseInt(beginTimeSplit[1]) * 60 + Integer.parseInt(beginTimeSplit[2]);
                String[] endTimeSplit = jsonObject.getStr("endTime").split(":");
                Integer endSeconds = Integer.parseInt(endTimeSplit[0]) * 3600
                        + Integer.parseInt(endTimeSplit[1]) * 60 + Integer.parseInt(endTimeSplit[2]);

                Map<String, Object> params = new HashMap<>(4);
                params.put("begin_seconds", beginSeconds);
                params.put("end_seconds", endSeconds);
                params.put("week_day", jsonObject.getInt("weekDay"));

                Script script = new Script(Script.DEFAULT_SCRIPT_TYPE,
                        Script.DEFAULT_SCRIPT_LANG, code, params);
                boolQueryValidTime.mustNot(QueryBuilders.scriptQuery(script));
            }

            configQueryBuilder.must(boolQueryValidTime);

数据更新

                SearchHit[] hits = search.getHits().getHits();
                if (hits != null && hits.length > 0) {
                    for (SearchHit searchHit : hits) {
                        if (alarmConfigHelper.matchParams(searchHit)) { //告警频率
                            //标志告警
                            UpdateByQueryRequest updateByQueryRequest = new UpdateByQueryRequest(searchHit.getIndex());
                            updateByQueryRequest.setConflicts("proceed");
                            updateByQueryRequest.setRefresh(true);
                            updateByQueryRequest.setQuery(QueryBuilders.idsQuery().addIds(searchHit.getId()));
                            updateByQueryRequest.setScript(new Script(
                                    "ctx._source['" + FILED_PROJECT_ID + "']=" + alarmProject.getId()
                                            + ";ctx._source['" + FILED_PROJECT_THREAT_LEVEL + "']="
                                            + alarmProject.getThreatLevel()));

                            BulkByScrollResponse bulkByScrollResponse = getRestHighLevelClient()
                            .updateByQuery(updateByQueryRequest, RequestOptions.DEFAULT);
                            List<ScrollableHitSource.SearchFailure> searchFailures =
                                    bulkByScrollResponse.getSearchFailures();
                            if(searchFailures.size() >0){
                                throw new RuntimeException(searchFailures.get(0).toString());
                            }
                        }
                    }
                }
【实战 ES】实战 Elasticsearch：快速上手与深度实践-2.3.1 避免频繁更新（Update by Query的代价）
kngines
03-04 852
实战 Elasticsearch：快速上手与深度实践-2.3.1 避免频繁更新（Update by Query的代价）
【实战ES】实战 Elasticsearch：快速上手与深度实践-3.3.3缓存机制（Query Cache、Request Cache）
最新发布
kngines
03-07 2121
【实战ES】实战 Elasticsearch：快速上手与深度实践-3.3.3缓存机制（Query Cache、Request Cache）
Elasticsearch(2) boost的使用
qq_29312279的博客
03-09 1300
在Elasticsearch中，boost是一个权重值，它可以应用于搜索查询的各个部分，以影响相关性评分。当对某个字段进行搜索时，如果给该字段分配更高的boost值，那么匹配到该字段的文档在搜索结果中的排名将会更高，也就是说，它的相关性得分会相对增加。
Elasticsearch查询文档和更新文档
weixin_54982854的博客
05-01 251
Elasticsearch查询文档和更新文档(来源尚硅谷视频教程)
elasticsearch查询字段更新
ZHANGHUI3239619的专栏
04-01 269
POST congestion-2021-03/_update_by_query { "query": { "range": { "state": { "lte": 2 } } },"script" : { "source": "ctx._source.state= params.state", "lang": "painless", "params" : { "st...
elasticsearch通过查询更新_update_by_query
桔里桔气
04-19 1815
_update_by_query 顾名思义，通过查询更新，既先query出符合条件的内容再进行update操作，新增字段，修改字段值都可以满足 POST http://10.3.39.3:9200/my-index-0001/_update_by_query { "script": { "inline": "ctx._source.totalAmount = 123123" }, "query": { "bool": { "must": [ {
ElasticSearch的Script逻辑查询
ywb201314的专栏
07-11 1461
———————————————— 版权声明：本文为CSDN博主「CTO修炼手册」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/Prepared/article/details/102893852在使用 ES 进行统计的时候，经常会用到查询某个小时的统计数据，比如统计每个小时的数据；比如计算早晚高峰的数据。这些场景都可以使用 script 进行查询、统计。ES 语句 这个属性能取哪些值，取
Elasticsearch技术解析与实战
modouwu的博客
09-23 1595
启动发现当Elasticsearch节点启动时，它会尝试连接到配置中的种子节点列表中的每个节点。如果节点是首次启动或需要加入一个新的集群，它会通过种子节点列表来发现集群中的其他节点。Ping操作节点之间通过Ping操作来确认彼此的存在和状态。Elasticsearch会定期向集群中的其他节点发送Ping请求，以检测节点是否仍然在线。构建集群视图通过Ping操作，每个节点都能构建出集群的完整视图，包括集群中所有节点的信息。
ElasticSearch入门实战介绍
weixin_51049616的博客
07-12 2509
官网地址下载地址ElasticSearch（简称ES）是一个开源的分布式搜索和数据分析引擎，是用Java开发并且是当前最流行的开源的企业级搜索引擎，能够达到近实时搜索，它专门设计用于处理大规模的文本数据和实现高性能的全文检索。以下是一些 Elasticsearch 的特点和优势：分布式架构：Elasticsearch 是一个分布式系统，可以轻松地 水平扩展处理大规模的数据集和高并发的查询请求。全文检索功能：Elasticsearch 提供了强大的全文检索功能，
Elasticsearch实战应用
完颜振江
02-13 586
"query": {"term": {- 减少跨分片查询，提升吞吐量30%+- 需配合`index.routing_partition_size`平衡数据分布。
ES 大数据量按照日期分索引存储和查询
苍煜
04-09 2825
ES 通常被用来存放各种日志数据或其他大批量数据，然后做统计。对于请求量大的系统来说，日志或其他业务数据无比庞大，需要按日期来划分索引，便于做冷热数据的迁移管理。大批量的业务数据也要根据日期来区分，提高检索效率。假设，日志数据按每日来分索引存储，索引名字格式：system_log_20240408，system_log_20240409 等来切分。查询时，使用别名system_log 或者 用多个索引联合查询。
elasticSearch QueryBuilders查询条件构建
羊驼哥哥的博客
09-06 2600
elasticSearch QueryBuilders查询条件构建。
elasticsearch 总结
weixin_35226066的博客
06-23 1417
Term level queries 术语查询 虽然全文查询将在执行之前分析查询字符串，但是项级别查询对存储在反向索引中的确切项进行操作。 这些查询通常用于结构化数据，如数字、日期和枚举，而不是全文字段。或者，在分析过程之前，它允许你绘制低级查询。 这样的查询有以下这些： Term Query（项查询） 查询包含在指定字段中指定的确切值的文档。 查看Term Query QueryBuilder qb = termQuery( "name", //field "kimc
ES构建queryBuilder条件查询
热门推荐
mingyonghu的博客
11-17 2万+
文章目录1. maven配置2. 等值查询3. 范围查询4. 模糊查询5. 多条件查询6. 集合查询7. 使用should查询8. should和must配合查询9. 有值查询10. 分页查询 开发过程中多使用ES的javaAPI，通过javaAPI来对ES的索引进行操作，对ES的操作一般都是通过构建QueryBuilder对象来进行操作。下面介绍几种QueryBuilder的构建。 1. maven配置 maven依赖 <dependency> <groupId>org.
ElasticSearch Java 筛选时间区间、must与should组合、分页查询、根据字段排序
imHanweihu的博客
03-12 1834
es查询：会员ID不为空且资源类型为api或page，分页，根据访问时间倒序排序 package com.jiuku.modules.es.service.impl; import com.jiuku.modules.es.entity.AdminLogEntity; import org.elasticsearch.index.query.BoolQueryBuilder; import org.elasticsearch.index.query.QueryBuilders; import or.
Elasticsearch模糊查询、多字段in查询、时间范围查询，DSL和java API两种方式
Gzzz的博客
03-23 8073
项目场景： Elasticsearch模糊查询某字段，通过DSL和java API两种方式 解决方案： wildcard 通配符检索 使用wildcard相当于SQL的like，前后都可拼接*，匹配0到多个任意字符 { "query": { "wildcard": { "name.keyword": "*文件*" } } } BoolQueryBuilder queryBuilder = QueryBuilde.
ElasticSearch 简单的查询。查询存在该字段的资源,更新,统计
伟大是熬出来的
11-05 552
备注：存在chainCode 的字段并且不存在isDelete的资源。
ES QueryBuilder学习
qq_42383787的博客
04-24 1万+
public void test() throws IOException { # 创建一个Search 对象 SearchRequest searchRequest = new SearchRequest(); # 创建一个Builder 对象 对条件进行封装 SearchSourceBuilder searchS...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值