es查询语法常用汇总某索引的总记录数

 

 一、查询某索引的总记录数

 

 

二、查询某个字段值为空

 

 1 {
 2   "query": {
 3     "bool": {
 4       "must_not": {
 5         "exists": {
 6           "field": "Year"
 7         }
 8       }
 9     }
10   }
11 }

 

三、我想查询Year 等于 2019 或者 Title 字段包含 2018 的记录，怎么写呢？分别用es写法，还有es nest类库写法。

 1 用 Elasticsearch 原生查询语法可以这样写：
 2 
 3 ```
 4 {
 5   "query": {
 6     "bool": {
 7       "should": [
 8         {
 9           "match": {
10             "Year": 2019
11           }
12         },
13         {
14           "match": {
15             "Title": "2018"
16           }
17         }
18       ]
19     }
20   }
21 }
22 ```
23 
24 上面的查询语句中，使用了 `should` 来进行或逻辑的查询操作，即返回的文档要么有 `Year` 字段等于 `2019`，要么有 `Title` 字段中包含 `2018` 字符串。如果同时满足，则会被查询到。
25 
26 使用 Elasticsearch 的 Nest 类库，这个查询可以这样写：
27 
28 ```
29 var searchResponse = client.Search<MyDocument>(s => s
30     .Query(q => q
31         .Bool(b => b
32             .Should(
33                 bs => bs.Match(m => m.Field(f => f.Year).Query("2019")),
34                 bs => bs.Match(m => m.Field(f => f.Title).Query("2018"))
35             )
36         )
37     )
38 );
39 ```
40 
41 在 Nest 中，可以在 `Match` 查询中直接传入一个字符串来进行匹配，如上面的代码所示。当然，你也可以创建一个查询对象来代替传入字符串：
42 
43 ```
44 var yearQuery = new MatchQuery
45 {
46     Field = "Year",
47     Query = "2019"
48 };
49 
50 var titleQuery = new MatchQuery
51 {
52     Field = "Title",
53     Query = "2018"
54 };
55 
56 var searchResponse = client.Search<MyDocument>(s => s
57     .Query(q => q
58         .Bool(b => b
59             .Should(
60                 bs => bs.Query(q1 => yearQuery),
61                 bs => bs.Query(q2 => titleQuery)
62             )
63         )
64     )
65 );
66 ```
67 
68 这样可以使你的代码更加可读和灵活。

 

四：我想查询Year 等于 2019 或者 Title 字段包含 2018 或者Name包含zhang 的记录，怎么写呢？分别用es写法，还有es nest类库写法。

 1 用 Elasticsearch 原生查询语法可以这样写：
 2 
 3 ```
 4 {
 5   "query": {
 6     "bool": {
 7       "should": [
 8         {
 9           "match": {
10             "Year": 2019
11           }
12         },
13         {
14           "match": {
15             "Title": "2018"
16           }
17         },
18         {
19           "match": {
20             "Name": "zhang"
21           }
22         }
23       ]
24     }
25   }
26 }
27 ```
28 
29 上面的查询语句中，使用了 `should` 来进行或逻辑的查询操作，即返回的文档要么有 `Year` 字段等于 `2019`，要么有 `Title` 字段中包含 `2018` 字符串，要么有 `Name` 字段中包含 `zhang` 字符串。如果同时满足，则会被查询到。
30 
31 使用 Elasticsearch 的 Nest 类库，这个查询可以这样写：
32 
33 ```
34 var searchResponse = client.Search<MyDocument>(s => s
35     .Query(q => q
36         .Bool(b => b
37             .Should(
38                 bs => bs.Match(m => m.Field(f => f.Year).Query("2019")),
39                 bs => bs.Match(m => m.Field(f => f.Title).Query("2018")),
40                 bs => bs.Match(m => m.Field(f => f.Name).Query("zhang"))
41             )
42         )
43     )
44 );
45 ```
46 
47 在 Nest 中，也是使用 Bool 和 Should 来嵌套查询，通过 Match 查询来进行字段与搜索关键字的匹配。也可以使用 MatchPhrase 查询来进行短语的匹配，以更精确地匹配需要的文档。

 

