es查询保存时间大于 es查询超时时间

ES查询超时机制

_search后面指定超时：

GET /_search?timeout=1s

ES中的查询

从es7开始就已经不建议使用type的概念，es8更是直接移除了type的概念，因此查询路径中我们之后都不带中间的type了。。

Query_String

查询全部

product索引，有数据：

GET /product/_search

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 4,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "name" : "nfc phone",
          "desc" : "shouji zhong de hongzhaji",
          "price" : 2999,
          "tags" : [
            "xingjiabi",
            "fashao",
            "menjinka"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 1.0,
        "_source" : {
          "name" : "xiaomi erji",
          "desc" : "erji zhong de huangmenji",
          "price" : 999,
          "tags" : [
            "low",
            "bufangshui",
            "yinzhicha"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "5",
        "_score" : 1.0,
        "_source" : {
          "name" : "hongmi erji",
          "desc" : "erji zhong de kendeji",
          "price" : 399,
          "tags" : [
            "lowbee",
            "xuhangduan",
            "zhiliangx"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "name" : "xiaomi phone",
          "desc" : "shouji zhong de zhandouji",
          "price" : 99999
        }
      }
    ]
  }
}

全文检索匹配

全文检索name字段包含xiaomi：

GET /product/_search?q=name:xiaomi

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 0.45618832,
    "hits" : [
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 0.45618832,
        "_source" : {
          "name" : "xiaomi erji",
          "desc" : "erji zhong de huangmenji",
          "price" : 999,
          "tags" : [
            "low",
            "bufangshui",
            "yinzhicha"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.45618832,
        "_source" : {
          "name" : "xiaomi phone",
          "desc" : "shouji zhong de zhandouji",
          "price" : 99999
        }
      }
    ]
  }
}

全文检索所有字段内容拼在一起是否包含xiaomi：

GET /product/_search?q=xiaomi

排序

ES默认按照_score的高低进行排序，如果指定排序，可通过sort进行指定：
根据price正序排序

GET /product/_search?sort=price:asc

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 4,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "5",
        "_score" : null,
        "_source" : {
          "name" : "hongmi erji",
          "desc" : "erji zhong de kendeji",
          "price" : 399,
          "tags" : [
            "lowbee",
            "xuhangduan",
            "zhiliangx"
          ]
        },
        "sort" : [
          399
        ]
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : null,
        "_source" : {
          "name" : "xiaomi erji",
          "desc" : "erji zhong de huangmenji",
          "price" : 999,
          "tags" : [
            "low",
            "bufangshui",
            "yinzhicha"
          ]
        },
        "sort" : [
          999
        ]
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : null,
        "_source" : {
          "name" : "nfc phone",
          "desc" : "shouji zhong de hongzhaji",
          "price" : 2999,
          "tags" : [
            "xingjiabi",
            "fashao",
            "menjinka"
          ]
        },
        "sort" : [
          2999
        ]
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : null,
        "_source" : {
          "name" : "xiaomi phone",
          "desc" : "shouji zhong de zhandouji",
          "price" : 99999
        },
        "sort" : [
          99999
        ]
      }
    ]
  }
}

发现，_score属性的值没了。。因为ES知道你使用了某种排序，因此_score就没啥意义了。

分页

在此基础上，进行分页，返回索引为0开始，2条数据。

GET /product/_search?from=0&size=2&sort=price:asc

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 4,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "5",
        "_score" : null,
        "_source" : {
          "name" : "hongmi erji",
          "desc" : "erji zhong de kendeji",
          "price" : 399,
          "tags" : [
            "lowbee",
            "xuhangduan",
            "zhiliangx"
          ]
        },
        "sort" : [
          399
        ]
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : null,
        "_source" : {
          "name" : "xiaomi erji",
          "desc" : "erji zhong de huangmenji",
          "price" : 999,
          "tags" : [
            "low",
            "bufangshui",
            "yinzhicha"
          ]
        },
        "sort" : [
          999
        ]
      }
    ]
  }
}

