ElasticSearch的查询相关操作---使用es的api和结果遍历

摘要: 引用了https://www.cnblogs.com/wenbronk/p/6432990.html和http://blog.csdn.net/xiaohulunb/article/details/37877435的内容

QueryBuilders：

QueryBuilders:
boolQuery:
must:相当于sql的and
must not:相当于sql的not
should:相当于sql的or
mathcquery:单个匹配
mathcAllQuery:匹配所有
termQuery:termQuery("key", obj) 完全匹配 ;termsQuery("key", obj1, obj2..)  一次匹配多个值
multiMatchQuery:multiMatchQuery("text", "field1", "field2"..);  匹配多个字段, field有通配符忒行
idsQuery:构造一个只会匹配的特定数据 id 的查询
constantScoreQuery:看了一下这个类的构造函数ConstantScoreQuery(Filter filter) ，我的理解就是通过构造filter来完成文档的过滤，并且返回一个复合当前过滤条件的文档的常量分数，这个分数等于为查询条件设置的boost
fuzzyQuery:模糊查询
moreLikeThisQuery:文档中的文本查询
prefixQuery:前缀查询
rangeQuery:在一个范围内查询相匹配的文档
termQuery:一个查询相匹配的文件包含一个术语
termsQuery:一个查询相匹配的多个value---minimumMatch(1); // 设置最小数量的匹配提供了条件。默认为1。
wildcardQuery:通配符查询
nestedQuery:嵌套查询---scoreMode("total");// max, total, avg or none
disMaxQuery:对子查询的结果做union, score沿用子查询score的最大值,
spanFirstQuery:跨度查询,还包括(spanNearQuery,spanNotQuery,spanOrQuery,spanTermQuery)

其他字段解释：

percent_terms_to_match：匹配项（term）的百分比，默认是0.3
min_term_freq：一篇文档中一个词语至少出现次数，小于这个值的词将被忽略，默认是2
max_query_terms：一条查询语句中允许最多查询词语的个数，默认是25
stop_words：设置停止词，匹配时会忽略停止词
min_doc_freq：一个词语最少在多少篇文档中出现，小于这个值的词会将被忽略，默认是无限制
max_doc_freq：一个词语最多在多少篇文档中出现，大于这个值的词会将被忽略，默认是无限制
min_word_len：最小的词语长度，默认是0
max_word_len：最多的词语长度，默认无限制
boost_terms：设置词语权重，默认是1
boost：设置查询权重，默认是1
analyzer：设置使用的分词器，默认是使用该字段指定的分词器

操作例子（es版本还是1.7.2）：

//查询某个医生的明细-- boolean query and 条件组合查询(时间+护士名称)
BoolQueryBuilder must = QueryBuilders.boolQuery().must(
QueryBuilders.matchQuery("name_doc", "681_护士206"))
.must(QueryBuilders.rangeQuery("yke123").gte(startTime + START_DATE_YUE)
.lte(endTime + END_DATE_YUE));
SearchResponse searchResponse = mSRB.setQuery(must).execute().actionGet();
/**
* 在es中所有的查询结果都会保存在SearchResponse中，在从SearchResponse中读取数据的时候，有两种方式：第一种是对Query的结果进行读取，
* 使用的是hit，每一条查询到的doc都是一个hit，可以将每个hit转换为map形式的数据，map的具体形式为<"field"，"value">的形式
*/
for(SearchHit hit:searchResponse.getHits()){
Map<String, Object> source = hit.getSource();//每条数据
if (!source.isEmpty()) {
String name_depa=(String) source.get("name_depa");
String name_doc=(String)source.get("name_doc");
System.out.println(name_depa+"=="+name_doc);
}
}
//查询该人的工时
SearchResponse searchResponse1 = mSRB.setQuery(must).addAggregation(AggregationBuilders.sum("hushi").field("hushi")).get();
InternalSum hushi = searchResponse1.getAggregations().get("hushi");
System.out.println("总工的工时"+hushi.getValue());
/**
* 第二种方式是针对查询中的聚合问题（aggregation），聚合完成后的每条doc都是一个bucket（桶），他的访问只能通过bucket来进行，而不能使用hit
*/
//设置聚合查询条件---使用SearchResponse封装结果
SearchResponse searchResponse3 = mSRB.addAggregation(AggregationBuilders.terms("name_doc").field("name_doc").size(0))//返回所有数据用0
.execute().actionGet();
System.out.println(searchResponse);
Terms depa_count = searchResponse.getAggregations().get("name_doc");
for (Terms.Bucket bucket : depa_count.getBuckets()) {
String name_depa = bucket.getKey();//科室名称
long docCount = bucket.getDocCount();//科室出现的次数

System.out.println(name_depa + "==" + docCount);
}
//该医生在该月的总条数
long l = searchResponse.getHits().totalHits();
System.out.println(l+"===============");