五、我想查询Year 等于 2019 并且Book包含kk 或者 Title 字段包含 2018 或者Name包含zhang 的记录，怎么写呢？分别用es写法，还有es nest类库写法。

 1 用 Elasticsearch 原生查询语法可以这样写：
 2 
 3 ```
 4 {
 5   "query": {
 6     "bool": {
 7       "must": [
 8         {
 9           "match": {
10             "Year": 2019
11           }
12         },
13         {
14           "match": {
15             "Book": "kk"
16           }
17         }
18       ],
19       "should": [
20         {
21           "match": {
22             "Title": "2018"
23           }
24         },
25         {
26           "match": {
27             "Name": "zhang"
28           }
29         }
30       ]
31     }
32   }
33 }
34 ```
35 
36 上面的查询语句中，使用了 `must` 来进行与逻辑的查询操作，即返回的文档要有 `Year` 字段等于 `2019`，且 `Book` 字段中包含 `kk` 关键字。同时使用了 `should` 来进行或逻辑的查询操作，即返回的文档要么有 `Title` 字段中包含 `2018` 字符串，要么有 `Name` 字段中包含 `zhang` 字符串。如果同时满足，则会被查询到。
37 
38 使用 Elasticsearch 的 Nest 类库，这个查询可以这样写：
39 
40 ```
41 var searchResponse = client.Search<MyDocument>(s => s
42     .Query(q => q
43         .Bool(b => b
44             .Must(
45                 bm => bm.Match(m => m.Field(f => f.Year).Query("2019")),
46                 bm => bm.Match(m => m.Field(f => f.Book).Query("kk"))
47             )
48             .Should(
49                 bs => bs.Match(m => m.Field(f => f.Title).Query("2018")),
50                 bs => bs.Match(m => m.Field(f => f.Name).Query("zhang"))
51             )
52         )
53     )
54 );
55 ```
56 
57 在 Nest 中，也是使用 Bool 和 Should 来嵌套查询，不同的是查询条件使用的是 Must 和 Should，即返回的文档要同时满足 Must 查询和 Should 查询。
58 
59 以上代码仅供参考，具体实现可能需要根据实际情况进行修改。

 

六、我想查询Year 等于 2019 并且Book不包含kk 或者 Title 字段包含 2018 或者Name包含zhang 的记录，怎么写呢？分别用es写法，还有es nest类库写法。

 1 用 Elasticsearch 原生查询语法可以这样写：
 2 
 3 ```
 4 {
 5   "query": {
 6     "bool": {
 7       "must": [
 8         {
 9           "match": {
10             "Year": 2019
11           }
12         }
13       ],
14       "must_not": [
15         {
16           "match": {
17             "Book": "kk"
18           }
19         }
20       ],
21       "should": [
22         {
23           "match": {
24             "Title": "2018"
25           }
26         },
27         {
28           "match": {
29             "Name": "zhang"
30           }
31         }
32       ]
33     }
34   }
35 }
36 ```
37 
38 上面的查询语句中，使用了 `must` 来进行与逻辑的查询操作，即返回的文档必须有 `Year` 字段等于 `2019`。同时，使用了 `must_not` 来进行非逻辑的查询操作，即返回的文档不能有 `Book` 字段中包含 `kk` 关键字。最后，使用了 `should` 来进行或逻辑的查询操作，即返回的文档要么有 `Title` 字段中包含 `2018` 字符串，要么有 `Name` 字段中包含 `zhang` 字符串。如果同时满足，则会被查询到。
39 
40 使用 Elasticsearch 的 Nest 类库，这个查询可以这样写：
41 
42 ```
43 var searchResponse = client.Search<MyDocument>(s => s
44     .Query(q => q
45         .Bool(b => b
46             .Must(
47                 bm => bm.Match(m => m.Field(f => f.Year).Query("2019"))
48             )
49             .MustNot(
50                 bmn => bmn.Match(m => m.Field(f => f.Book).Query("kk"))
51             )
52             .Should(
53                 bs => bs.Match(m => m.Field(f => f.Title).Query("2018")),
54                 bs => bs.Match(m => m.Field(f => f.Name).Query("zhang"))
55             )
56         )
57     )
58 );
59 ```
60 
61 在 Nest 中，也是使用 Bool 和 Should 来嵌套查询，不同的是查询条件使用的是 Must，MustNot和Should，即返回的文档必须同时满足 Must 查询和 Should 查询，并且不能满足 MustNot 查询。
62 
63 以上代码仅供参考，具体实现可能需要根据实际情况进行修改。

 