Query DSL

查询全部（match_all）

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

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 4,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "name" : "nfc phone",
          "desc" : "shouji zhong de hongzhaji",
          "price" : 2999,
          "tags" : [
            "xingjiabi",
            "fashao",
            "menjinka"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 1.0,
        "_source" : {
          "name" : "xiaomi erji",
          "desc" : "erji zhong de huangmenji",
          "price" : 999,
          "tags" : [
            "low",
            "bufangshui",
            "yinzhicha"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "5",
        "_score" : 1.0,
        "_source" : {
          "name" : "hongmi erji",
          "desc" : "erji zhong de kendeji",
          "price" : 399,
          "tags" : [
            "lowbee",
            "xuhangduan",
            "zhiliangx"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "name" : "xiaomi phone",
          "desc" : "shouji zhong de zhandouji",
          "price" : 99999
        }
      }
    ]
  }
}

全文检索匹配（match）

匹配name中包含erji的记录：

GET /product/_search
{
  "query": {
    "match": {
      "name": "erji"
    }
  }
}

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 1.0630728,
    "hits" : [
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : 1.0630728,
        "_source" : {
          "name" : "xiaomi erji",
          "desc" : "erji zhong de huangmenji",
          "price" : 999,
          "tags" : [
            "low",
            "bufangshui",
            "yinzhicha"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "5",
        "_score" : 1.0630728,
        "_source" : {
          "name" : "hongmi erji",
          "desc" : "erji zhong de kendeji",
          "price" : 399,
          "tags" : [
            "lowbee",
            "xuhangduan",
            "zhiliangx"
          ]
        }
      }
    ]
  }
}

排序（sort）

对上面全文检索出来的数据，进行根据price进行正序排序：

GET /product/_search
{
  "query": {
    "match": {
      "name": "erji"
    }
  },
  "sort": [
    {
      "price": {
        "order": "asc"
      }
    }
  ]
}

{
  "took" : 0,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : null,
    "hits" : [
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "5",
        "_score" : null,
        "_source" : {
          "name" : "hongmi erji",
          "desc" : "erji zhong de kendeji",
          "price" : 399,
          "tags" : [
            "lowbee",
            "xuhangduan",
            "zhiliangx"
          ]
        },
        "sort" : [
          399
        ]
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "4",
        "_score" : null,
        "_source" : {
          "name" : "xiaomi erji",
          "desc" : "erji zhong de huangmenji",
          "price" : 999,
          "tags" : [
            "low",
            "bufangshui",
            "yinzhicha"
          ]
        },
        "sort" : [
          999
        ]
      }
    ]
  }
}

多字段全文检索匹配（multi_match）

在name和desc中查询包含“zhong”的记录：

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

分页

根据price倒序，从索引为0的数据开始，查询1条出来。

GET /product/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "price": {
        "order": "desc"
      }
    }
  ], 
  "from": 0,
  "size": 1
 
}

关于全文检索

term

搜索关键词，不会进行分词

GET /product/_search
{
  "query": {
    "term": {
      "name": {
        "value": "nfc phone"
      }
    }
  }
 
}

term和match的区别？

match会对关键词进行分词，例如上面的“nfc phone” 会分词为“nfc”和“phone”：

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

{
  "tokens" : [
    {
      "token" : "nfc",
      "start_offset" : 0,
      "end_offset" : 3,
      "type" : "<ALPHANUM>",
      "position" : 0
    },
    {
      "token" : "phone",
      "start_offset" : 4,
      "end_offset" : 9,
      "type" : "<ALPHANUM>",
      "position" : 1
    }
  ]
}

