在本文中，我们将带你了解ElasticSearch，Tire和嵌套查询/与ActiveRecord的关联在这篇文章中，我们将为您详细介绍ElasticSearch，Tire和嵌套查询/与ActiveR
在本文中，我们将带你了解ElasticSearch，Tire和嵌套查询/与ActiveRecord的关联在这篇文章中，我们将为您详细介绍ElasticSearch，Tire和嵌套查询/与ActiveRecord的关联的方方面面，并解答elasticsearch嵌套对象常见的疑惑，同时我们还将给您一些技巧，以帮助您实现更有效的Elastic Search 6嵌套查询聚合、elasticsearch elk最全java api 搜索 聚合、嵌套查询、Elasticsearch query_string嵌套查询、ElasticSearch 嵌套查询以及注意事项。
本文目录一览：- ElasticSearch，Tire和嵌套查询/与ActiveRecord的关联（elasticsearch嵌套对象）
- Elastic Search 6嵌套查询聚合
- elasticsearch elk最全java api 搜索 聚合、嵌套查询
- Elasticsearch query_string嵌套查询
- ElasticSearch 嵌套查询以及注意事项
ElasticSearch，Tire和嵌套查询/与ActiveRecord的关联（elasticsearch嵌套对象）
我正在将ElasticSearch与Tire一起使用来对一些ActiveRecord模型进行索引和搜索，并且我一直在寻找索引和搜索关联的“正确”方法。我还没有找到最佳解决方案，所以我想问问是否有人采用他们认为确实有效的方法。
作为一个示例设置（已完成，但说明了问题），假设我们有一本书，带有章节。每本书都有标题和作者，以及许多章节。每章都有文字。我们希望为书的字段和章节的文本建立索引，以便您可以按作者搜索书，也可以搜索其中包含某些单词的任何书。
class Book < ActiveRecord::Base include Tire::Model::Search include Tire::Model::Callbacks has_many :chapters mapping do indexes :title, :analyzer => ''snowball'', :boost => 100 indexes :author, :analyzer => ''snowball'' indexes :chapters, type: ''object'', properties: { chapter_text: { type: ''string'', analyzer: ''snowball'' } } endendclass Chapter < ActiveRecord::Base belongs_to :bookend因此，我使用以下命令进行搜索：
s = Book.search do query { string query_string }end即使看起来索引应该执行此操作，这也不起作用。相反，如果我索引：
indexes :chapters, :as => ''chapters.map{|c| c.chapter_text}.join(''|''), :analyzer => ''snowball''这样可以使文本可搜索，但是显然这不是一个好办法，并且会丢失实际的关联对象。我已经尝试过各种搜索方式，例如：
s = Book.search do query do boolean do should { string query_string } should { string "chapters.chapter_text:#{query_string}" } end endend那里也没有运气。如果有人有一个很好的，清晰的示例，就可以使用Tire索引和搜索关联的ActiveRecord对象，那么这似乎是对此处知识库的真正补充。
感谢您的任何想法和贡献。
答案1
小编典典Tire中对ActiveRecord关联的支持正在起作用，但是需要在应用程序内部进行一些调整。毫无疑问，图书馆应该在这里做得更好，将来肯定会做得更好。
就是说，这是一个可以在Elasticsearch中与Rails的关联一起工作的Tire配置的完整示例：active_record_associations.rb
让我在这里强调几件事。
父模型
首先，必须确保将关联的更改通知关联的父模型。
给定我们有一个Chapter模型“属于” a Book，我们需要做：
class Chapter < ActiveRecord::Base belongs_to :book, touch: trueend这样，当我们执行以下操作时：
book.chapters.create text: "Lorem ipsum...."该book实例被通知增加的一章。
响应触摸
整理完这一部分后，我们需要将有关更改通知给 Tire ，并相应地更新elasticsearch索引：
class Book < ActiveRecord::Base has_many :chapters after_touch() { tire.update_index }end（毫无疑问， Tire
应该after_touch自行拦截通知，而不是强迫您这样做。这是另一方面，证明了绕过图书馆的限制以不伤眼睛的方式进行工作有多么容易）
在Rails <3.1中正确进行JSON序列化
尽管自述文件中提到您必须在Rails <3.1中禁用自动的“在JSON中添加根密钥”，但许多人还是忘记了它，因此您也必须在类定义中包括它：
self.include_root_in_json = falseelasticsearch的正确映射
现在是我们工作的重点-为我们的文档（模型）定义适当的映射：
mapping do indexes :title, type: ''string'', boost: 10, analyzer: ''snowball'' indexes :created_at, type: ''date'' indexes :chapters do indexes :text, analyzer: ''snowball'' endend请注意，我们title使用created_at了相关模型的升序索引（作为“日期”）和章节文本。在Elasticsearch中，所有数据都有效地“归一化”为单个文档（如果这样的话会稍微有意义）。
正确的文档JSON序列化
作为最后一步，我们必须正确地序列化Elasticsearch索引中的文档。注意我们如何利用 ActiveRecord中 的便捷to_json方法：
__
def to_indexed_json to_json( include: { chapters: { only: [:text] } } )end设置好所有这些设置之后，我们就可以在文档的Book和Chapter部分中搜索属性。
请运行开头链接的Ruby文件active_record_associations.rb，以查看完整图片。
有关更多信息，请参考以下资源：
- https://github.com/karmi/railscasts-episodes/commit/ee1f6f3
- https://github.com/karmi/railscasts-episodes/commit/03c45c3
- https://github.com/karmi/tire/blob/master/test/models/active_record_models.rb#L10-20
Elastic Search 6嵌套查询聚合
我是elasticsearch查询和聚合的新手。我有一个带有以下映射的嵌套文档
PUT /company
{
"mappings": {
`"data": {
"properties": {
"deptId": {
"type": "keyword"
},"deptName": {
"type": "keyword"
},"employee": {
"type": "nested","properties": {
"empId": {
"type": "keyword"
},"empName": {
"type": "text"
},"salary": {
"type": "float"
}
}}}}}}
我已插入示例数据，如下所示
PUT company/data/1
{
"deptId":"1","deptName":"HR","employee": [
{
"empId": "1","empName": "John","salary":"1000"
},{
"empId": "2","empName": "Will","salary":"2000"
}
]}
PUT company/data/3
{
"deptId":"3","deptName":"FINANCE","employee": [
{
"empId": "1","salary":"1000"
},{
"empId": "2","salary":"2000"
},{
"empId": "3","empName": "Mark","salary":"4000"
}]
}
我如何为以下内容构建查询DSL
- 员工人数最多的部门
- 大多数部门的员工
我正在使用Elastic Search 6.2.4
elasticsearch elk最全java api 搜索 聚合、嵌套查询
一、 一般查询... 2
（一） matchAllQuery(client). 2
（二） matchQuery(client);3
（三） multiMatchQuery(client);3
（四） wildcardQuery()模糊查询... 3
（五） commonTermQuery(client);3
（六） termQuery(client);4
（七） testPrefixQuery前缀... 4
（八） rangeQuery(client); 范围查询... 4
1、 两种写法... 5
（九） nested query. 5
（十） 其他查询... 6
二、 聚合查询AggsQueryTest7
（一） avgQuery(client);7
（二） minQuery(client);8
（三） maxQuery(client). 8
（四） valueCountQuery(client); //统计个数... 8
值计算聚合... 8
（五） extendedStatsQuery(client);//统计聚合(一堆). 8
（六） percentileQuery(client). 9
（七） percentileRankQuery(client);//百分比... 9
（八） rangeQuery(client)//范围... 9
（九） histogramQuery(client);//柱状图聚合... 10
（十） dateHistogramQuery(client);// 按日期间隔分组... 10
（十一） 获取聚合里面的结果... 10
（十二） 嵌套的聚合... 10
（十三） 反转嵌套... 10
三、 二级分组的例子：... 10
四、 嵌套查询... 11
（一） constantScoreQuery(client);11
（二） booQuery(client)（最常用）... 12
1、 经典案例... 12
（三） disMaxQuery(client);13
五、 本案例数据导入... 14
一、一般查询
（一）matchAllQuery(client)
matchAllQuery()方法用来匹配全部文档
| public static void matchAllQuery(Client client ) { SearchResponse res = null; QueryBuilder qb = QueryBuilders.matchAllQuery();
res = client.prepareSearch("search_test") .setTypes("article") .setSearchType(SearchType.DFS_QUERY_THEN_FETCH) .setQuery(qb) .setFrom(0) .setSize(10) .execute().actionGet(); for (SearchHit hit: res.getHits().getHits()){ System.out.println(hit.getSourceAsString()); } |
for有选择的打印
| 1. for (SearchHit searchHit : searchHits) { 2. String name = (String) searchHit.getSource().get("name"); 3. String birth = (String) searchHit.getSource().get("birth"); 4. String interest = (String) searchHit.getSource().get("interest"); 5. System.out.println("-------------" + (++i) + "------------"); 6. System.out.println(name); 7. System.out.println(birth); 8. System.out.println(interest); 9. }
|
（二）matchQuery(client);
不能写为matchQuery("name", "to*")
matchQuery("filedname","value")匹配单个字段，匹配字段名为filedname,值为value的文档
| QueryBuilder qb = QueryBuilders.matchQuery("title", "article"); |
（三）multiMatchQuery(client);
多个字段匹配某一个值
1. QueryBuilder queryBuilder = QueryBuilders.multiMatchQuery("music",
2. "name", "interest");//搜索name中或interest中包含有music的文档（必须与music一致）
（四）wildcardQuery()模糊查询
模糊查询，?匹配单个字符，*匹配多个字符
[java] view plain copy
1. WildcardQueryBuilder queryBuilder = QueryBuilders.wildcardQuery("name",
2. "*jack*");//搜索名字中含有jack文档（name中只要包含jack即可）
（五）commonTermQuery(client);
一种略高级的查询，充分考虑了stop-word的低优先级，提高了查询精确性。
将terms分为了两种：more-importent（low-frequency） and less important（high-frequency）。less-important比如stop-words，eg：the and。
QueryBuilder qb = QueryBuilders
.commonTermsQuery("title","article");
（六）termQuery(client);
* termQuery("key", obj) 完全匹配
* termsQuery("key", obj1, obj2..) 一次匹配多个值
QueryBuilder qb =QueryBuilders
.termQuery("title","article");
// QueryBuilder qb = QueryBuilders
// .termsQuery("title","article","relevence");
（七）testPrefixQuery前缀
参考网址：https://www.cnblogs.com/wenbronk/p/6432990.html
/**
* 前缀查询
*/
@Test
public void testPrefixQuery() {
QueryBuilder queryBuilder = QueryBuilders.matchQuery("user", "kimchy");
searchFunction(queryBuilder);
}
（八）rangeQuery(client);范围查询
// 闭区间 QueryBuilderquery = QueryBuilders.rangeQuery("age").from(10).to(20); // 开区间 QueryBuilder query = QueryBuilders.rangeQuery("age").gt(10).lt(20);
1、两种写法
QueryBuilder qb = QueryBuilders
.rangeQuery("like")
.gte(5)
.lt(7);
// QueryBuilderqb = QueryBuilders
// .rangeQuery("like")
// .from(5)
// .to(7)
// .includeLower(true)// 包含上届
// .includeUpper(false);// 包含下届
（九）nested query
在关系查询中，存在一对多和多对一的关系。因为就会出现两种查询情况。
在解释查询关系之前，需要理解一下Relationship Name，如文档中contact和account的关系 ，一个Account会有多个contact，一个Contact也会有多个Account，但是最终归结的关系为Account对contact的关系为一对多。也就是说 在contact上保存有对account''的引用，这个引用的名称就是RelationshipName（区别于field name），类似于外键的名称。
下面介绍两种查询
1、多对一的查询。
salesforce 中特有的__r模式，直接关联到parent上，如contact上存有对account的引用，那么我可以直接关联出account上的相关字段。
[sql] view plain copy
1. select id,name ,account.name,account.id from contact
2、一对多的查询
嵌入式查询(nestedquery),这种方式适合在父的一端查询相关子的记录。如：我想查找到负责这个account的全部contact。
[sql] view plain copy
1. select id,name,(select id,name from contacts)
2. from account
查询结果如图：
这样就会关联出所以的contact数据，contact部分的展示形式json串。注意contacts不是对象名称，是Relationshipname
（十）其他查询
QueryBuilder qb =QueryBuilders.existsQuery("str");
//QueryBuilder qb =QueryBuilders.prefixQuery("name", "prefix");
//QueryBuilder qb =QueryBuilders.regexpQuery("user", "k.*y");
正则表达式
/** * 模糊查询 * 不能用通配符, 不知道干啥用 */
//QueryBuilder qb = QueryBuilders.fuzzyQuery("name", "kimzhy");
|
//QueryBuilder qb =QueryBuilders.typeQuery("my_type");
/** * 只查询一个id的 * QueryBuilders.idsQuery(String...type).ids(Collection<String> ids) */
//QueryBuilder qb = QueryBuilders.idsQuery("my_type","type2").addIds("1","2","5");
|
二、聚合查询AggsQueryTest
（一）avgQuery(client);
publicstatic void avgQuery(Client client ) {
SearchResponseres = null;
AvgBuilderagg = AggregationBuilders
.avg("avg_num")
.field("like");
res= client.prepareSearch("search_test")
.setTypes("article")
.setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
.addAggregation(agg)
.setFrom(0)
.setSize(10)
.execute().actionGet();
System.out.println(res);
//on shutdown
client.close();
}
（二）minQuery(client);
MinBuilderagg = AggregationBuilders
.min("min_num")
.field("like");
（三）maxQuery(client)
MaxBuilderagg = AggregationBuilders
.max("max_num")
.field("like");
（四）valueCountQuery(client); //统计个数
值计算聚合
SearchResponseres = null;
ExtendedStatsBuilderagg = AggregationBuilders
.extendedStats("extended_stats_num")
.field("like");
（五）extendedStatsQuery(client);//统计聚合(一堆)
返回聚合分析后所有指标，比Stats多三个统计结果：平方和、方差、标准差
| 1 2 3 4 5 |
{ "aggs" : { "grades_stats" : { "extended_stats" : { "field" : "grade" } } } } |
ExtendedStatsBuilder agg =AggregationBuilders.extendedStats("extended_stats_num").field("like");
（六）percentileQuery(client)
PercentilesBuilderagg = AggregationBuilders
.percentiles("percentile_num")
.field("like")
.percentiles(95,99,99.9);
（七）percentileRankQuery(client);//百分比
PercentileRanksBuilderagg = AggregationBuilders
.percentileRanks("percentile_rank_num")
.field("like")
.percentiles(3,5);
（八） rangeQuery(client)//范围
AggregationBuilder agg =
AggregationBuilders
.range("agg")
.field("like")
.addUnboundedTo(3)
.addRange(3, 5)
.addUnboundedFrom(5);
（九）histogramQuery(client);//柱状图聚合
（十）dateHistogramQuery(client);// 按日期间隔分组
（十一）获取聚合里面的结果
TopHitsBuilder thb= AggregationBuilders.topHits("top_result");
（十二）嵌套的聚合
NestedBuilder nb= AggregationBuilders.nested("negsted_path").path("quests");
（十三）反转嵌套
AggregationBuilders.reverseNested("res_negsted").path("kps ");
三、二级分组的例子：
上面这些基本就是常用的聚合查询了，在嵌套（nested）下面的子聚合查询就是嵌套查询了，除了嵌套查询，其他的聚合查询也可以无限级添加子查询
举个例子
SearchRequestBuildersearch= client.prepareSearch("index").setTypes("type");
TermsBuilderone= AggregationBuilders.terms("group_name").field("name");
TermsBuildertwo= AggregationBuilders.terms("group_age").field("age");
one.subAggregation(two)
search.addAggregation(one);
Terms terms=search.get().getAggregations().get("group_name");
for(Terms.Bucket name_buk:terms.getBuckets()){
//一级分组的内容Terms terms_age= name_buk.getAggregations().get("group_age");
for(Terms.Bucket age_buk:terms_age.getBuckets()){
//二级分组的内容 System.out.println(name_buk.getKey()+" "+age_buk.getKey()+" "+age_buk.getDocCount());
}}
四、嵌套查询
（一）constantScoreQuery(client);
/**
* 包裹查询, 高于设定分数, 不计算相关性
*/
@Test
public void testConstantScoreQuery() {
QueryBuilder queryBuilder = QueryBuilders.constantScoreQuery(QueryBuilders.termQuery("name", "kimchy")).boost(2.0f);
searchFunction(queryBuilder);
（二）booQuery(client)（最常用）
/**
* 组合查询
* must(QueryBuilders) : AND
* mustNot(QueryBuilders): NOT
* should: : OR
*/
publicstaticvoid booQuery(Client client) {//最有用的嵌套查询
SearchResponse res = null;
QueryBuilder qb =QueryBuilders.boolQuery()
.should(QueryBuilders.termQuery("title", "02"))
// .mustNot(QueryBuilders.termQuery("title","article"))
.should(QueryBuilders.termQuery("title", "relevance"));
// .filter(QueryBuilders.termQuery("title","article"));
res = client.prepareSearch("search_test").setTypes("article").setSearchType(SearchType.DFS_QUERY_THEN_FETCH)
.setQuery(qb).setFrom(0).setSize(10).execute().actionGet();
for (SearchHit hit : res.getHits().getHits()) {
System.out.println(hit.getSourceAsString());
}
1、经典案例
如果需要查询(addr = Beijing) && (sex = false) && (10 < age< 20)的doc：
public static QueryBuilder createQuery() {
BoolQueryBuilder query =QueryBuilders.boolQuery();
// addr = Beijing
query.must(new QueryStringQueryBuilder("Beijing").field("addr"));
// sex = falese
query.must(new QueryStringQueryBuilder("false").field("sex"));
// age ∈ (10,20)
query.must(new RangeQueryBuilder("age").gt(10).lt(20));
return query;
}
返回结果：
{"pid":168,"age":16,"sex":false,"name":"Tom","addr":"Beijing"}
{"pid":276,"age":19,"sex":false,"name":"Bill","addr":"Beijing"}
{"pid":565,"age":16,"sex":false,"name":"Brown","addr":"Beijing"}
{"pid":73,"age":13,"sex":false,"name":"David","addr":"Beijing"}
作者：唐影若凡
链接：https://www.jianshu.com/p/a3694b13bf89
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
（三）disMaxQuery(client);
/**
* disMax查询
* 对子查询的结果做union, score沿用子查询score的最大值,
* 广泛用于muti-field查询
*/
@Test
public void testDisMaxQuery() {
QueryBuilder queryBuilder = QueryBuilders.disMaxQuery()
.add(QueryBuilders.termQuery("user", "kimch")) // 查询条件
.add(QueryBuilders.termQuery("message", "hello"))
.boost(1.3f)
.tieBreaker(0.7f);
searchFunction(queryBuilder);
}
五、本案例数据导入
curl -XPUT''http://169.254.135.217:9200/search_test/'' -d ''{
"settings" : {
"index" : {
"number_of_shards" : 3,
"number_of_replicas" : 1
}
},
"mappings" : {
"article" : {
"properties" : {
"title" : { "type" : "string"},
"body" : { "type" : "string"},
"like" : { "type" : "long"},
"publish_date" : { "type" : "date"}
}
}
}
}''
curl -XGET''http://169.254.135.217:9200/search_test/_mapping?pretty''
curl -XGET''http://169.254.135.217:9200/search_test/_mapping/article?pretty''
curl -XHEAD -i''http://169.254.135.217:9200/search_test/article''
/search_test/article/1
{
"title": "What''s relevance?",
"body": "atticle body of relevence:Term frequency/inversedocument frequency",
"like": "1",
"publish_date": "2016-03-24"
}
/search_test/article/2
{
"title": "article 02",
"body": "article 02 atticlebody of relevence:Term frequency/inverse document frequency",
"like": "2",
"publish_date":"2016-05-24"
}
/search_test/article/3
{
"title": "article 03",
"body": "article 03 atticlebody of relevence:Term frequency/inverse document frequency",
"like": "3",
"publish_date":"2016-07-24"
}
/search_test/article/4
{
"title": "article 04",
"body": "article 04 atticlebody of relevence:Term frequency/inverse document frequency",
"like": "4",
"publish_date":"2016-09-24"
}
/search_test/article/5
{
"title": "article 05",
"body": "article 04 atticlebody of relevence:Term frequency/inverse document frequency",
"like": "5",
"publish_date":"2016-11-24"
}
/search_test/article/6
{
"title": "Quick brownrabbits",
"body": "Brown rabbits arecommonly seen.",
"like": "6",
"publish_date":"2016-12-24"
}
/search_test/article/7
{
"title": "Keeping petshealthy",
"body": "My quick brown foxeats rabbits on a regular basis.",
"like": "7",
"publish_date":"2017-11-24"
}
Elasticsearch query_string嵌套查询
如何解决Elasticsearch query_string嵌套查询？
我进行了更多研究，发现可以通过在映射中将include_in_parent设置为true来实现。
现在，您应该可以执行如下查询
{
"query": {
"query_string": {
"query": "fields.fieldvalue:sometext"
}
}
}
例如：-
"mappings": {
"documentMetadatavalue": {
"properties": {
"id": {
"type": "string"
},
"fields": {
"type": "nested",
"include_in_parent": true,
"properties": {
"fieldId": {"type": "string"},
"fieldvalue": {"type": "string"}
}
}
}
}
}
让我知道是否有帮助。
解决方法
我正在尝试使用query_string编写查询以检索嵌套对象的数据查询。
我想做的查询的一个例子是：
{
"query": {
"query_string": {
"query": "a.id:2"
}
}
}
其中“ a”是嵌套对象，“ id”是“ a”的字段。
我知道我可以使用嵌套查询成功地执行此任务，编写如下查询：
{
"nested": {
"path": "a"
"query_string": {
"query": "a.id:2"
}
}
}
但是，我想避免这种情况。我不想自己弄清楚用户正在搜索嵌套字段并修改查询。我尝试使用“ fields”参数，但它似乎不适用于嵌套对象。
是否可以使用“ query_string”查询直接编写此查询？有可能获得什么语义？（例如，如果我写“ a.id:2 AND
ab：10”，我是在匹配同一对象还是不同对象中的两个字段？）
ElasticSearch 嵌套查询以及注意事项
es 实体
@Data
@Document(indexName = "indexdemo", type = "typedemo", shards = 3, replicas = 1)
public class TmsWaybillEsEntity {
/**
* 主键id
*/
@Id
private Long id;
private String waybillNo;
private String orderNo;
private Long orderId;
@Field(type = FieldType.Nested)
private List<TmsWaybillDispatcherInfoEsEntity> dispatcherBills;
}
@Data
public class TmsWaybillDispatcherInfoEsEntity {
private Long dispatcherBillId;
private String dispatcherBillNo;
private Byte waybillType;
private String snapDriverName;
private String snapDriverPhone;
private String snapTruckPlateNumber;
}
创建索引和映射
public void createWaybillIndex(){
if(waybillEsTemplate.indexExists(TmsWaybillEsEntity.class)){
log.info("运单索引已经存在，无需创建");
}else{
boolean createResult = waybillEsTemplate.createIndex(TmsWaybillEsEntity.class);
waybillEsTemplate.putMapping(TmsWaybillEsEntity.class);
waybillEsTemplate.refresh(TmsWaybillEsEntity.class);
log.info("创建运单索引的结果：{}", createResult);
}
}
嵌套查询，kibana --> Dev Tools
GET /indexdemo/typedemo/_search
{
"query": {
"bool": {
"must": [{
"term": {
"companyId": {
"value": 965006065496327513,
"boost": 1.0
}
}
},
{
"nested": {
"query": {
"bool": {
"must": [{
"wildcard": {
"dispatcherBills.dispatcherBillNo.keyword": {
"value": "*P101454019050700013*",
"boost": 1.0
}
}
}],
"disable_coord": false,
"adjust_pure_negative": true,
"boost": 1.0
}
},
"path": "dispatcherBills",
"score_mode": "max",
"ignore_unmapped": false,
"boost": 1.0
}
},
{
"nested": {
"query": {
"bool": {
"must": [{
"term": {
"dispatcherBills.snapDriverName.keyword": {
"value": "smxc",
"boost": 1.0
}
}
}],
"disable_coord": false,
"adjust_pure_negative": true,
"boost": 1.0
}
},
"path": "dispatcherBills",
"score_mode": "max",
"ignore_unmapped": false,
"boost": 1.0
}
}
],
"disable_coord": false,
"adjust_pure_negative": true,
"boost": 1.0
}
}
}注意事项， 分片数量和副本数量要和运维的同事配置的一致。
今天关于ElasticSearch，Tire和嵌套查询/与ActiveRecord的关联和elasticsearch嵌套对象的介绍到此结束，谢谢您的阅读，有关Elastic Search 6嵌套查询聚合、elasticsearch elk最全java api 搜索 聚合、嵌套查询、Elasticsearch query_string嵌套查询、ElasticSearch 嵌套查询以及注意事项等更多相关知识的信息可以在本站进行查询。
本文标签：