七、我想查询Year 等于 2019 并且 Title 字段包含 2018 并且Name不等于zhang 的记录，怎么写呢？分别用es写法，还有es nest类库写法。

 1 用 Elasticsearch 原生查询语法可以这样写：
 2 
 3 ```
 4 {
 5   "query": {
 6     "bool": {
 7       "must": [
 8         {
 9           "match": {
10             "Year": 2019
11           }
12         },
13         {
14           "match": {
15             "Title": "2018"
16           }
17         }
18       ],
19       "must_not": [
20         {
21           "match": {
22             "Name": "zhang"
23           }
24         }
25       ]
26     }
27   }
28 }
29 ```
30 
31 上面的查询语句中，使用了 `must` 来进行与逻辑的查询操作，即返回的文档必须有 `Year` 字段等于 `2019`，且 `Title` 字段中包含 `2018` 字符串。同时，使用了 `must_not` 来进行非逻辑的查询操作，即返回的文档不能有 `Name` 字段等于 `zhang`。如果同时满足，则会被查询到。
32 
33 使用 Elasticsearch 的 Nest 类库，这个查询可以这样写：
34 
35 ```
36 var searchResponse = client.Search<MyDocument>(s => s
37     .Query(q => q
38         .Bool(b => b
39             .Must(
40                 bm => bm.Match(m => m.Field(f => f.Year).Query("2019")),
41                 bm => bm.Match(m => m.Field(f => f.Title).Query("2018"))
42             )
43             .MustNot(
44                 bmn => bmn.Match(m => m.Field(f => f.Name).Query("zhang"))
45             )
46         )
47     )
48 );
49 ```
50 
51 在 Nest 中，也是使用 Bool 和 MustNot 和 Must 来嵌套查询，即返回的文档必须同时满足 Must 查询，不能满足 MustNot 查询，并且必须有 Title 包含 2018 和 Year 等于 2019 的条件。
52 
53 以上代码仅供参考，具体实现可能需要根据实际情况进行修改。

 

八、我想查询Year 等于 2019 并且 Title 字段包含 2018 或者Name不等于zhang 的记录，怎么写呢？分别用es写法，还有es nest类库写法。

 

 1 用 Elasticsearch 原生查询语法可以这样写：
 2 
 3 ```
 4 {
 5   "query": {
 6     "bool": {
 7       "must": [
 8         {
 9           "match": {
10             "Year": 2019
11           }
12         }
13       ],
14       "should": [
15         {
16           "match": {
17             "Title": "2018"
18           }
19         },
20         {
21           "bool": {
22             "must_not": [
23               {
24                 "match": {
25                   "Name": "zhang"
26                 }
27               }
28             ]
29           }
30         }
31       ]
32     }
33   }
34 }
35 ```
36 
37 上面的查询语句中，使用了 `must` 来进行与逻辑的查询操作，即返回的文档必须有 `Year` 字段等于 `2019`。同时，使用了 `should` 来进行或逻辑的查询操作，即返回的文档要么有 `Title` 字段中包含 `2018` 字符串，要么有 `Name` 字段不等于 `zhang` 字符串。如果同时满足，则会被查询到。
38 
39 使用 Elasticsearch 的 Nest 类库，这个查询可以这样写：
40 
41 ```
42 var searchResponse = client.Search<MyDocument>(s => s
43     .Query(q => q
44         .Bool(b => b
45             .Must(
46                 bm => bm.Match(m => m.Field(f => f.Year).Query("2019"))
47             )
48             .Should(
49                 bs => bs.Match(m => m.Field(f => f.Title).Query("2018")),
50                 bs => bs.Bool(bn => bn.MustNot(m => m.Match(m => m.Field(f => f.Name).Query("zhang"))))
51             )
52         )
53     )
54 );
55 ```
56 
57 在 Nest 中，也是使用 Bool 和 Should 来嵌套查询，不同的是在 Should 中使用了一个 Bool 来实现多个条件查询。如果有任意一个条件满足，则会被查询到。
58 
59 以上代码仅供参考，具体实现可能需要根据实际情况进行修改。

 