而term则不进行分词，直接拿“nfc phone”去匹配，
因此上面的term查询，实际是无法查询到数据的，因为虽然关键词不分词，但是es中的实际字段内容也是会进行分词的：
也就是说，字段内容为““nfc phone””会分词为“nfc”和“phone”， 但此时term是拿着“nfc phone”去匹配，自然匹不到东西了。。。

有没有办法使用term查询记录为“nfc phone”呢？
当然，使用terms：

terms

GET /product/_search
{
  "query": {
    "terms": {
      "name": [
        "nfc",
        "phone"
      ]
    }
  }
 
}

terms就是去匹配字段内容分词为“nfc”或者“phone”的，类似于mysql的in操作，这样便可以实现类似match的效果了。。

{
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "name" : "nfc phone",
          "desc" : "shouji zhong de hongzhaji",
          "price" : 2999,
          "tags" : [
            "xingjiabi",
            "fashao",
            "menjinka"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "name" : "xiaomi phone",
          "desc" : "shouji zhong de zhandouji",
          "price" : 99999
        }
      }
    ]
  }
}

短语检索

GET /product/_search
{
  "query": {
    "match_phrase": {
      "name": "nfc phone"
    }
  }
}

类似于match，match_phrase还是分词后去搜的，但不同的是：
1、目标文档需要包含分词后的所有词
2、目标文档还要保持这些词的相对顺序和文档中的一致

效果有点像mysql的like查询。。

查询和过滤（Query and filter）

bool

可以组合多个查询条件，bool查询也是采用more_matches_is_better的机制，因此满足must和should子句的文档将会合并起来计算分值。

1、must

必须满足 and
子句（查询）必须都能在文档中进行匹配成功

name必须包含xiaomi，且price大于2999的

GET /product/_search
{
  "query": {
    "bool": {
    "must": [
      {
        "match": {
          "name": "xiaomi"
        }
      },
      {
        "range": {
          "price": {
            "gte": 2999
          }
        }
      }
    ]
    }
  }
}

2、 filter

过滤器 不计算相关度分数，cache☆
子句（查询）必须都能在文档中进行匹配成功。但是相比must查询，filter中的子句的分数将被忽略（不进行计算分数），因此相比must效率更高。

Filter子句在filter上下文中执行，这意味着计分被忽略，并且子句被考虑用于缓存。

price大于999的：

GET /product/_search
{
  "query": {
    "bool": {
    "filter": [
      {"range": {
        "price": {
          "gt": 999
        }
      }}
    ]
    }
  }
}

一般可以先通过filter筛选出数据集，然后再去match匹配这堆数据集，得到最终的结果，而实际上，我们的分数排名计算也只想针对于这些结果集，而非全部数据。
接下来看一个案例：
首先筛选name包含“xiaomi phone”并且价格大于1999的数据（不排序，不计算分数），然后搜索name包含“xiaomi”and desc 并且包含“shouji”的

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

3、 should

可能满足 or
至少需要minimum_should_match个子句（查询）匹配成功。

name包含erji或者xiaomi：

GET /product/_search
{
  "query": {
    "bool": {
    "should": [
      {"match": {
        "name": "erji"
      }},{
        "match": {
          "name": "xiaomi"
        }
      }
    ]
    }
  }
}

4、must_not

必须不满足 不计算相关度分数 not
子句（查询）全都不得出现在匹配的文档中。子句在过滤器上下文中执行，这意味着计分被忽略，并且子句被视为用于缓存。由于忽略计分，因此将返回所有文档的分数都为0。

匹配name既不包含“erji”也不包含“hongzhaji”的记录

GET /product/_search
{
  "query": {
    "bool": {
    "must_not": [
      {
        "match": {
          "name": "erji"
        }
      },
      {
        "match": {
          "name": "hongzhaji"
        }
      }
    ]
    }
  }
}

