ES的基本语法

1 基本使用

　　使用kibaba来执行语句

　　es安装和kibaba安装：https://www.cnblogs.com/jthr/p/17075759.html

1）添加PUT

　　已存在会直接覆盖

PUT /myindex/_doc/1
{
  "id":1,
  "name":"手机",
  "price":3888.8,
  "desc":"美国有苹果，中国有菠萝"
}

2）修改POST

POST/myindex/_doc/1
{
  "id":1,
  "name":"手机",
  "price":3888.8,
  "desc":"美国有苹果，中国有菠萝"
}

3）查询GET

GET /jsnh/user/1/

4）删除DELETE

DELETE /jsnh/user/1/

2 查询

2.1 测试数据准备

PUT /product/_doc/1
{
    "name" : "xiaomi phone",
    "desc" :  "shouji zhong de zhandouji",
    "price" :  3999,
    "tags": [ "xingjiabi", "fashao", "buka" ]
}
PUT /product/_doc/2
{
    "name" : "xiaomi nfc phone",
    "desc" :  "zhichi quangongneng nfc,shouji zhong de jianjiji",
    "price" :  4999,
    "tags": [ "xingjiabi", "fashao", "gongjiaoka" ]
}

PUT /product/_doc/3
{
    "name" : "nfc phone",
    "desc" :  "shouji zhong de hongzhaji",
    "price" :  2999,
    "tags": [ "xingjiabi", "fashao", "menjinka" ]
}

PUT /product/_doc/4
{
    "name" : "xiaomi erji",
    "desc" :  "erji zhong de huangmenji",
    "price" :  999,
    "tags": [ "low", "bufangshui", "yinzhicha" ]
}

PUT /product/_doc/5
{
    "name" : "hongmi erji",
    "desc" :  "erji zhong de kendeji",
    "price" :  399,
    "tags": [ "lowbee", "xuhangduan", "zhiliangx" ]
}

2.2 简单查询

1）查询product/_doc下所有

GET /product/_doc/_search

2）简单条件查询

　　返回name中包含xiaomi或者phone的关键字的

　　es采取的是关键字查询索引，xiaomi phone会被分词分为 xiaomi和phone，再去查找索引

GET /product/_doc/_search?q=name:xiaomi phone

3）简单条件+分页排序

　　页码为0，每页为2，安装price排正序

GET /product/_doc/_search?q=name:xiaomi phone&from=0&size=2&sort=price:asc

2.3 复杂查询

2.3.1 查询所有match_all

　　无条件查询所有

    GET /product/_doc/_search
{
  "query":{
    "match_all": {}
  }
}

2.3.2 单字段条件查询match

　　match会对查询条件进行分词处理，得到一些关键字，然后每个关键字去相等匹配，只要有一个匹配到，就可以返回，再根据相关度排序

　　返回name中包含xiaomi或者phone关键字的

        GET /product/_doc/_search
{
  "query":{
    "match": {
      "name":"xiaomi phone"
    }
  }
}

2.3.3 多字段条件匹配multi_match

　　multi_match和match的区别在于，可以对多个字段进行匹配查询

　　查询name字段或desc字段中包含phone关键字的的，multi_match多个字段单条件去匹配

    GET /product/_doc/_search
{
  "query":{
    "multi_match": {
      "query":"phone",
      "fields":["name","desc"]
    }
  }
}

2.3.4 排序sort

    GET /product/_doc/_search
{
  "query":{
    "multi_match": {
      "query":"phone",
      "fields":["name","desc"]
    }
  },
  "sort":{
    "price":"asc"
  }
}

2.3.5 指定返回字段

　　可以指定只返回部分字段，不用全部字段都返回

　　只返回字段name和price

    GET /product/_doc/_search
{
  "query":{
    "multi_match": {
      "query":"phone",
      "fields":["name","desc"]
    }
  },
  "sort":{
    "price":"asc"
  },
  "_source":["name","price"]
}

2.3.6 分页

GET /product/_doc/_search
{
  "query":{
    "multi_match": {
      "query":"phone",
      "fields":["name","desc"]
    }
  },
  "sort":{
    "price":"asc"
  },
  "_source":["name","price"],
  "from":0,
  "size":2
}

2.3.7 不分词查询term

　　查询条件不会被分词，而是整个作为一个关键字去查询

　　获取name包含关键字xiaomi erji的，由于关键字中没有xiaomi erji，只有xiaomi和erji这两个关键字，所以查不到

GET /product/_doc/_search
{
  "query":{
    "term": {
      "name":"xiaomi erji"
    }
  },
  "sort":{
    "price":"asc"
  },
  "_source":["name","price"],
  "from":0,
  "size":2
}

2.3.8 不分词查询terms

　　和term的区别在于，对一个字段可以查询多个条件，满足一个就可以

　　获取name包含关键字包含xiaomi erji或者phone关键字的

    GET /product/_doc/_search
{
  "query":{
    "terms": {
      "name":["hongmi erji","phone"]
    }
  },
  "sort":{
    "price":"asc"
  },
  "_source":["name","price"],
  "from":0,
  "size":2
}

2.3.9 验证分词会怎么分_analyze

　　查询字符串"xiaomi nfc zhineng phone huhu"会被分成哪几个关键词

 GET /_analyze
{
  "analyzer": "standard",
  "text":"xiaomi nfc zhineng phone huhu"
}