九、我想查询Year 等于 2019 或者Name不等于zhang 或者Tile等于aaa 的记录，怎么写呢？分别用es写法，还有es nest类库写法。

 1 用 Elasticsearch 原生查询语法可以这样写：
 2 
 3 ```
 4 {
 5   "query": {
 6     "bool": {
 7       "should": [
 8         {
 9           "match": {
10             "Year": 2019
11           }
12         },
13         {
14           "bool": {
15             "must_not": [
16               {
17                 "match": {
18                   "Name": "zhang"
19                 }
20               }
21             ]
22           }
23         },
24         {
25           "match": {
26             "Title": "aaa"
27           }
28         }
29       ]
30     }
31   }
32 }
33 ```
34 
35 上面的查询语句中，使用了 `should` 来进行或逻辑的查询操作，即返回的文档要么有 `Year` 字段等于 `2019`，要么有 `Name` 字段不等于 `zhang`，要么有 `Title` 字段中包含 `aaa` 字符串。如果满足其中一个条件或多个条件，则会被查询到。
36 
37 使用 Elasticsearch 的 Nest 类库，这个查询可以这样写：
38 
39 ```
40 var searchResponse = client.Search<MyDocument>(s => s
41     .Query(q => q
42         .Bool(b => b
43             .Should(
44                 bs => bs.Match(m => m.Field(f => f.Year).Query("2019")),
45                 bs => bs.Bool(bn => bn.MustNot(m => m.Match(m => m.Field(f => f.Name).Query("zhang")))),
46                 bs => bs.Match(m => m.Field(f => f.Title).Query("aaa"))
47             )
48         )
49     )
50 );
51 ```
52 
53 在 Nest 中，也是使用 Bool 和 Should 来嵌套查询，分别设置三个 Match 和一个 Bool MustNot 子查询。如果有任意一个条件满足，则会被查询到。
54 
55 以上代码仅供参考，具体实现可能需要根据实际情况进行修改。

 

十、我想查询Year 等于 2019 或者Name不等于zhang 的记录，怎么写呢？分别用es写法，还有es nest类库写法。

 1 用 Elasticsearch 原生查询语法可以这样写：
 2 
 3 ```
 4 {
 5   "query": {
 6     "bool": {
 7       "should": [
 8         {
 9           "match": {
10             "Year": 2019
11           }
12         },
13         {
14           "bool": {
15             "must_not": [
16               {
17                 "match": {
18                   "Name": "zhang"
19                 }
20               }
21             ]
22           }
23         }
24       ]
25     }
26   }
27 }
28 ```
29 
30 上面的查询语句中，使用了 `should` 来进行或逻辑的查询操作，即返回的文档要么有 `Year` 字段等于 `2019`，要么有 `Name` 字段不等于 `zhang`。如果满足其中一个条件或多个条件，则会被查询到。
31 
32 使用 Elasticsearch 的 Nest 类库，这个查询可以这样写：
33 
34 ```
35 var searchResponse = client.Search<MyDocument>(s => s
36     .Query(q => q
37         .Bool(b => b
38             .Should(
39                 bs => bs.Match(m => m.Field(f => f.Year).Query("2019")),
40                 bs => bs.Bool(bn => bn.MustNot(m => m.Match(m => m.Field(f => f.Name).Query("zhang"))))
41             )
42         )
43     )
44 );
45 ```
46 
47 在 Nest 中，也是使用 Bool 和 Should 来嵌套查询，分别设置两个 Match 子查询。如果有任意一个条件满足，则会被查询到。
48 
49 以上代码仅供参考，具体实现可能需要根据实际情况进行修改。

 