使用游标sroll进行分页查询遍历

client = (Client) Pools.getPool().borrowObject();//从链接池中获取客户端
//构建查询器
SearchRequestBuilder mSRB = client
.prepareSearch(index1)//索引--查询工时表
.setSearchType(SearchType.SCAN)//设置查询类型--DFS_QUERY_THEN_FETCH
.setSize(100).setScroll(TimeValue.timeValueMinutes(8));
String startTime = "2013-08";
String endTime = "2013-09";
String timeType = "0";
BoolQueryBuilder must = QueryBuilders.boolQuery()
//.must(QueryBuilders.matchQuery("name_doc", "681_护士206"))
.must(QueryBuilders.rangeQuery("yke123").gte(startTime + START_DATE_YUE)
.lte(endTime + END_DATE_YUE));
SearchResponse searchResponse = mSRB.setQuery(must).execute().actionGet();
//使用scroll遍历查询的数据
Date begin = new Date();
long count = searchResponse.getHits().getTotalHits();//第一次不返回数据
for(int i=0,sum=0; sum<count; i++){
searchResponse = client.prepareSearchScroll(searchResponse.getScrollId())
.setScroll(TimeValue.timeValueMinutes(8))
.execute().actionGet();
sum += searchResponse.getHits().hits().length;
for(SearchHit hit:searchResponse.getHits()){
Map<String, Object> source = hit.getSource();
String name_depa=(String) source.get("name_depa");
String name_doc=(String)source.get("name_doc");
String yke123=(String)source.get("yke123");
System.out.println("科室:"+name_depa+"医生:"+name_doc+"开单时间:"+yke123);
};
System.out.println("总量"+count+" 已经查到"+sum);
}
Date end = new Date();
System.out.println("耗时: "+(end.getTime()-begin.getTime()));

引用他人的http://blog.csdn.net/xr568897472/article/details/73826255：

（1）统计某个字段的数量

ValueCountBuilder vcb= AggregationBuilders.count("count_uid").field("uid");

（2）去重统计某个字段的数量（有少量误差）

CardinalityBuilder cb= AggregationBuilders.cardinality("distinct_count_uid").field("uid");

（3）聚合过滤

FilterAggregationBuilder fab= AggregationBuilders.filter("uid_filter").filter(QueryBuilders.queryStringQuery("uid:001"));

（4）按某个字段分组

TermsBuilder tb= AggregationBuilders.terms("group_name").field("name");

（5）求和

SumBuilder sumBuilder= AggregationBuilders.sum("sum_price").field("price");

（6）求平均

AvgBuilder ab= AggregationBuilders.avg("avg_price").field("price");

（7）求最大值

MaxBuilder mb= AggregationBuilders.max("max_price").field("price");

（8）求最小值

MinBuilder min= AggregationBuilders.min("min_price").field("price");

（9）按日期间隔分组

DateHistogramBuilder dhb= AggregationBuilders.dateHistogram("dh").field("date");

（10）获取聚合里面的结果

TopHitsBuilder thb= AggregationBuilders.topHits("top_result");

（11）嵌套的聚合

NestedBuilder nb= AggregationBuilders.nested("negsted_path").path("quests");

（12）反转嵌套

AggregationBuilders.reverseNested("res_negsted").path("kps ");