ElasticSearch查询操作

查询所有

    @Test
    void testBulk() throws IOException {

        //构建查询请求,指定查询的索引名称
        SearchRequest searchRequest = new SearchRequest("person");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //指定查询条件
        QueryBuilder queryBuilder = QueryBuilders.matchAllQuery();//查询所有文档
        searchSourceBuilder.query(queryBuilder);
        //添加查询条件构建器对象
        searchRequest.source(searchSourceBuilder);
        searchSourceBuilder.from(0); //从哪开始 
        searchSourceBuilder.size(1000); //分页 默认十页
        //查询获取查询结果
        SearchResponse search = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        //获取命中对象
        SearchHits hits = search.getHits();
        long value = hits.getTotalHits().value;
        System.out.println("总记录数:"+value);

        SearchHit[] hits1 = hits.getHits();
        for (SearchHit documentFields : hits1) {
            String sourceAsString = documentFields.getSourceAsString();
            System.out.println(sourceAsString);
        }
    }

词条查询

term不会对查询条件分词,一般用于查询品牌,分类

    @Test
    public void testTermQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("person");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        QueryBuilder queryBuilder = QueryBuilders.termQuery("name","zhangsan");
        searchSourceBuilder.query(queryBuilder);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits searchHits = searchResponse.getHits();
        System.out.println(searchHits.getTotalHits());
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
    }

match查询

会对查询条件进行分词
然后将分词后的查询条件和词条进行等值匹配

默认取并集(OR) 交集(AND)

GET person/_search
{
	"query":{
		"match":{
			"字段名称":{
				"query":"条件",
				"operator":"and"
			}
		}
	}
}

    @Test
    public void testMatchQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("person");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        MatchQueryBuilder queryBuilder = QueryBuilders.matchQuery("name","zhangsan");
        queryBuilder.operator(Operator.AND);//求并集
        searchSourceBuilder.query(queryBuilder);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits searchHits = searchResponse.getHits();
        System.out.println(searchHits.getTotalHits());
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
    }

模糊查询

wildcard:查询条件分词模糊查询,?匹配一个字符,*多个字符

GET person/_search
{
  "query": {
    "wildcard": {
      "name": {
        "value": "zhang*" #通配符不能写前面性能差
      }
    }
  }
}

正则查询

GET person/_search
{
  "query": {
   "regexp": {
     "name": "\\w(.)*"
   }
  }
}

前缀查询

GET person/_search #对 k v 查询比较好
{
  "query": {
   "prefix": {
     "name": {
       "value": "zhang"
     }
   }
  }
}

    @Test
    public void testWildQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("person");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        WildcardQueryBuilder wildcardQueryBuilder = QueryBuilders.wildcardQuery("name", "zhang*");
        
        searchSourceBuilder.query(wildcardQueryBuilder);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits searchHits = searchResponse.getHits();
        System.out.println(searchHits.getTotalHits());
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
    }

范围查询&排序

范围内查询

GET person/_search
{
  "query": {
   "range": {
     "price": {
       "gte": 2000,
       "lte": 3000
     }
   }
  },
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ]
}

    @Test
    public void testRangeQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("person");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        RangeQueryBuilder price = QueryBuilders.rangeQuery("price");
        price.gte(2000);//指定范围
        price.lte(3000);
        searchSourceBuilder.query(price);
        searchSourceBuilder.sort("price", SortOrder.ASC);//任何查询都可以指定排序
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits searchHits = searchResponse.getHits();
        System.out.println(searchHits.getTotalHits());
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
    }

多字段查询

queryString:

会对查询条件进行分词
然后将分词后的查询条件和词条进行等值匹配
默认取并集(OR)
可以指定多个查询字段

#手动分词 "query": "zhang OR san" 
GET person/_search
{
  "query": {
   "query_string": {
     "fields": ["name","address"],
     "query": "zhangsan" 
   }
  }
}