{
  "took" : 4,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 5,
      "relation" : "eq"
    },
    "max_score" : 0.0,
    "hits" : [
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 0.0,
        "_source" : {
          "name" : "nfc phone",
          "desc" : "shouji zhong de hongzhaji",
          "price" : 2999,
          "tags" : [
            "xingjiabi",
            "fashao",
            "menjinka"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "1",
        "_score" : 0.0,
        "_source" : {
          "name" : "xiaomi phone",
          "desc" : "shouji zhong de zhandouji",
          "price" : 99999
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "MQhVI3IBIohknZNBAh6y",
        "_score" : 0.0,
        "_source" : {
          "name" : "balala nfc phone",
          "desc" : "shouji zhong de hongzhaji",
          "price" : 12999,
          "tags" : [
            "ff",
            "we",
            "asd"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "MghbI3IBIohknZNBIB4B",
        "_score" : 0.0,
        "_source" : {
          "name" : "phone nfc",
          "desc" : "shouji zhong de hongzhaji",
          "price" : 12999,
          "tags" : [
            "ff",
            "we",
            "asd"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "MwheI3IBIohknZNB-R4G",
        "_score" : 0.0,
        "_source" : {
          "name" : " nfc bbb phone",
          "desc" : "shouji zhong de hongzhaji",
          "price" : 12999,
          "tags" : [
            "ff",
            "we",
            "asd"
          ]
        }
      }
    ]
  }
}

5、 minimum_should_match

should子句最少需要满足匹配的个数或百分比，如果bool查询包含至少一个should子句，而没有must或 filter子句，此时该值为1，否则，该值为0（此时should中的任何子句没有匹配都可以）

这里同时存在must和should，minimum_should_match默认值为0，此时即使should一条都没匹上，只要must匹上了，就可以匹上

GET /product/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "erji"
          }
        }
      ], 
    "should": [
      {"match": {
        "name": "sdgsdag"
      }},{
        "match": {
          "name": "qweqwt"
        }
      }
    ]
    }
  }
}

但如果手动设置minimum_should_match，则此时需要should也要至少满足1个子句能够匹配：

GET /product/_search
{
  "query": {
    "bool": {
      "filter": [
        {
          "range": {
            "price": {
              "gt": 2999
            }
          }
        }
      ], 
    "should": [
      {"match": {
        "name": "sdgsdag"
      }},{
        "match": {
          "name": "qweqwt"
        }
      }
    ],
    "minimum_should_match": 1
    }
  }
}

评分的计算规则

bool 查询会为每个文档计算相关度评分 _score ， 再将所有匹配的 must 和 should 语句的分数 _score 求和，
最后除以 must 和 should 语句的总数。
must_not 语句不会影响评分； 它的作用只是将不相关的文档排除

组合查询（Compound queries）

① 想要name包含 “nfc” 或者 “xiaomi”的产品， 但是不要包含“erji”
SELECT * from product
where (name like “%xiaomi%” or name like ‘%nfc%’)
AND name not LIKE ‘%erji%’

缓存查询

这里使用了filter缓存查询的特性，如果整体都想使用filter做缓存查询,而不计算分数的话：

GET /product/_search
{
  "query": {
    "constant_score":{
      "filter": {
        "bool": {
          "should":[
            {"term":{"name":"xiaomi"}},
            {"term":{"name":"nfc"}}
            ],
          "must_not":[
            {"term":{"name":"erji"}}
            ]
        }
      },
      "boost": 1.2 //给一个固定分数
    }
  }
}

② 搜索一台name包含“xiaomi nfc phone”或者一台name包含"phone" 并且 price小于等于2999

SELECT * FROM product
WHERE NAME LIKE '%xiaomi nfc phone%'
OR (
NAME LIKE '%erji%'
AND price > 399
AND price <=999);

嵌套查询

这里用到了嵌套查询，也就是子句里可以继续放入bool来实现复杂查询：