十一、我想查询Year 等于 2019 并且Book不包含kk 或者 Title 字段包含 2018 或者Name包含zhang 并且Number等于5 的记录，怎么写呢？分别用es写法，还有es nest类库写法。

 

 1 用 Elasticsearch 原生查询语法可以这样写：
 2 
 3 ```
 4 {
 5   "query": {
 6     "bool": {
 7       "should": [
 8         {
 9           "match": {
10             "Title": "2018"
11           }
12         },
13         {
14           "bool": {
15             "must": [
16               {
17                 "match": {
18                   "Name": "zhang"
19                 }
20               },
21               {
22                 "match": {
23                   "Number": 5
24                 }
25               }
26             ]
27           }
28         },
29         {
30           "bool": {
31             "must_not": [
32               {
33                 "match": {
34                   "Book": "kk"
35                 }
36               }
37             ],
38             "must": [
39               {
40                 "match": {
41                   "Year": 2019
42                 }
43               }
44             ]
45           }
46         }
47       ]
48     }
49   }
50 }
51 ```
52 
53 上面的查询语句中，使用了 `should` 和 `must` 来进行组合查询操作，即返回的文档要么有 `Title` 字段包含 `2018`，或者有 `Name` 字段包含 `zhang` 并且有 `Number` 字段等于 `5`，或者有 `Year` 字段等于 `2019` 并且不包含 `Book` 字段包含 `kk`。如果满足其中一个条件或多个条件，则会被查询到。
54 
55 使用 Elasticsearch 的 Nest 类库，这个查询可以这样写：
56 
57 ```
58 var searchResponse = client.Search<MyDocument>(s => s
59     .Query(q => q
60         .Bool(b => b
61             .Should(
62                 bs => bs.Match(m => m.Field(f => f.Title).Query("2018")),
63                 bs => bs.Bool(bn => bn.Must(
64                     mu => mu.Match(m => m.Field(f => f.Name).Query("zhang")),
65                     mu => mu.Match(m => m.Field(f => f.Number).Query("5"))
66                 )),
67                 bs => bs.Bool(bn => bn.MustNot(
68                     mu => mu.Match(m => m.Field(f => f.Book).Query("kk"))
69                 )).Must(
70                     mu => mu.Match(m => m.Field(f => f.Year).Query("2019"))
71                 )
72             )
73         )
74     )
75 );
76 ```
77 
78 在 Nest 中，也是使用 Bool 和 Should 来嵌套查询，使用 Match 和 Must 等子查询。如果有任意一个条件满足，则会被查询到。
79 
80 以上代码仅供参考，具体实现可能需要根据实际情况进行修改。

 

十二：查询Year等于2019 或者 Title等于2018 的语法区别

 1 在es中 写法如下： {
 2     "query": {
 3         "bool": {
 4             "should": [{
 5                     "match": {
 6                         "Year": 2019
 7                     }
 8                 },
 9                 {
10                     "match": {
11                         "Title": "2018"
12                     }
13                 }
14             ]
15         }
16     }
17 } 这种写法 和下面 这种写法 是一样的吗？
18 
19 {
20     "query": {
21         "bool": {
22             "must": [{
23                 "match": {
24                     "Year": 2019
25                 }
26             }],
27             "should": [{
28                 "match": {
29                     "Title": "2018"
30                 }
31 
32             }]
33         }
34     }
35 }
1 这两种写法的含义不完全相同，主要区别在于是否强制匹配must条件所出现的文档。
2 
3 第一种写法中，使用should作为组合查询条件，表示只要满足其中的任意一个条件就可以被匹配。如果同时匹配了两个条件，那么得分会更高。
4 
5 第二种写法中，使用must和should作为组合查询条件，表示文档必须满足must条件，并且至少满足should中的一个条件才能被匹配。如果只满足should中的一个条件，那么得分会比同时满足两个条件低。
6 
7 因此，如果你期望只要满足其中任意一个条件就可以被匹配，可以使用第一种写法；如果你期望同时满足多个条件，并且其中某一个条件比其他条件更加重要，可以使用第二种写法，并将该条件放在must中。

 