GET person/_search
{
  "query": {
   "simple_query_string": {
     "fields": ["name","address"],
     "query": "zhangsan AND san" 
   }
  }
}

    @Test
    public void testQueryStringeQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("person");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        QueryStringQueryBuilder query = QueryBuilders.queryStringQuery("zhang").field("name").field("address").defaultOperator(Operator.AND);
        searchSourceBuilder.query(query);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits searchHits = searchResponse.getHits();
        System.out.println(searchHits.getTotalHits());
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
    }

布尔查询

boolQuery:对多个查询条件链接.连接方式:

must(and):条件必须成立
must_not(not):条件必须不成立
should(or):条件可以成立
filter:条件必须成立,性能比must高.不会计算得分

GET person/_search
{
  "query": {
   "bool": {
     "must": [
       {
         "term": {
           "name": {
             "value": "zhang"
           }
         }
       },{
         "match": {
           "address": "beijing"
         }
       }
     ]
   }
  }
}

    @Test
    public void testBoolQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("person");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        //1.构建boolQuery
        BoolQueryBuilder query = QueryBuilders.boolQuery();
        //2.构建各个查询条件
        QueryBuilder termQuery = QueryBuilders.termQuery("name","zhang");
        query.must(termQuery);
        QueryBuilder matchQuery = QueryBuilders.matchQuery("address","beijing");
        //3.使用boolQuery链接
        query.filter(matchQuery);

        searchSourceBuilder.query(query);
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits searchHits = searchResponse.getHits();
        System.out.println(searchHits.getTotalHits());
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
    }

聚合查询

指标聚合:相当于MySQL的聚合函数. max min avg sum等

GET person/_search
{
  "query": {
    "match": {
      "name": "zhang"
    }
  },
  "aggs": {
    "max_price":{
      "max": {
        "field": "prece"
      }
    }
  }
}

桶聚合:相当于MySQL的group by操作.不要对text类型的数据进行分组,会失败.

#分组
GET person/_search
{
  "query": {
    "match": {
      "name": "zhang"
    }
  },
  "aggs": {
    "name_zhang": {
      "terms": {
        "field": "name",
        "size": 100
      }
    }
  }
}

    @Test
    public void testGroupQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("person");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        QueryBuilder query = QueryBuilders.matchQuery("name","zhang");

        searchSourceBuilder.query(query);
        //name_zhang 自定义名称 name分组字段
        AggregationBuilder agg = AggregationBuilders.terms("name_zhang").field("name").size(100);
        searchSourceBuilder.aggregation(agg);

        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits searchHits = searchResponse.getHits();
        System.out.println(searchHits.getTotalHits());
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

        Aggregations aggregations = searchResponse.getAggregations();
        Map<String, Aggregation> stringAggregationMap = aggregations.asMap();
        Terms name_zhang = (Terms) stringAggregationMap.get("name_zhang");
//        name_zhang.
    }

高亮查询

高亮三要素:

高亮字段
前缀
后缀

GET person/_search
{
  "query": {
    "match": {
      "name": "zhang"
    }
  },
  "highlight": {
    "fields": {
      "name": {
        "pre_tags": "<em>",
        "post_tags": "</em>"
      }
    }
  }
}

    @Test
    public void testHighQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("person");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        QueryBuilder query = QueryBuilders.matchQuery("name","zhang");
        searchSourceBuilder.query(query);
        HighlightBuilder highlighter = new HighlightBuilder();
        //设置三要素
        highlighter.field("name");//设置高亮字段
        highlighter.preTags("<em>");//设置前缀
        highlighter.postTags("</em>");//设置后缀字段
        searchSourceBuilder.highlighter(highlighter);

        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);
        SearchHits searchHits = searchResponse.getHits();
        System.out.println(searchHits.getTotalHits());
        SearchHit[] hits = searchHits.getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
            //获取高亮结果再替换name
        }
    }

索引别名&重建索引

POST _reindex #重建索引
{
  "source": {
    "index": "v1"
  },
  "dest": {
    "index": "v2"
  }
}
 
DELETE v1 #删除v1
POST v2/_alias/v1 #v2取别名为v1

posted @ 2021-08-06 16:42 ZHANG3F 阅读(189) 评论(0) 收藏举报

刷新页面返回顶部

Loading

ZHANG3F