GET /product/_search
{
  "query": {
    "constant_score": {
      "filter": {
        "bool":{
          "should":[
            {"match_phrase":{"name":"xiaomi nfc phone"}},
            {
              "bool":{
                "must":[
                  {"term":{"name":"phone"}},
                  {"range":{"price":{"lte":"2999"}}}
                  ]
              }
            }
          ]
        }
      }
    }
  }
}

高亮查询（Highlight search）

匹配包含“nfc phone”句子的文档，并将匹配到的对应文档的name内容的关键词进行高亮“

GET /product/_search
{
    "query" : {
        "match_phrase" : {
            "name" : "nfc phone"
        }
    },
    "highlight":{
      "fields":{
         "name":{}
      }
    }
}

{
  "took" : 352,
  "timed_out" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "hits" : {
    "total" : {
      "value" : 2,
      "relation" : "eq"
    },
    "max_score" : 0.94048226,
    "hits" : [
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "3",
        "_score" : 0.94048226,
        "_source" : {
          "name" : "nfc phone",
          "desc" : "shouji zhong de hongzhaji",
          "price" : 2999,
          "tags" : [
            "xingjiabi",
            "fashao",
            "menjinka"
          ]
        },
        "highlight" : {
          "name" : [
            "<em>nfc</em> <em>phone</em>"
          ]
        }
      },
      {
        "_index" : "product",
        "_type" : "_doc",
        "_id" : "MQhVI3IBIohknZNBAh6y",
        "_score" : 0.79284847,
        "_source" : {
          "name" : "balala nfc phone",
          "desc" : "shouji zhong de hongzhaji",
          "price" : 12999,
          "tags" : [
            "ff",
            "we",
            "asd"
          ]
        },
        "highlight" : {
          "name" : [
            "balala <em>nfc</em> <em>phone</em>"
          ]
        }
      }
    ]
  }
}

扩展查询

响应内容查询

pretty

可以在查询url后面添加pretty参数，使得返回的json更易查看。

只返回原始数据

如不需要返回元数据，仅仅返回原始数据，可以这样：

GET /index/type/id/_source

例子：

GET /product/_doc/1/_source

{
  "_index" : "product",
  "_type" : "1",
  "_id" : "_source",
  "found" : false
}

指定查询只返回某些字段

只查询name，price字段信息：（DSL版本）

GET /product/_search
{
  "query": {
    "match_all": {}
  },
  "_source": ["name","price"]
 
}

（query string版本）：

GET /product/_doc/_search?_source=name,price

查询对应文档是否存在

通常来说，一条数据是否存在我们需要通过查询数据，然后如果能查到就说明存在。
那有没有更优的方法？
使用HEAD请求方式，去请求数据

HEAD /product/_doc/3

如果存在返回200：

200 - OK

如果不存在404：

404 - Not Found

这样无需查询返回数据，只需通过状态码就可判断了。

批量操作

批量查询

为了减少网络传输次数，可以批量进行获取操作：

GET /product/_mget
{
  "ids":[1,3,"balala"]
}

上面我指定了3个id，其中”balala“是不存在的

{
  "docs" : [
    {
      "_index" : "product",
      "_type" : "_doc",
      "_id" : "1",
      "_version" : 3,
      "_seq_no" : 6,
      "_primary_term" : 1,
      "found" : true,
      "_source" : {
        "name" : "xiaomi phone",
        "desc" : "shouji zhong de zhandouji",
        "price" : 99999
      }
    },
    {
      "_index" : "product",
      "_type" : "_doc",
      "_id" : "3",
      "_version" : 1,
      "_seq_no" : 2,
      "_primary_term" : 1,
      "found" : true,
      "_source" : {
        "name" : "nfc phone",
        "desc" : "shouji zhong de hongzhaji",
        "price" : 2999,
        "tags" : [
          "xingjiabi",
          "fashao",
          "menjinka"
        ]
      }
    },
    {
      "_index" : "product",
      "_type" : "_doc",
      "_id" : "balala",
      "found" : false
    }
  ]
}