十三、我想查询Year 等于 2019 并且Book不包含kk 并且 Title 字段包含 2018 或者Name包含zhang  或者Number等于5 的记录，怎么写呢？分别用es写法，还有es nest类库写法。

 1 用 Elasticsearch 原生查询语法可以这样写：
 2 
 3 ```
 4 {
 5   "query": {
 6     "bool": {
 7       "must": [
 8         {
 9           "match": {
10             "Year": 2019
11           }
12         },
13         {
14           "bool": {
15             "must_not": [
16               {
17                 "match": {
18                   "Book": "kk"
19                 }
20               }
21             ]
22           }
23         }
24       ],
25       "should": [
26         {
27           "match": {
28             "Title": "2018"
29           }
30         },
31         {
32           "match": {
33             "Name": "zhang"
34           }
35         },
36         {
37           "match": {
38             "Number": 5
39           }
40         }
41       ]
42     }
43   }
44 }
45 ```
46 
47 上面的查询语句中，使用了 `must`、`must_not` 和 `should` 来进行组合查询操作，即返回的文档必须同时满足 `Year` 等于 `2019`，并且不包含 `Book` 包含 `kk`，同时满足 `Title` 包含 `2018`，或者满足 `Name` 包含 `zhang`，或者满足 `Number` 等于 `5` 中的至少一个条件。如果以上条件都满足，则该文档会被查询到。
48 
49 使用 Elasticsearch 的 Nest 类库，这个查询可以这样写：
50 
51 ```
52 var searchResponse = client.Search<MyDocument>(s => s
53     .Query(q => q
54         .Bool(b => b
55             .Must(mu => mu
56                 .Match(m => m.Field(f => f.Year).Query("2019")),
57                 mu => mu.Bool(bn => bn.MustNot(
58                     mn => mn.Match(m => m.Field(f => f.Book).Query("kk"))
59                 ))
60             ).Should(sh => sh
61                 .Match(m => m.Field(f => f.Title).Query("2018")),
62                 sh => sh.Match(m => m.Field(f => f.Name).Query("zhang")),
63                 sh => sh.Match(m => m.Field(f => f.Number).Query("5"))
64             )
65         )
66     )
67 );
68 ```
69 
70 在 Nest 中，也是使用 `Bool` 和 `Should`、`Must`、`MustNot` 来嵌套查询，使用 `Match` 等子查询。如果文档同时满足 `Year` 等于 `2019`，并且不包含 `Book` 包含 `kk`，同时满足 `Title` 包含 `2018`，或者满足 `Name` 包含 `zhang`，或者满足 `Number` 等于 `5` 中的至少一个条件，则文档会被查询到。
71 
72 以上代码仅供参考，具体实现可能需要根据实际情况进行修改。

 

十三：我想查询Year 等于 2019 或者Book不包含kk 并且 Title 字段包含 2018 或者Name包含zhang  并且Number等于5 的记录，怎么写呢？分别用es写法，还有es nest类库写法。

 1 用 Elasticsearch 原生查询语法可以这样写：
 2 
 3 ```
 4 {
 5   "query": {
 6     "bool": {
 7       "should": [
 8         {
 9           "match": {
10             "Year": 2019
11           }
12         },
13         {
14           "bool": {
15             "must_not": [
16               {
17                 "match": {
18                   "Book": "kk"
19                 }
20               }
21             ]
22           }
23         }
24       ],
25       "must": [
26         {
27           "bool": {
28             "should": [
29               {
30                 "match": {
31                   "Title": "2018"
32                 }
33               },
34               {
35                 "match": {
36                   "Name": "zhang"
37                 }
38               },
39               {
40                 "match": {
41                   "Number": 5
42                 }
43               }
44             ]
45           }
46         }
47       ]
48     }
49   }
50 }
51 ```
52 
53 上面的查询语句中，使用了 `should` 和 `must` 来进行组合查询操作，即返回的文档可以满足 `Year` 等于 `2019` 或者不包含 `Book` 包含 `kk`，同时满足 `Title` 包含 `2018`，或者满足 `Name` 包含 `zhang`，并且满足 `Number` 等于 `5` 中的至少一个条件。如果以上条件都满足，则该文档会被查询到。
54 
55 使用 Elasticsearch 的 Nest 类库，这个查询可以这样写：
56 
57 ```
58 var searchResponse = client.Search<MyDocument>(s => s
59     .Query(q => q
60         .Bool(b => b
61             .Should(sh => sh
62                 .Match(m => m.Field(f => f.Year).Query("2019")),
63                 sh => sh.Bool(bn => bn.MustNot(
64                     mn => mn.Match(m => m.Field(f => f.Book).Query("kk"))
65                 ))
66             ).Must(mu => mu
67                 .Bool(bn => bn
68                     .Should(sh => sh
69                         .Match(m => m.Field(f => f.Title).Query("2018")),
70                         sh => sh.Match(m => m.Field(f => f.Name).Query("zhang")),
71                         sh => sh.Match(m => m.Field(f => f.Number).Query("5"))
72                     )
73                 )
74             )
75         )
76     );
77 ```
78 
79 在 Nest 中，也是使用 `Bool` 和 `Should`、`Must`、`MustNot` 来嵌套查询，使用 `Match` 等子查询。如果文档可以满足 `Year` 等于 `2019` 或不包含 `Book` 包含 `kk`，同时满足 `Title` 包含 `2018`，或者满足 `Name` 包含 `zhang`，并且满足 `Number` 等于 `5` 中的至少一个条件，则文档会被查询到。
80 
81 以上代码仅供参考，具体实现可能需要根据实际情况进行修改。

 