2.3.10 短语搜索match_phrase

　　match_phrase还是分词后去搜的

　　目标文档需要包含分词后的所有关键词

　　目标文档还要保持这些词的顺序和文档中的一致

　　添加测试数据

PUT /myindex/_doc/1
{
  "id":1,
  "name":"手机",
  "price":3888.8,
  "desc":"USA has apple China has pineapple"
}
PUT /myindex/_doc/2
{
  "id":1,
  "name":"手机",
  "price":3888.8,
  "desc":"USA has apple China has pear"
}

PUT /myindex/_doc/3
{
  "id":1,
  "name":"手机",
  "price":3888.8,
  "desc":"USA has apple China has pear and pineapple"
}

　　查询

GET /myindex/_search
{
  "query":{
    "match_phrase":{
      "desc":"China has pineapple"
    }
  }
}

　　查询结果，只有一条。说明match_phrase是分词后去查询的，且查询的结果必须包含查询条件的这几个关键词，且顺序连续一致

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 1,
      "relation" : "eq"
    },
    "max_score" : 0.6026137,
    "hits" : [
      {
        "_index" : "myindex",
        "_type" : "mytype",
        "_id" : "1",
        "_score" : 0.6026137,
        "_source" : {
          "id" : 1,
          "name" : "手机",
          "price" : 3888.8,
          "desc" : "USA has apple China has pineapple"
        }
      }
    ]
  }
}

2.4 组合条件查询bool

　　bool标识组合条件

2.4.1 must

　　must标识必须满足的条件

1）查询name中包含xiaomi关键字的并且desc中包含shouji关键字的

{
  "query":{
    "bool":{
      "must":
      [
        {
          "match":{
            "name":"xiaomi"
          }
        },
        {
          "match":{
            "desc":"shouji"
          }
        }
      ]
    }
  }
}

2.4.2 filter

　　filter也是必须满足的条件，和must的区别是不计相关度分数。

1）查询name包含xiaomi关键字的，desc包含shouji关键字的，price大于4000的(这个条件不参与相关度分数的计算)

GET /product/_doc/_search
{
  "query":{
    "bool":{
      "must":
      [
        {
          "match":{
            "name":"xiaomi"
          }
        },
        {
          "match":{
            "desc":"shouji"
          }
        }
      ],
      "filter":[
          {
            "range":{
              "price":{
                "gt":4000
              }
            }
          }
        ]
    }
  }
}

2.4.3 should

　　相当于or匹配

　　minimum_should_match表示shoule中的条件有几个必须满足，可以为0。

　　如果bool查询包含至少一个should子句，而没有must或 filter子句，则默认值为1。否则，默认值为0

1）查询出name包含xiaomi关键字或者desc包含shouji关键字的　

    GET /product/_doc/_search
{
  "query":{
    "bool":{
      "should":
      [
        {
          "match":{
            "name":"xiaomi"
          }
        },
        {
          "match":{
            "desc":"shouji"
          }
        }
      ],
      "minimum_should_match":1
    }
  }
}

2）查询出name包含xiaomi关键字并且desc包含shouji关键字的

    GET /product/_doc/_search
{
  "query":{
    "bool":{
      "should":
      [
        {
          "match":{
            "name":"xiaomi"
          }
        },
        {
          "match":{
            "desc":"shouji"
          }
        }
      ],
      "minimum_should_match":2
    }
  }
}

3）如下，因为存在must，所以minimum_should_match值为0，相当于should里的条件不存在，也就是查询price大于1999的

GET /product/_doc/_search
{
  "query":{
    "bool":{
      "should":
      [
        {
          "match":{
            "name":"xiaomi"
          }
        },
        {
          "match":{
            "desc":"shouji"
          }
        }
      ],
      "must":[
          {
            "range":{
              "price":{
                "gt":1999
              }
            }
          }
        ]
    }
  }
}

4）查询价格大于1999，并且(name包含xiaomi关键字或者desc包含shouji关键字)

GET /product/_doc/_search
{
  "query":{
    "bool":{
      "should":
      [
        {
          "match":{
            "name":"xiaomi"
          }
        },
        {
          "match":{
            "desc":"shouji"
          }
        }
      ],
      "minimum_should_match":1,
      "must":[
          {
            "range":{
              "price":{
                "gt":1999
              }
            }
          }
        ]
    }
  }
}

5）查询价格大于1999，并且(name包含xiaomi关键字，并且desc包含shouji关键字)

GET /product/_doc/_search
{
  "query":{
    "bool":{
      "should":
      [
        {
          "match":{
            "name":"xiaomi"
          }
        },
        {
          "match":{
            "desc":"shouji"
          }
        }
      ],
      "minimum_should_match":2,
      "must":[
          {
            "range":{
              "price":{
                "gt":1999
              }
            }
          }
        ]
    }
  }
}

2.4.4 must not

　　必须不满足，且不计算相关度分数

1）查询价格不能大于4000的，也就是价格小于等于4000的

GET /product/_doc/_search
{
  "query":{
    "bool":{
      "must_not":[
          {
            "range":{
              "price":{
                "gt":4000
              }
            }
          }
        ]
    }
  }
}