关于elasticsearch:45elasticsearch搜索引擎的bool组合查询

【百度云搜寻，搜各种材料:http://www.lqkweb.com】

【搜网盘，搜各种材料:http://www.swpan.cn】

bool 查问阐明

filter:[], 字段的过滤，不参加打分
must:[], 如果有多个查问，都必须满足【并且】
should:[], 如果有多个查问，满足一个或者多个都匹配【或者】
must_not:[], 相同查问词一个都不满足的就匹配【取反，非】

# bool 查问
# 老版本的 filtered 曾经被 bool 替换
#用 bool 包含 must should must_not filter 来实现
#格局如下：#bool:{#     "filter":[],      字段的过滤，不参加打分
#     "must":[],        如果有多个查问，都必须满足【并且】#     "should":[],      如果有多个查问，满足一个或者多个都匹配【或者】#     "must_not":[],    相同查问词一个都不满足的就匹配【取反，非】#}

建设测试数据

# 建设测试数据
POST jobbole/job/_bulk
{"index":{"_id":1}}
{"salary":10,"title":"python"}
{"index":{"_id":2}}
{"salary":20,"title":"Scrapy"}
{"index":{"_id":3}}
{"salary":30,"title":"Django"}
{"index":{"_id":4}}
{"salary":40,"title":"Elasticsearch"}

bool 组合查问——最简略的 filter 过滤查问之 term 查问，相当于等于

过滤查问到 salary 字段等于 20 的数据

能够看出执行两个两个步骤，先查到所有数据，而后在查到的所有数据过滤查问到 salary 字段等于 20 的数据

# bool 查问
# 老版本的 filtered 曾经被 bool 替换
#用 bool 包含 must should must_not filter 来实现
#格局如下：#bool:{#     "filter":[],      字段的过滤，不参加打分
#     "must":[],        如果有多个查问，都必须满足
#     "should":[],      如果有多个查问，满足一个或者多个都匹配
#     "must_not":[],    相同查问词一个都不满足的就匹配
#}

