elasticsearch的rest搜索--- 查询

目录： 一、针对这次装B 的解释

二、下载，安装插件elasticsearch-1.7.0

　　   三、索引的mapping

　　　四、　查询

　　　五、对于相关度的大牛的文档

四、　查询

1. 查询的官网的文档

    https://www.elastic.co/guide/en/elasticsearch/reference/current/search.html

   

    

    

2.  查询的rest格式

    

 

3.  介绍用过的查询方式

      一般的查询

      http://blog.csdn.net/dm_vincent/article/details/41820537

 

        查询出的数据字段的解释

  - took —— Elasticsearch执行这个搜索的耗时，以毫秒为单位

- timed_out —— 指明这个搜索是否超时
  - _shards —— 指出多少个分片被搜索了，同时也指出了成功/失败的被搜索的shards的数量
  - hits —— 搜索结果
  - hits.total —— 能够匹配我们查询标准的文档的总数目
  - hits.hits —— 真正的搜索结果数据（默认只显示前10个文档）

  - _score和max_score —— 现在先忽略这些字段

    (1) match匹配    

 "query":{
    "match":{
      "UserName":"BWH-PC"
     }
 }

        match是匹配一个key对应的value，value可以是多个，但是必须是这个字段下的，查找多个字段的是不行.

 {
     "query": {
         "match": {
             "text": "quick fox"
         }
     }
 }

相当于

 {
     "query": {
         "bool": {
             "should": [
                 {
                     "term": {
                         "text": "quick"
                     }
                 },
                 {
                     "term": {
                         "text": "fox"
                     }
                 }
             ]
         }
     }
 }

    (2) multi_match 匹配 

 {
     "query": {
         "multi_match": {
             "query": "bbc0641345dd8224ce81bbc79218a16f",
             "operator": "or",
             "fields": [
                 "*.machine"
             ]
         }
     }
 }

        注意：如果没有machine这个字段，就会报错，需要在fields后面添加一个""

                   fields中可以添加*做模糊----fields":  ["f*.name"]【查询的是f开头的】

                    "operator":"or" 指的是对query中的多个值查询方式

                    其中的type的配置报错，需要进一步学习

       (3) bool查询

　　　　

 {
     "bool": {
         "must": {
             "match": {
                 "title": "how to make millions"
             }
         },
         "must_not": {
             "match": {
                 "tag": "spam"
             }
         },
         "should": [
             {
                 "match": {
                     "tag": "starred"
                 }
             },
             {
                 "range": {
                     "date": {
                         "gte": "2014-01-01"
                     }
                 }
             }
         ]
     }
 }

       must：所有分句都必须匹配，与 AND 相同。

       must_not：所有分句都必须不匹配，与 NOT 相同。

       should：至少有一个分句匹配，与 OR 相同。   

      (4) term查询

           (a) 在term查询中，字段是field.name1,那么term不能查，以为"."必须是域  

             "term":{"f1.name":"a1"}-----那么意思是查找的是f1的field下面的name

              但是数据中有"f1.name":"a1" ,那么term是查找不到这个， 所以数据中的key不能有"."

            (b) 在term中查询时候，查询的字段的值不能有大写，但是可以有空格 ---- 对数据中有大写，那么查询用小写，也会匹配到那个值的

　　　　

 "term": {
     "CapabilityDescriptions": "aa"
 }

      (5)不计算存在的次数，判断存在就1分，当然可以指定分数    

 {
     "query": {
         "bool": {
             "should": [
                 {
                     "constant_score": {
                         "query": {
                             "match": {
                                 "description": "wifi"
                             }
                         }
                     }
                 },
                 {
                     "constant_score": {
                         "query": {
                             "match": {
                                 "description": "garden"
                             }
                         }
                     }
                 },
                 {
                     "constant_score": {
                         "boost": {
                             "query": {
                                 "match": {
                                     "description": "pool"
                                 }
                             }
                         }
                     }
                 }
             ]
         }
     }
 }

      (6)   exists 过滤器 相当于is not null

    missing相当于is null

  【没查到的是null】

      (7) 过滤查询---了解到这种过滤会使得查询效率高，而不是单纯的查询完以后的过滤

            当执行 filtered 查询时，filter 会比 query 早执行。结果字节集会被传给 query 来跳过已经被排除的文档。这种过滤器提升性能的方式，查询更少的文档意味着更快的速度。

        (a)query带match     filter带term    【term是精确匹配单个字段 , terms中可以写多个的term】

　　　　

 {
     "query": {
         "filtered": {
             "query": {
                 "match": {
                     "email": "business opportunity"
                 }
             },
             "filter": {
                 "term": {
                     "folder": "inbox"
                 }
             }
         }
     }
 }

        (b)query没有，默认是查询match_all ， fliter中带bool 【bool中再使用match或者match_all，需要用query包】

　　　　

 {
     "query": {
         "filtered": {
             "filter": {
                 "bool": {
                     "must": {
                         "term": {
                             "folder": "inbox"
                         }
                     },
                     "must_not": {
                         "query": {
                             "match": {
                                 "email": "urgent business proposal"
                             }
                         }
                     }
                 }
             }
         }
     }
 }

        (c) tie_breaker ,在标题的网址中去查，是最佳字段的调优，是将匹配度乘以这个值

              tie_breaker的取值范围是0到1之间的浮点数，取0时即为仅使用最佳匹配子句(译注：和不使用tie_breaker参数的dis_max查询效果相同)，取1则会将所有匹配的子句一视同仁。

          它的确切值需要根据你的数据和查询进行调整，但是一个合理的值会靠近0，(比如，0.1 -0.4)，来确保不会压倒dis_max查询具有的最佳匹配性质。

 

        (d)range 过滤器，让你可以根据范围过滤：range过滤器也可以用于日期字段

 　　　

 　"range": {
     　　　　"price": {
         　　　　"gt": 20,
         　　　　"lt": 40
     }
 }

 {
     "query": {
         "filtered": {
             "filter": {
                 "range": {
                     "price": {
                         "gte": 20,
                         "lt": 40
                     }
                 }
             }
         }
     }
 }

 {
     "range": {
         "timestamp": {
             "gt": "2014-01-0100: 00: 00",
             "lt": "2014-01-0700: 00: 00"
         }
     }
 }

