【ES 6.5.4 】ElasticSearch知识点
ElaticSearch
1.索引基本操作
1.1 创建一个索引
#创建一个索引
PUT /person
{
"settings": {
"number_of_shards": 5,
"number_of_replicas": 1
}
}
1.2 查看索引信息
#查看索引
GET /person
1.3 删除索引
#删除索引
DELETE /person
1.4 ES中Field可以指定的类型
#String:
text：一般用于全文检索。将当前的field进行分词
# keyword: 当前的Field不可被分词
#
#
#
#
1.5 创建索引并指定数据结构
——以创建小说为例子
PUT /book
{
"settings": {
#备份数
"number_of_replicas": 1,
#分片数
"number_of_shards": 5
},
#指定数据结构
"mappings": {
#指定类型 Type
"novel": {
# 文件存储的Field属性名
"properties": {
"name": {
"type": "text",
"analyzer": "ik_max_word",
# 指定当前的Field可以作为查询的条件
"index": true
},
"authoor": {
"type": "keyword"
},
"onsale": {
"type": "date",
"format": "yyyy-MM-dd"
}
}
}
}
}
1.6 文档的操作
- 文档在ES服务中的唯一标志，_index, _type, _id 三个内容为组合，来锁定一个文档，操作抑或是修改
1.6.1 新建文档
- 自动生成id
PUT /book/novel
{
"name": "西游记",
"authoor": "刘明",
"onsale": "2020-12-11"
}
- 手动指定ID（更推荐）
PUT /book/novel/1
{
"name": "三国演义",
"authoor": "小明",
"onsale": "2020-12-11"
}
1.6.2 修改文档
-
覆盖式修改
POST /book/novel/1 { "name": "三国演义", "authoor": "小明", "onsale": "2020-12-11" } -
doc修改方式（更推荐）
POST /book/novel/1/_update { "doc": { "name": "极品家丁" } } #先锁定文档，_update 修改需要的字段即可
1.6.3 删除文档
-
删库跑路
DELETE /book/novel/1
2. java操作ElaticSearch
2.1 Java链接ES
1、创建Maven工程
导入依赖
# 4个依赖
1、1 elasticsearch
<!-- https://mvnrepository.com/artifact/org.elasticsearch/elasticsearch -->
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>6.5.4</version>
</dependency>
1、2 elasticsearch的高级API
<!-- https://mvnrepository.com/artifact/org.elasticsearch.client/elasticsearch-rest-high-level-client -->
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>6.5.4</version>
</dependency>
1、3 junit
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
1、4 lombok
<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
<scope>provided</scope>
</dependency>
2.1.2 创建测试类，连接ES
// 先创建连接，工具类
public class ESClient {
public static RestHighLevelClient getClient(){
// 创建HttpHost对象
HttpHost httpHost = new HttpHost("127.0.0.1",9200);
// 创建RestClientBuilder
RestClientBuilder builder = RestClient.builder(httpHost);
// 创建RestHighLevelClien对象
RestHighLevelClient client = new RestHighLevelClient(builder);
return client;
}
}
2.2 java创建索引
import com.dengzhou.utils.ESClient;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.json.JsonXContent;
import org.junit.jupiter.api.Test;
import java.io.IOException;
public class Create_ES_Index {
String index = "person";
String type = "man";
@Test
public void createIndex() throws IOException {
//1、 准备关于索引的settings
Settings.Builder settings = Settings.builder()
.put("number_of_shards", 3)
.put("number_of_replicas", 1);
//2、 准备关于索引的结构mappings
XContentBuilder mappings = JsonXContent.contentBuilder()
.startObject()
.startObject("properties")
.startObject("name")
.field("type","text")
.endObject()
.startObject("age")
.field("type","integer")
.endObject()
.startObject("birthday")
.field("type","date")
.field("format","yyyy-MM-dd")
.endObject()
.endObject()
.endObject();
//2 将settings 和 mappings封装成一个request对象
CreateIndexRequest request = new CreateIndexRequest(index)
.settings(settings)
.mapping(type,mappings);
//3 通过client对象去链接es并执行创建索引
RestHighLevelClient client = ESClient.getClient();
CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
//测试
System.out.println("response"+response.toString());
}
2.3 检查索引是否存在，删除索引
//检查索引是否存在
@Test
public void exists() throws IOException {
//1 准备request对象
GetIndexRequest request = new GetIndexRequest();
request.indices(index);
// 2 通过client去检查
RestHighLevelClient client = ESClient.getClient();
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
System.out.println(exists);
}
2.4 修改文档
-
添加文档操作
@Test public void createDoc() throws IOException { ObjectMapper mapper = new ObjectMapper(); // 1. 准备json数据 Person person = new Person(1, "张三", 23, new Date()); String json = mapper.writeValueAsString(person); System.out.println(json); // 2. 准备一个request对象(手动指定id创建) IndexRequest indexRequest = new IndexRequest(index,type,person.getId().toString()); indexRequest.source(json, XContentType.JSON); // 3、通过client对象执行添加操作 RestHighLevelClient client = ESClient.getClient(); IndexResponse resp = client.index(indexRequest, RequestOptions.DEFAULT); // 4、 输出返回 System.out.println(resp.getResult().toString()); } -
修改文档
// 修改文档，通过doc方式 @Test public void updateDoc() throws IOException { // 创建map,指定需要修改的内容 Map<String,Object> map = new HashMap<String, Object>(); map.put("name","李四"); String docId = "1"; // 创建一个request对象，封装数据 UpdateRequest updateRequest = new UpdateRequest(index,type,docId); updateRequest.doc(map); // 通过client对象执行 RestHighLevelClient client = ESClient.getClient(); UpdateResponse update = client.update(updateRequest, RequestOptions.DEFAULT); // 返回输出结果 System.out.println(update.getResult().toString()); }2.5 删除文档
2.6 java批量操作文档
3.ElasticSearch练习
-
索引 ： sms-logs-index
-
类型：sms-logs-type
| 字段名称 | 备注 |
|---|---|
| createDate | 创建时间String |
| sendDate | 发送时间 date |
| longCode | 发送长号码 如 16092389287811 string |
| Mobile | 如 13000000000 |
| corpName | 发送公司名称，需要分词检索 |
| smsContent | 下发短信内容，需要分词检索 |
| State | 短信下发状态 0 成功 1 失败 integer |
| Operatorid | 运营商编号1移动2联通3电信 integer |
| Province | 省份 |
| ipAddr | 下发服务器IP地址 |
| replyTotal | 短信状态报告返回时长 integer |
| Fee | 扣费 integer |
-
创建实例代码
//先定义索引名和类型名 String index = "sms_logs_index"; String type = "sms_logs_type";public void create_index() throws IOException { Settings.Builder settings = Settings.builder() .put("number_of_shards", 3) .put("number_of_replicas", 1); XContentBuilder mappings = JsonXContent.contentBuilder() .startObject() .startObject("properties") .startObject("createDate") .field("type", "text") .endObject() .startObject("sendDate") .field("type", "date") .field("format", "yyyy-MM-dd") .endObject() .startObject("longCode") .field("type", "text") .endObject() .startObject("mobile") .field("type", "text") .endObject() .startObject("corpName") .field("type", "text") .field("analyzer", "ik_max_word") .endObject() .startObject("smsContent") .field("type", "text") .field("analyzer", "ik_max_word") .endObject() .startObject("state") .field("type", "integer") .endObject() .startObject("operatorid") .field("type", "integer") .endObject() .startObject("province") .field("type", "text") .endObject() .startObject("ipAddr") .field("type", "text") .endObject() .startObject("replyTotal") .field("type", "integer") .endObject() .startObject("fee") .field("type", "integer") .endObject() .endObject() .endObject(); CreateIndexRequest request = new CreateIndexRequest(index) .settings(settings) .mapping(type,mappings); RestHighLevelClient client = ESClient.getClient(); CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT); System.out.println(response.toString()); }-
数据导入部分
PUT /sms_logs_index/sms_logs_type/1 { "corpName": "途虎养车", "createDate": "2020-1-22", "fee": 3, "ipAddr": "10.123.98.0", "longCode": 106900000009, "mobile": "1738989222222", "operatorid": 1, "province": "河北", "relyTotal": 10, "sendDate": "2020-2-22", "smsContext": "【途虎养车】亲爱的灯先生，您的爱车已经购买", "state": 0 }
-
4. ES的各种查询
4.1 term&terms查询
4.1.1 term查询
- term的查询是代表完全匹配，搜索之前不会对你的关键字进行分词
#term匹配查询
POST /sms_logs_index/sms_logs_type/_search
{
"from": 0, #limit from,size
"size": 5,
"query": {
"term": {
"province": {
"value": "河北"
}
}
}
}
##不会对term中所匹配的值进行分词查询
// java代码实现方式
@Test
public void testQuery() throws IOException {
// 1 创建Request对象
SearchRequest request = new SearchRequest(index);
request.types(type);
// 2 指定查询条件
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.from(0);
builder.size(5);
builder.query(QueryBuilders.termQuery("province", "河北"));
request.source(builder);
// 3 执行查询
RestHighLevelClient client = ESClient.getClient();
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4 获取到_source中的数据
for (SearchHit hit : response.getHits().getHits()) {
Map<String, Object> result = hit.getSourceAsMap();
System.out.println(result);
}
}
-
terms是针对一个字段包含多个值得运用
- terms: where province = 河北 or province = ? or province = ?
#terms 匹配查询 POST /sms_logs_index/sms_logs_type/_search { "from": 0, "size": 5, "query": { "terms": { "province": [ "河北", "河南" ] } } }// java代码 terms 查询 @Test public void test_terms() throws IOException { SearchRequest request = new SearchRequest(index); request.types(type); SearchSourceBuilder builder = new SearchSourceBuilder(); builder.query(QueryBuilders.termsQuery("province","河北","河南")); request.source(builder); RestHighLevelClient client = ESClient.getClient(); SearchResponse resp = client.search(request, RequestOptions.DEFAULT); for (SearchHit hit : resp.getHits().getHits()){ System.out.println(hit); } }
4.2 match查询
match查询属于高层查询，它会根据你查询字段类型不一样，采用不同的查询方式
match查询，实际底层就是多个term查询，将多个term查询的结果进行了封装
-
查询的如果是日期或者是数值的话，它会根据你的字符串查询内容转换为日期或者是数值对等
-
如果查询的内容是一个不可被分的内容（keyword），match查询不会对你的查询的关键字进行分词
-
如果查询的内容是一个可被分的内容（text）,match则会根据指定的查询内容按照一定的分词规则去分词进行查询
4.2.1 match_all查询
查询全部内容，不指定任何查询条件
POST /sms_logs_index/sms_logs_type/_search
{
"query": {
"match_all": {}
}
}
@Test
public void test_match_all() throws IOException {
// 创建Request ,放入索引和类型
SearchRequest request = new SearchRequest(index);
request.types(type);
builder.size(20); //es默认查询结果只展示10条，这里可以指定展示的条数
//指定查询条件
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.query(QueryBuilders.matchAllQuery());
request.source(builder);
// 执行查询
RestHighLevelClient client = ESClient.getClient();
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 获取查询结果，遍历显示
for (SearchHit hit : response.getHits().getHits()){
System.out.println(hit);
}
}
4.2.2 match查询 根据某个Field
POST /sms_logs_index/sms_logs_type/_search
{
"query": {
"match": {
"smsContent": "打车"
}
}
}
@Test
public void test_match_field() throws IOException {
SearchRequest request = new SearchRequest(index);
request.types(type);
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.query(QueryBuilders.matchQuery("smsContext","打车"));
request.source(builder);
RestHighLevelClient client = ESClient.getClient();
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
for (SearchHit hit : response.getHits().getHits()){
System.out.println(hit);
}
}
4.2.3 布尔match查询
基于一个Filed匹配的内容，采用and或者or的方式进行连接
# 布尔match查询
POST /sms_logs_index/sms_logs_type/_search
{
"query": {
"match": {
"smsContext": {
"query": "打车 女士",
"operator": "and" #or
}
}
}
}
@Test
public void test_match_boolean() throws IOException {
SearchRequest request = new SearchRequest(index);
request.types(type);
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.query(QueryBuilders.matchQuery("smsContext","打车 女士").operator(Operator.AND));
request.source(builder);
RestHighLevelClient client = ESClient.getClient();
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
for (SearchHit hit : response.getHits().getHits()){
System.out.println(hit);
}
4.2.4 multi_match查询
match针对一个field做检索，multi_match针对多个field进行检索，多个key对应一个text
POST /sms_logs_index/sms_logs_type/_search
{
"query": {
"multi_match": {
"query": "河北", #指定text
"fields": ["province","smsContext"] #指定field
}
}
}
// java 实现
@Test
public void test_multi_match() throws IOException {
SearchRequest request = new SearchRequest(index);
request.types(type);
SearchSourceBuilder builder = new SearchSourceBuilder();
// 查询的文本内容 字段1 字段2 字段3 。。。。。
builder.query(QueryBuilders.multiMatchQuery("河北", "province", "smsContext"));
request.source(builder);
RestHighLevelClient client = ESClient.getClient();
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
for (SearchHit hit : response.getHits().getHits()) {
System.out.println(hit);
}
}
4.3 ES 的其他查询
4.3.1 ID 查询
# id查询
GET /sms_logs_index/sms_logs_type/1
GET /索引名/type类型/id
public void test_multi_match() throws IOException {
GetRequest request = new GetRequest(index,type,"1");
RestHighLevelClient client = ESClient.getClient();
GetResponse resp = client.get(request, RequestOptions.DEFAULT);
System.out.println(resp.getSourceAsMap());
}
4.3.2 ids查询
根据多个id进行查询，类似MySql中的where Id in (id1,id2,id3….)
POST /sms_logs_index/sms_logs_type/_search
{
"query": {
"ids": {
"values": [1,2,3] #id值
}
}
}
//java代码
@Test
public void test_query_ids() throws IOException {
SearchRequest request = new SearchRequest(index);
request.types(type);
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.query(QueryBuilders.idsQuery().addIds("1","2","3"));
request.source(builder);
RestHighLevelClient client = ESClient.getClient();
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
for (SearchHit hit : response.getHits().getHits()){
System.out.println(hit.getSourceAsMap());
}
}
4.3.3 prefix查询
前缀查询，可以通过一个关键字去指定一个Field的前缀，从而查询到指定的文档
POST /sms_logs_index/sms_logs_type/_search
{
"query": {
"prefix": {
"smsContext": {
"value": "河"
}
}
}
}
#与 match查询的不同在于，prefix类似mysql中的模糊查询。而match的查询类似于严格匹配查询
# 针对不可分割词
@Test
public void test_query_prefix() throws IOException {
SearchRequest request = new SearchRequest(index);
request.types(type);
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.query(QueryBuilders.prefixQuery("smsContext","河"));
request.source(builder);
RestHighLevelClient client = ESClient.getClient();
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
for (SearchHit hit : response.getHits().getHits()){
System.out.println(hit.getSourceAsMap());
}
}
4.3.4 fuzzy查询
fuzzy查询：模糊查询，我们可以输入一个字符的大概，ES就可以根据输入的内容大概去匹配一下结果，eg.你可以存在一些错别字
#fuzzy查询
#fuzzy查询
POST /sms_logs_index/sms_logs_type/_search
{
"query": {
"fuzzy": {
"corpName": {
"value": "盒马生鲜",
"prefix_length": 2 # 指定前几个字符要严格匹配
}
}
}
}
#不稳定，查询字段差太多也可能查不到
// java 实现
@Test
public void test_query_fuzzy() throws IOException {
SearchRequest request = new SearchRequest(index);
request.types(type);
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.query(QueryBuilders.fuzzyQuery("corpName","盒马生鲜").prefixLength(2));
request.source(builder);
RestHighLevelClient client = ESClient.getClient();
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
for (SearchHit hit : response.getHits().getHits()){
System.out.println(hit.getSourceAsMap());
}
}
.prefixLength() :指定前几个字符严格匹配
4.3.5 wildcard查询
通配查询，与mysql中的like查询是一样的，可以在查询时，在字符串中指定通配符*和占位符？
#wildcard查询
POST /sms_logs_index/sms_logs_type/_search
{
"query": {
"wildcard": {
"corpName": {
"value": "*车" # 可以使用*和？指定通配符和占位符
}
}
}
}
?代表一个占位符
??代表两个占位符
// java代码
@Test
public void test_query_wildcard() throws IOException {
SearchRequest request = new SearchRequest(index);
request.types(type);
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.query(QueryBuilders.wildcardQuery("corpName","*车"));
request.source(builder);
RestHighLevelClient client = ESClient.getClient();
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
for (SearchHit hit : response.getHits().getHits()){
System.out.println(hit.getSourceAsMap());
}
}
4.3.6 range查询
范围查询，只针对数值类型，对某一个Field进行大于或者小于的范围指定
POST /sms_logs_index/sms_logs_type/_search
{
"query": {
"range": {
"relyTotal": {
"gte": 0,
"lte": 3
}
}
}
}
查询范围:[gte,lte]
查询范围：(gt,lt)
//java代码
@Test
public void test_query_range() throws IOException {
SearchRequest request = new SearchRequest(index);
request.types(type);
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.query(QueryBuilders.rangeQuery("fee").lt(5).gt(2));
request.source(builder);
RestHighLevelClient client = ESClient.getClient();
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
for (SearchHit hit : response.getHits().getHits()){
System.out.println(hit.getSourceAsMap());
}
}
4.3.7 regexp查询
正则查询，通过你编写的正则表达式去匹配内容
PS: prefix,fuzzy,wildcar和regexp查询效率相对比较低,在对效率要求比较高时，避免去使用
POST /sms_logs_index/sms_logs_type/_search
{
"query": {
"regexp": {
"moible": "109[0-8]{7}" # 匹配的正则规则
}
}
}
//java 代码
@Test
public void test_query_regexp() throws IOException {
SearchRequest request = new SearchRequest(index);
request.types(type);
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.query(QueryBuilders.regexpQuery("moible","106[0-9]{8}"));
request.source(builder);
RestHighLevelClient client = ESClient.getClient();
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
for (SearchHit hit : response.getHits().getHits()){
System.out.println(hit.getSourceAsMap());
}
}
4.4 深分页Scroll
ES对from+size有限制，from和size两者之和不能超过1w
原理：
from+size ES查询数据的方式：
1 先将用户指定的关键词进行分词处理
2 将分词去词库中进行检索，得到多个文档的id
3 去各个分片中拉去指定的数据 耗时
4 根据数据的得分进行排序 耗时
5 根据from的值，将查询到的数据舍弃一部分，
6 返回查询结果
Scroll+size 在ES中查询方式
1 先将用户指定的关键词进行分词处理
2 将分词去词库中进行检索，得到多个文档的id
3 将文档的id存放在一个ES的上下文中，ES内存
4 根据你指定给的size的个数去ES中检索指定个数的数据，拿完数据的文档id,会从上下文中移除
5 如果需要下一页的数据，直接去ES的上下文中，找后续内容
6 循环进行4.5操作
缺点，Scroll是从内存中去拿去数据的，不适合做实时的查询，拿到的数据不是最新的
# 执行scroll查询，返回第一页数据，并且将文档id信息存放在ES的上下文中，指定生存时间
POST /sms_logs_index/sms_logs_type/_search?scroll=1m
{
"query": {
"match_all": {}
},
"size": 2,
"sort": [
{
"fee": {
"order": "desc"
}
}
]
}
#查询下一页的数据
POST /_search/scroll
{
"scroll_id": "DnF1ZXJ5VGhlbkZldGNoAwAAAAAAACSPFnJjV1pHbENVVGZHMmlQbHVZX1JGdmcAAAAAAAAkkBZyY1daR2xDVVRmRzJpUGx1WV9SRnZnAAAAAAAAJJEWcmNXWkdsQ1VUZkcyaVBsdVlfUkZ2Zw==",
"scoll" :"1m" #scorll信息的生存时间
}
#删除scroll在ES中上下文的数据
DELETE /_search/scroll/scrill_id
//java代码
@Test
public void test_query_scroll() throws IOException {
// 1 创建SearchRequest
SearchRequest request = new SearchRequest(index);
request.types(type);
// 2 指定scroll信息,生存时间
request.scroll(TimeValue.timeValueMinutes(1L));
// 3 指定查询条件
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.size(2);
builder.sort("fee",SortOrder.DESC);
builder.query(QueryBuilders.matchAllQuery());
// 4 获取返回结果scrollid ,source
request.source(builder);
RestHighLevelClient client = ESClient.getClient();
SearchResponse response = client.search(request,RequestOptions.DEFAULT);
String scrollId = response.getScrollId();
System.out.println(scrollId);
while(true){
// 5 循环创建SearchScrollRequest
SearchScrollRequest scrollRequest = new SearchScrollRequest(scrollId);
// 6 指定scrollid生存时间
scrollRequest.scroll(TimeValue.timeValueMinutes(1L));
// 7 执行查询获取返回结果
SearchResponse scrollResp = client.scroll(scrollRequest, RequestOptions.DEFAULT);
// 8.判断是否得到数据，输出
if (scrollResp.getHits().getHits() != null && scrollResp.getHits().getHits().length > 0){
System.out.println("=======下一页的数据========");
for (SearchHit hit : scrollResp.getHits().getHits()){
System.out.println(hit.getSourceAsMap());
}
}else{
// 9。判断没有查询到数据-退出循环
System.out.println("没得");
break;
}
}
// 10 创建clearScrollRequest
ClearScrollRequest clearScrollRequest = new ClearScrollRequest();
// 11 指定scrollid
clearScrollRequest.addScrollId(scrollId);
// 12 删除
client.clearScroll(clearScrollRequest,RequestOptions.DEFAULT);
}
4.5 delete-by-query
根据term，match等查询方式去删除大量的文档
如果你需要删除的内容，是index下的大部分数据，不建议使用，建议逆向操作，创建新的索引，添加需要保留的数据内容
POST /sms_logs_index/sms_logs_type/_delete_by_query
{
"query": {
"range": {
"relyTotal": {
"gte": 2,
"lte": 3
}
}
}
}
##中间跟你的查询条件，查到什么，删什么t
public class test_sms_search2 {
String index = "sms_logs_index";
String type = "sms_logs_type";
@Test
public void test_query_fuzzy() throws IOException {
DeleteByQueryRequest request = new DeleteByQueryRequest(index);
request.types(type);
request.setQuery(QueryBuilders.rangeQuery("relyTotal").gt("2").lt("3"));
RestHighLevelClient client = ESClient.getClient();
BulkByScrollResponse response = client.deleteByQuery(request, RequestOptions.DEFAULT);
System.out.println(response.toString());
}
}
4.6 复合查询
4.6. 1 bool查询
复合过滤器，可以将多个查询条件以一定的逻辑组合在一起，and or
-
must : 所有的条件，用must组合在一起，表示AND
-
must_not:将must_not中的条件，全部不能匹配，表示not的意思，不能匹配该查询条件
-
should: 所有条件，用should组合在一起，表示or的意思，文档必须匹配一个或者多个查询条件
-
filter: 过滤器，文档必须匹配该过滤条件，跟must子句的唯一区别是，filter不影响查询的score
#查询省份为河北或者河南的
#并且公司名不是河马生鲜的
#并且smsContext中包含软件两个字
POST /sms_logs_index/sms_logs_type/_search
{
"query": {
"bool": {
"should": [
{
"term": {
"province": {
"value": "河北"
}
}
},
{
"term": {
"province": {
"value": "河南"
}
}
],
"must_not": [
{
"term": {
"corpName": {
"value": "河马生鲜"
}
}
}
],
"must": [
{
"match": {
"smsContext": "软件"
}
}
]
}
}
}
本博客用于技术学习，所有资源都来源于网络，部分是转发，部分是个人总结。欢迎共同学习和转载，转载请在醒目位置标明原文。如有侵权，请留言告知，及时撤除。