通过查询结果可以发现，能匹配到的所有数据会返回，并且有一个found字段，而匹配不到，也会返回一条信息，但是found为false

当然，可以不仅仅那么简单，还可以指定每个文档的返回字段：

只包含某个字段：

除去某个字段外都要：

_bulk操作

在Elasticsearch中，支持批量的插入、修改、删除操作，都是通过_bulk的api完成的。
请求格式如下：（请求格式不同寻常）
语法格式：

POST /index名称/_bulk
{ action: { metadata }}\n
{ request body    }\n
{ action: { metadata }}\n
{ request body    }\n

…

批量插入数据：（注意最后一行的回车。）

POST /product/_bulk
{"create":{"_index":"product","_id":2001}}
{"id":2001,"name":"name1","price":1}
{"create":{"_index":"product","_id":2002}}
{"id":2002,"name":"name2","price":2}
{"create":{"_index":"product","_id":2003}}
{"id":2003,"name":"name3","price":3}

批量删除数据：（由于delete没有请求体，所以，action的下一行直接就是下一个action。）

POST /product/_bulk
{"delete":{"_index":"product","_id":2001}}
{"delete":{"_index":"product","_id":2002}}
{"delete":{"_index":"product","_id":2003}}

批量操作之间可以组合使用，并且每一条的执行结果不会相互影响。

批量更新数据

retry_on_conflict 更新发生冲突时，重试次数（ES使用的是乐观锁机制来处理并发下的数据问题，更新时使用自身version与目标数据version要进行比对，只有等于自身的version才能更新）

index（可是是替换，也可以是创建）

批量操作相比于json体语法操作，效率更高，json体语法会将查询体序列化成对象放到内存，而批量操作不需要。

filter_path

有时我们只想得到失败的信息，而不关心成功的信息，此时可以加上filter_path来只过滤出错误信息：

EXIST

exists 查询可以用于查找文档中是否包含指定字段或没有某个字段，类似于SQL语句中的 IS_NULL 条件

筛选出文档中tags字段不为null的数据：

GET /product/_search
{
  "query": {
    "exists": {
      "field": "tags"
    }
  }
}

结合上面的bool查询，可以这样查询tags字段为null的数据：

GET /product/_search
{
  "query": {
    "bool": {
      "must_not": [
        {"exists": {"field": "tags"}}
      ]
    }
    
  }
}

ES全文检索分词的相对关系

默认来说，es对于match操作，会把查询内容分词后的 任一分词 命中的文档进行返回，也就是分词之间的关系是 or

如下： 查询name中包含xiaomi 或者 erji 的文档

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

那如果想要分词之间的关系是and关系呢？ 也就是必须都包含的才行
只需要这样写就行了：

GET /product/_search
{
  "query": {
    "match": {
      "name": {
        "operator": "and",
        "query": "xiaomi erji"
      }
    }
  }
}

相似度匹配

上面我们测试了全文检索中“OR” 和 “AND”搜索，这是两个极端，其实在实际场景中，并不会选取这2个极端，更有可能是选取只需要符合一定的相似度就可以查询到数据，在Elasticsearch中也支持这样的查询，通过
minimum_should_match来指定匹配度，如：70%；

GET /itcast2/_search
{
  "query": {
    "match": {
      "hobby": {
        "minimum_should_match": "70%" //这里写匹配个数或者匹配相似度百分比, 
        "query": "羽毛球 乒乓球"
      }
    }
    
  }
}

相似度应该多少合适，需要在实际的需求中进行反复测试，才可得到合理的值。

权重

如果文档字段内容包含篮球，则额外增加5的评分权重：

GET /itcast2/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "hobby": {
              "operator": "and",
              "query": "羽毛球足球"
            }
          }
        }
      ],
      "should": [
        {
          "match": {
            "hobby": {
              "query": "篮球",
              "boost": 5
            }
          }
        }
      ]
    }
  }
}