到所有最近一个小时的文档:

 {
     "range": {
         "timestamp": {
             "gt": "now-1h"
         }
     }
 }

            (e) 区别于 filtered ，post_filter查询就是先查询，后过滤， 效率没有前面的高 

后置过滤--post_filter元素是一个顶层元素，只会对搜索结果进行过滤。

警告：性能考量

只有当你需要对搜索结果和聚合使用不同的过滤方式时才考虑使用post_filter。有时一些用户会直接在常规搜索中使用post_filter。

不要这样做！post_filter会在查询之后才会被执行，因此会失去过滤在性能上帮助(比如缓存)。

post_filter应该只和聚合一起使用，并且仅当你使用了不同的过滤条件时。

                        ----下面的例子是可以过滤field的，multi_match必须使用query包，

                               match只能过滤没有被“包”的，必须multi_match是过滤被"包"的,

                                query_string中的是全文搜索，是可以查到所有的数据

             eg:查询machine是bbc0641345dd8224ce81bbc79218a16f,不管是否被字段包，都需要过滤出来

 {
     "query": {
         "query_string": {
             "query": "*"
         }
     },
     "post_filter": {
         "bool": {
             "should": {
                 "query": {
                     "bool": {
                         "should": [
                             {
                                 "match": {
                                     "machine": "bbc0641345dd8224ce81bbc79218a16f"
                                 }
                             },
                             {
                                 "match": {
                                     "machine": "bbc0641345dd8224ce81bbc79218a16f"
                                 }
                             }
                         ]
                     }
                 }
             }
         }
     }
 }

　　　　当然，在里面的每一个should中，可以去做很多变形，但是should多个子类时，必须用[]

　　　　

 {
     "query": {
         "query_string": {
             "query": "*"
         }
     },
     "post_filter": {
         "bool": {
             "should": [
                 {
                     "query": {
                         "bool": {
                             "must": [
                                 {
                                     "multi_match": {
                                         "query": "bbc0641345dd8224ce81bbc79218a16f",
                                         "operator": "or",
                                         "fields": [
                                             "*.machine",
                                             ""
                                         ]
                                     }
                                 },
                                 {
                                     "multi_match": {
                                         "query": "10.10.185.99",
                                         "operator": "or",
                                         "fields": [
                                             "*.IPAddress",
                                             ""
                                         ]
                                     }
                                 }
                             ]
                         }
                     }
                 },
                 {
                     "query": {
                         "bool": {
                             "must": [
                                 {
                                     "match": {
                                         "machine": "bbc0641345dd8224ce81bbc79218a16f"
                                     }
                                 },
                                 {
                                     "match": {
                                         "IPAddress": "10.10.11.11"
                                     }
                                 }
                             ]
                         }
                     }
                 }
             ]
         }
     }
 }

            (f) 这是查询中最让人恶心的：查询到结果以后，进行过滤(或者过滤以后进行查询)----其实这种复杂的，直接在query中查，最后在_score中过滤,0.1以下的就是不匹配(同事不让，原因不明，我感觉这很好用)

                          

 

               在一般的过滤中，比如"first":"a1"  那么只能过滤到第二个，不被name包的

                但是有时候，对于field没创建好的情况下，需要"包"，"不包"的都匹配上，就需要使用multi_match和match的联用

                在过滤中可以用match或者multi_match,query_string放的方式用query包

                   eg:查询 last = a2的，不管包还是不包的都要查询出来

　　　　　　

 {
     "query": {
         "filtered": {
             "query": {
                 "query_string": {
                     "query": "*"
                 }
             },
             "filter": {
                 "bool": {
                     "should": {
                         "query": {
                             "bool": {
                                 "should": [
                                     {
                                         "multi_match": {
                                             "query": "a2",
                                             "operator": "or",
                                             "fields": [
                                                 "*.last"
                                             ]
                                         }
                                     },
                                     {
                                         "match": {
                                             "last": "a2"
                                         }
                                     }
                                 ]
                             }
                         }
                     }
                 }
             }
         }
     }
 }

8.   询条件添加以后，进行数量的检索_search?search_type=count