搜索引擎ElasticSearch的简单查询以及高级查询(五)

悠悠 2022-04-10 07:08 231阅读 0赞

一.简单查询:

//查询id为1的数据,请求方式为GET
    127.0.0.1:9200/book/novel/1

二.条件查询:

1.查询全部的数据: 请求方式为post

127.0.0.1:9200/book/_search
    请求参数:
        {
            "query": {
                "match_all": {}
            }
        }

2.指定返回条数:

{
       	"query": {
       		"match_all": {}
       	},
       	"from":1,
       	"size":1  //返回数量
    }

3.根据参数进行条件查询:

{
       	"query": {
       		"match": {    //匹配
       			"word_count":3000
       		}
       	}
    }

4.根据参数查询的同时按照时间降序排列:

{
     	"query": {
     		"match": {
     			"word_count":5000
     		}
     	},
     	"sort": [
     		 {"publish_date": {"order": "desc"}}
     	]
    }

5.聚合查询:

//书籍的信息按照名字进行聚合
    1).单个分组聚合:
        127.0.0.1:9200/book/_search  请求方式: POST
        参数:
            {
            	"aggs": {
            		"group_by_word_count": {
            			"terms": {
            				"field": "word_count"
            			}
            		}
            	}
            }
    聚合信息在最下面,就是统计信息

2).多个分组聚合:

{
      	"aggs": {
      		"group_by_word_count": {
      			"terms": {
      				"field": "word_count"
      			}
      		},
      		"group_by_publish_date":{
      			"terms": {
      				"field": "publish_date"
      			}
      		}
      	}
    }
    最下面显示的是两组聚合信息

3).除了上面的函数还有其他功能函数,比如统计函数:

{
       	"aggs": {
       		"grades_word_count": {
       			"stats": {
       				"field": "word_count"
       			}
       		}
       	}
       }

下面会显示统计信息:

"aggregations": {
              "grades_word_count": {
                  "count": 10,
                  "min": 300,
                  "max": 8000,
                  "avg": 3790,
                  "sum": 37900
              }
      }

当然也可以直接指定获取最小的值的函数,只需要把stats换成min就可以了。

**三.高级查询:**

**方式一.子条件查询: 特定字段查询所指特定值**

**1.Query context:**

在查询的过程中,除了判断文档是否满足查询条件外,ES还会计算一个\_score来表示匹配的程度,旨在判断目标文档和查询条件匹配的有多好常用查询:

**A.全文本查询: 针对文本类型数据**

1).模糊查询
       {
        	"query": {
        		"match": {  会根据java和入门进行匹配
        			"title": "java入门"
        		}
        	}
        }
    2).习语匹配,就是只根据该参数找相应的数据
         {
         	"query": {
         		"match_phrase": {  //match_phrase 习语匹配函数
         			"title": "java入门"
         		}
         	}
         }
    3).多条件查询(查询作者和标题中都有枫的数据)
         {
            "query": {
            	"multi_match": {  //multi_match作为匹配的函数
            		"query": "枫",
            		"fields": ["title","author"]
            	}
            }
         }
    
    4).字符串数据查询:
        {
        	"query": {
        		"query_string": {
        			"query": "java AND 入门" //java AND 入门 表示的就是java入门
        		}
        	}
        }
    5).多字段查询:
        {
        	"query": {
        		"query_string": {
        			"query": "(java AND 入门) OR python"   //查询java或者python都可以
        		}
        	}
        }
    6).query_string查询多个字段:
        查询作者和标题中有小说或者王五的数据
        {
        	"query": {
        		"query_string": {
        			"query": "小说 OR 王五",
        			"fields": ["author","title"]
        		}
        	}
        }

**B.字段级别查询: 针对结构化数据,如数字,日期等**

1).term指定项查询:
        {
        	"query": {
        		"term": {
        			"word_count": 5000  //查询word_count为5000的所有数据
        		}
        	}
        }
    2).范围查询
        {
        	"query": {
        		"range": {     //范围查询函数
        			"word_count": {
        				"gte": 1000,  //大于等于  e表示等于,去掉就表示大于
        				"lte": 5000   //小于等于
        			}
        		}
        	}
        }
    3).时间范围查询:
        {
        	"query": {
        		"range": {
        			"publish_date": {
        				"gte": "2017-01-01",
        				"lte": "2018-12-28"
        			}
        		}
        	}
        }

**2.Filter context:**

在查询的过程中,只判断该文档是否满足条件,只有Yes或者No,而query查询还判断匹配度有多好,数据等只显示word\_count为5000的数据

{
          "query": {
              "bool": {
                  "filter": {
                      "term": {
                          "word_count": 5000
                      }
                  }
              }
          }
    }

**方式二.复合条件查询-以一定的逻辑组合子条件查询**

1.固定分数查询(也就是根据查询到的数据的评分):

{
    	"query": {
    		"constant_score": {
    			"filter":{
    				"match": {
    					"title": "小说"
    				}
    			}
    		}
    	}
    }

2.布尔查询:

1).should只要满足一个就可以,相当于或
    {
        "query": {
             "bool": {
                 "should": [  //应该满足的条件,下面写查询条件,只要满足一个即可
                     {
                         "match": {
                             "author": "王五"
                         }
                     },
                     {
                         "match": {
                             "title": "红楼梦"
                         }
                     }
                 ]
             }
         }
    }
    
    2).must必须满足,相当于与
    {
     	"query": {
     		"bool": {
     			"must": [
     				{
     					"match": {
     						"author": "王五"
     					}
     				},
     				{
     					"match": {
     						"title": "红楼梦"
     					}
     				}
     			]
     		}
     	}
    }
    3).和filter结合使用:
    {
     	"query": {
     		"bool": {
     			"should": [
     				{
     					"match": {
     						"author": "李四"
     					}
     				},
     				{
     					"match": {
     						"title": "红楼梦"
     					}
     				}
     			],
     			"filter": {   //过滤出word_count为2300的数据
     				"term": {
     					"word_count": 2300
     				}
     			}
     		}
       }
    }
    4).must_not和must正好相反:
     {
     	"query": {
     		"bool": {
     			"must_not": {
     				"term": {
     					"author": "王五"
     				}
     			}
     		}
     	}
     }

以上就包含了ElasticSearch所有的查询操作,下面会为大家更新ElasticSearch集成到SpringBoot项目中实战使用。