我想查询 fileContent=“666” and  fileName="777" and Code="888" and (Type=1 or Type=2 or Type=3) ，怎么写呢？分别用es写法，还有es nest类库写法。

 1 ES 查询语法：
 2 
 3 您可以通过以下查询 DSL 编写您的查询：
 4 
 5 ```
 6 {
 7   "query": {
 8     "bool": {
 9       "must": [
10         { "match": { "fileContent": "666" }},
11         { "match": { "fileName": "777" }},
12         { "match": { "Code": "888" }},
13         { "bool": {
14             "should": [
15               { "match": { "Type": 1 }},
16               { "match": { "Type": 2 }},
17               { "match": { "Type": 3 }}
18             ],
19             "minimum_should_match": 1
20           }
21         }
22       ]
23     }
24   }
25 }
26 ```
27 
28 其中，`bool` 查询是一个组合查询，`must` 表示所有查询子句都必须匹配，`should` 表示只需要其中一个匹配即可。`minimum_should_match` 控制至少需要满足多少个 `should` 查询子句。
29 
30 ES Nest 类库写法：
31 
32 使用 ES Nest 类库，您可以将上述查询转换为以下 C# 代码：
33 
34 ```
35 using Nest;
36 
37 var searchResponse = client.Search<YourDocument>(s => s
38     .Query(q => q
39         .Bool(b => b
40             .Must(mu => mu
41                 .Match(m => m.Field(f => f.FileContent).Query("666")),
42                 mu => mu
43                 .Match(m => m.Field(f => f.FileName).Query("777")),
44                 mu => mu
45                 .Match(m => m.Field(f => f.Code).Query("888")),
46                 mu => mu
47                 .Bool(bb => bb
48                     .Should(sh => sh
49                         .Match(m => m.Field(f => f.Type).Query("1")),
50                         sh => sh
51                         .Match(m => m.Field(f => f.Type).Query("2")),
52                         sh => sh
53                         .Match(m => m.Field(f => f.Type).Query("3"))
54                     )
55                     .MinimumShouldMatch(1)
56                 )
57             )
58         )
59     )
60 );
61 ```
62 
63 其中，`client` 是一个 `ElasticClient` 对象。`Match` 方法构建一个 `match` 查询，`Should` 方法构建一个 `should` 查询子句，`MinimumShouldMatch` 方法指定至少要满足多少个 `should` 查询子句。其他方法的含义与查询语法中的相同。

 

"minimum_should_match": 1 是什么意思

1 `minimum_should_match` 是在布尔查询中使用的一个参数，用于指定至少需要满足多少个 `should` 查询子句。
2 
3 在 Elasticsearch 中，`bool` 查询是一个组合查询，可包含多个子查询。其中包括 `must` 查询、`should` 查询、`must_not` 查询等。其中，`should` 查询表示只要满足其中一个查询子句即可，而 `minimum_should_match` 参数则可用于指定至少需要满足多少个 `should` 查询子句。其默认值为 1，即至少需要满足一个 `should` 查询子句。
4 
5 例如，"should"查询包含多个分支，每个分支包含一个查询子句。当 `minimum_should_match` 值为 2 时，至少需要满足两个分支中的查询子句。如果只有一个分支满足条件，则查询不返回任何结果。
6 
7 因此，在您的查询语句中， `minimum_should_match` 参数值为 1，表示至少需要满足一个 `should` 查询子句。

 

posted @ 2023-05-25 16:04  南方卖菜  阅读(3035)  评论(0)  编辑  收藏  举报