#简略过滤查问
#最简略的 filter 过滤查问
#如果咱们要查 salary 字段等于 20 的数据
GET jobbole/job/_search
{
  "query": {
    "bool": {                   #bool 组合查问
      "must":{                  #如果有多个查问词，都必须满足
        "match_all":{}          #查问所有字段},
      "filter": {               #filter 过滤
        "term": {               #term 查问，不会将咱们的搜索词进行分词，将搜索词齐全匹配的查问
          "salary": 20          #查问 salary 字段值为 20
        }
      }
    }
  }
}

#简略过滤查问
#最简略的 filter 过滤查问
#如果咱们要查 salary 字段等于 20 的数据
GET jobbole/job/_search
{
  "query": {
    "bool": {
      "must":{"match_all":{}
      },
      "filter": {
        "term": {"salary": 20}
      }
    }
  }
}

bool 组合查问——最简略的 filter 过滤查问之 terms 查问，相当于或

过滤查问到 salary 字段等于 10 或 20 的数据

# bool 查问
# 老版本的 filtered 曾经被 bool 替换
#用 bool 包含 must should must_not filter 来实现
#格局如下：#bool:{#     "filter":[],      字段的过滤，不参加打分
#     "must":[],        如果有多个查问，都必须满足
#     "should":[],      如果有多个查问，满足一个或者多个都匹配
#     "must_not":[],    相同查问词一个都不满足的就匹配
#}

#简略过滤查问
#最简略的 filter 过滤查问
#如果咱们要查 salary 字段等于 20 的数据
#过滤 salary 字段值为 10 或者 20 的数据
GET jobbole/job/_search
{
  "query": {
    "bool": {
      "must":{"match_all":{}
      },
      "filter": {
        "terms": {"salary":[10,20]
        }
      }
    }
  }
}

留神：filter 过滤里也能够用其余根本查问的

_analyze 测试查看分词器解析的后果
analyzer 设置分词器类型 ik_max_word 精细化分词，ik_smart 非精细化分词
text 设置词

#_analyze 测试查看分词器解析的后果
#analyzer 设置分词器类型 ik_max_word 精细化分词，ik_smart 非精细化分词
#text 设置词
GET _analyze
{
  "analyzer": "ik_max_word",
  "text": "Python 网络开发工程师"
}

GET _analyze
{
  "analyzer": "ik_smart",
  "text": "Python 网络开发工程师"
}

bool 组合查问——组合简单查问 1
查问 salary 字段等于 20 或者 title 字段等于 python、salary 字段不等于 30、并且 salary 字段不等于 10 的数据

# bool 查问
# 老版本的 filtered 曾经被 bool 替换
#用 bool 包含 must should must_not filter 来实现
#格局如下：#bool:{#     "filter":[],      字段的过滤，不参加打分
#     "must":[],        如果有多个查问，都必须满足【并且】#     "should":[],      如果有多个查问，满足一个或者多个都匹配【或者】#     "must_not":[],    相同查问词一个都不满足的就匹配【取反，非】#}

# 查问 salary 字段等于 20 或者 title 字段等于 python、salary 字段不等于 30、并且 salary 字段不等于 10 的数据
GET jobbole/job/_search
{
  "query": {
    "bool": {
      "should": [{"term":{"salary":20}},
        {"term":{"title":"python"}}
      ],
      "must_not": [{"term": {"salary":30}},
        {"term": {"salary":10}}]
    }
  }
}

bool 组合查问——组合简单查问 2
查问 salary 字段等于 20 或者 title 字段等于 python、salary 字段不等于 30、并且 salary 字段不等于 10 的数据

# bool 查问
# 老版本的 filtered 曾经被 bool 替换
#用 bool 包含 must should must_not filter 来实现
#格局如下：#bool:{#     "filter":[],      字段的过滤，不参加打分
#     "must":[],        如果有多个查问，都必须满足【并且】#     "should":[],      如果有多个查问，满足一个或者多个都匹配【或者】#     "must_not":[],    相同查问词一个都不满足的就匹配【取反，非】#}

# 查问 title 字段等于 python、或者、(title 字段等于 elasticsearch 并且 salary 等于 30) 的数据
GET jobbole/job/_search
{
  "query": {
    "bool": {
      "should":[{"term":{"title":"python"}},
        {"bool": {
          "must": [{"term": {"title":"elasticsearch"}},
            {"term":{"salary":30}}
          ]
        }}
      ]
    }
  }
}

bool 组合查问——过滤空和非空

# 建设数据
POST bbole/jo/_bulk
{"index":{"_id":"1"}}
{"tags":["search"]}
{"index":{"_id":"2"}}
{"tags":["search","python"]}
{"index":{"_id":"3"}}
{"other_field":["some data"]}
{"index":{"_id":"4"}}
{"tags":null}
{"index":{"_id":"1"}}
{"tags":["search",null]}

解决 null 空值的办法

获取 tags 字段，值不为空并且值不为 null 的数据

# bool 查问
# 老版本的 filtered 曾经被 bool 替换
#用 bool 包含 must should must_not filter 来实现
#格局如下：#bool:{#     "filter":[],      字段的过滤，不参加打分
#     "must":[],        如果有多个查问，都必须满足【并且】#     "should":[],      如果有多个查问，满足一个或者多个都匹配【或者】#     "must_not":[],    相同查问词一个都不满足的就匹配【取反，非】#}

#解决 null 空值的办法
#获取 tags 字段，值不为空并且值不为 null 的数据
GET bbole/jo/_search
{
  "query": {
    "bool": {
      "filter": {
        "exists": {"field": "tags"}
      }
    }
  }
}

获取 tags 字段值为空或者为 null 的数据，如果数据没有 tags 字段也会获取

# bool 查问
# 老版本的 filtered 曾经被 bool 替换
#用 bool 包含 must should must_not filter 来实现
#格局如下：#bool:{#     "filter":[],      字段的过滤，不参加打分
#     "must":[],        如果有多个查问，都必须满足【并且】#     "should":[],      如果有多个查问，满足一个或者多个都匹配【或者】#     "must_not":[],    相同查问词一个都不满足的就匹配【取反，非】#}

#获取 tags 字段值为空或者为 null 的数据，如果数据没有 tags 字段也会获取
GET bbole/jo/_search
{
  "query": {
    "bool": {
      "must_not": {
        "exists": {"field": "tags"}
      }
    }
  }
}