本節內容會詳細介紹一些查詢操作過程中經常或者可能使用到一些 api。

查詢行為分類

查詢子句的行為取決于它是在 query context 中使用還是在 filter context 中使用：

查詢：query context 中，query 子句可以評估文檔與查詢子句的匹配程度。同時，計算出一個表示兩者匹配程度的分數 score。
過濾：filter context 中，query 子句僅判斷文檔是否與此 query 子句匹配，不計算分數。

Match All Query

最簡單的查詢，匹配所有文檔，所有文檔的分數均為 1.0。

語法：

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match_all": { }
    }
}

# 匹配所有文檔查詢
curl -XGET "localhost:9200/match_all_index/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "match_all": { }
    }
}'

{
  "took" : 181,
  "timed_out" : false,
  "terminated_early" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "_clusters" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0
  },
  "hits" : {
    "total" : 1,
    "max_score" : null,
    "hits" : [
      {
        "_index" : "match_all_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : null,
        "_source" : {
          "msg" : "no scheme",
          "url_address" : "developer.mozilla.org/en-US/search?q=URL"
        }
      }
    ]
  }
}

# 使用 boost 參數更改分數
curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match_all": { "boost" : 1.2 }
    }
}

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 1.2,
    "hits" : [
      {
        "_index" : "match_all_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : 1.2,
        "_source" : {
          "msg" : "no scheme",
          "url_address" : "developer.mozilla.org/en-US/search?q=URL"
        }
      }
    ]
  }
}

full text queries

Match Query

match query 可以查詢文本/數字/日期類型的數據。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match": { "message": "this is a test" }
    }
}

注意，message 是一個字段的名稱，你可以用任何字段的名稱來代替。

curl -XGET "localhost:9200/match_query_index/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "match": { "url_address": "https://developer.mozilla.org" }
    }
}'

{
  "took" : 112,
  "timed_out" : false,
  "terminated_early" : false,
  "_shards" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0,
    "failed" : 0
  },
  "_clusters" : {
    "total" : 1,
    "successful" : 1,
    "skipped" : 0
  },
  "hits" : {
    "total" : 1,
    "max_score" : 1.0893298,
    "hits" : [
      {
        "_index" : "match_query_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : 1.0893298,
        "_source" : {
          "msg" : "no scheme",
          "url_address" : "developer.mozilla.org/en-US/search?q=URL"
        }
      }
    ]
  }
}

參數說明

match query 對所提供的文本進行分析，根據所提供的文本構造一個布爾查詢，屬于一種布爾類型查詢。

operator 參數：可以設置為 OR 或 AND 來控制布爾子句（默認為 OR），通過 operator 參數可以控制匹配關系。匹配的可選 should 子句的最小數量可以使用 minimum_should_match 參數來設置。下面是一個提供額外參數的示例（注意結構上的變化，message 是字段名）:
```
curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match": {
            "message": { "query" : "this is a test"，
                         "operator" : "AND" }
        }
    }
}
```
analyzer 參數：可以設置為控制哪個 analyzer 將對文本執行分析過程。默認的 analyzer 是字段中的 mapping 顯式定義的 analyzer 或 default search analyzer。

lenient 參數：可設置為 true，以忽略由數據類型不匹配引起的異常，例如嘗試使用文本查詢去查詢數字字段。默認值為 false。
Fuzziness 參數

fuzziness 參數允許基于被查詢字段的類型進行模糊匹配。在這種情況下，可以設置 prefix_length 和 max_expansion 來控制模糊過程。

注意，模糊匹配不適用于具有同義詞的詞項。
```
curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match": {
            "message": { "query" : "this is a test"，
                         "fuzziness" : "AUTO" }
        }
    }
}
```

zero term query 參數

如果所使用的 analyzer 刪除了查詢中的所有詞元，則不會匹配到任何文檔。為了改變 zero_terms_query 參數的使用，它的默認值是 none，若設置為 all 則對應于 match_all 查詢。
```
curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match": {
            "message": { "query" : "this is a test"，
                         "zero_terms_query": "all" }
        }
    }
}
```

Match Phrase Query

match_phrase 查詢分析文本并根據分析的文本創建一個短語查詢。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match_phrase": { "message": "this is a test" }
    }
}

curl -X GET "localhost:9200/match_phrase_index/_search?&pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "match_phrase": { "mtext": "Brown fox" }
   }
}'

{
  ...
  "hits" : {
    "total" : 2,
    "max_score" : 0.19932948,
    "hits" : [
      {
        "_index" : "match_phrase_index",
        "_type" : "default_type_",
        "_id" : "2",
        "_score" : 0.19932948,
        "_source" : {
          "mtext" : "Brown fox eat rabbits",
          "mkeyword" : "Brown fox eat rabbits"
        }
      },
      {
        "_index" : "match_phrase_index",
        "_type" : "default_type_",
        "_id" : "1",
        "_score" : 0.1325215,
        "_source" : {
          "mtext" : "The 2 QUICK Brown-Foxes jumped over the lazy dog's Bone.",
          "mkeyword" : "The 2 QUICK Brown-Foxes jumped over the lazy dog's Bone."
        }
      }
    ]
  }
}

slop 用于指定查詢短語間的詞項（term）間的距離，默認值是 0；analyzer 參數可以設置哪個 analyzer 將對文本執行分析過程；與 match query 一樣，match phrase query 也可以接受 zero_terms_query 。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match_phrase": {
            "message": { "query": "quick brown",
                         "slop": 10 }
        }
    }
}

Match Phrase Prefix Query

match phrase prefix query 與 match phrase query 相同，但是它多了一個特性，它允許對文本中的最后一個詞進行前綴匹配。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match_phrase_prefix": {
            "message": "quick brown f"
        }
    }
}

curl -X GET "localhost:9200/match_phrase_prefix_index/_search?&pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "match_phrase_prefix": {
            "mtext": {"query": "quick brown f"}
        }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 3.2995868,
    "hits" : [
      {
        "_index" : "match_phrase_prefix_index",
        "_type" : "default_type_",
        "_id" : "1",
        "_score" : 3.2995868,
        "_source" : {
          "mtext" : "The 2 QUICK Brown-Foxes jumped over the lazy dog's Bone.",
          "mkeyword" : "The 2 QUICK Brown-Foxes jumped over the lazy dog's Bone."
        }
      }
    ]
  }
}

match phrase prefix 的 max_expansion 參數可以控制最后一項將擴展多少個后綴。建議將其設置為可接受的值以控制查詢的執行時間。以 quick brown f 查詢為例，它會先查找第一個與前綴 f 匹配的詞，然后依次查找搜集與之匹配的詞（按字母順序），直到沒有更多可匹配的詞或當數量超過 max_expansions 時結束。但是 max_expansions 是作用在分片級別（shard level）的，這意味著即使設置為 1，依然有可能匹配到多個詞。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "match_phrase_prefix": {
            "message": { "query": "quick brown f",
                         "max_expansions": 2 }
        }
    }
}

match phrase prefix query 非常容易使用，可以快速地開始搜索，但它的結果有時可能會不盡人意。

考慮查詢字符串 quick brown f。該查詢通過創建一個由 quick 和 brown 組成的查詢語句來進行查詢（即 quick 必須存在，并且必須后面跟著 brown）。然后，它查看排序后的詞項字典，找到以 f 開頭的前 50 個詞項，并將這些詞項添加到短語查詢中。

問題是前 50 個詞項中可能不包括 fox，這樣短語 quick brown fox 就不會被查到。可以通過繼續輸入更多的字母的方法找到要找到的結果。

Multi Match Query

multi match query 建立在 match query 的基礎上，允許多字段查詢:

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : { "query": "this is a test",
                          "fields": [ "subject", "message" ] }
    }
}

curl -X GET "localhost:9200/multi_match_index/_search?pretty" -H 'Content-Type: application/json' -d'{
    "query": {
        "multi_match" : { "query": "mouse",
                          "fields": [ "lastname", "abstract" ] }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 1.8032517,
    "hits" : [
      {
        "_index" : "multi_match_index",
        "_type" : "default_type_",
        "_id" : "4",
        "_score" : 1.8032517,
        "_source" : {
          "firstname" : "Industrious",
          "abstract" : "mouse eat rices",
          "title" : "mouse are also Pets",
          "content" : "Why hamster is a pet, mouse is not a pet",
          "lastname" : "Dark"
        }
      }
    ]
  }
}

fields and per-field boosting

可以使用通配符指定字段

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : { "query": "Will Smith",
                          "fields": [ "title", "*_name" ] }
    }
}

單個字段可以使用符號(^)來增強，下面的例子表示 subject 字段的重要性是 message 字段的三倍。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : { "query" : "this is a test",
                          "fields" : [ "subject^3", "message" ] }
    }
}

如果沒有提供字段，multi match query 默認為 "." 會將所有字段組合起來以構建一個查詢。

Types of multi_match query

multi match query 在內部執行的方式取決于 type 參數，它可以設置為:
- best_fields：（默認值）查找匹配任何字段的文檔，但取最大的匹配的score。
- most_fields：查找匹配任意字段的文檔，并把每個字段的score相加。
- cross_fields：用相同的analyzer處理字段，查找任何領域的每個單詞。
- phrase：對每個字段進行match phrase query，并取最大的匹配的score。
- phrase_prefix：對每個字段運行一個match phrase prefix query，并將每個字段的score相加。

best_fields

best_fields 類型為每個字段生成一個匹配查詢，以找到唯一的最佳匹配字段。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : {"query": "brown fox",
                         "type": "best_fields",
                         "fields": [ "subject", "message" ] }
    }
}

most_fields

與 best_fields 不同之處在于相關性評分，best_fields 取最大匹配得分（max 計算），而 most_fields 取所有匹配之和（sum 計算）。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : { "query": "quick brown fox",
                          "type": "most_fields",
                          "fields": [ "title", "title.original", "title.shingles" ] }
    }
}

相當于執行以下查詢語句：

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "bool": {
            "should": [ { "match": { "title":          "quick brown fox" }},
                        { "match": { "title.original": "quick brown fox" }},
                        { "match": { "title.shingles": "quick brown fox" }} ]
        }
    }
}

phrase and phrase_prefix

phrase 和 phrase_prefix 與 best_fields 類似，但它們使用的是 match_phrase query 或 match_phrase_prefix query，而不是 match query。

*curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : { "query": "quick brown f",
                          "type": "phrase_prefix",
                          "fields": [ "subject", "message" ]
        }
    }
}

cross_fields

cross_fields 對于需要匹配多個字段的結構化文檔特別有用。例如，當查詢 "Will Smith" 的 first_name 和 last_name 字段時，最好的匹配是一個字段中有 "Will"，另一個字段中有 "Smith"。

但是這種方法有個問題，與相關性有關：first_name 和 last_name 字段中的詞項頻率不同，可能會產生意想不到的結果。例如，假設有兩個人："Will Smith" 和 "Smith Jones"。"Smith" 作為 last_name 是很常見的（因此不太重要），但 "Smith" 作為 first_name 是很少見的(因此很重要)。如果搜索 "Will Smith"，"Smith Jones" 文檔可能會出現在更匹配的 "Will Smith" 之上，因為 first_name: Smith 的分數超過了 first_name: Will + last_name: Smith 的分數之和。

處理這類查詢的一種方法是將 first_name 和 last_name 字段索引到單個 full_name 字段中。當然，這只能在創建索引時完成。

cross_field 試圖在查詢時解決這些問題。它首先將查詢字符串分析為單個詞項，然后在任何字段中查找每個詞項，就像它們是一個大字段一樣。
```
curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "multi_match" : { "query": "Will Smith",
                          "type": "cross_fields",
                          "fields": [ "first_name", "last_name" ],
                          "operator": "and" }
    }
}
```

Term level queries

Term Query

term query 查找包含倒排索引中指定的準確詞項的文檔。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "term" : {
            "user" : { "value": "Kimchy" }
        }
    }
}

curl -XGET "localhost:9200/term_query_index/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "term": {
            "url_address": { "value": "https://www.google.com/" }
        }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 0.28004453,
    "hits" : [
      {
        "_index" : "term_query_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : 0.28004453,
        "_source" : {
          "msg" : "long",
          "url_address" : "https://www.google.com/search?q=url&sxsrf=APq-WBvQC6by6yojrKX42LpO9KpY5IEiBw%3A1646378551496"
        }
      }
    ]
  }
}

可以指定一個 boost 參數來給這個查詢一個比其他查詢更高的相關性評分。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "term": { "name": "Charlie Paul"
                  "boost": 3.0 }
    }
}

Terms Query

terms query 可以實現將一個字段，從多個 value 中檢索的效果，

類似于 sql 語句中的 in。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "terms" : { "user" : ["kimchy", "Scope"] }
    }
}

curl -XGET "localhost:9200/search_index/_search?&pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "terms": { "name.keyword": ["Charlie Puth"] }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "search_index",
        "_type" : "default_type_",
        "_id" : "9",
        "_score" : 1.0,
        "_source" : {
          "name" : "Charlie Puth",
          "age" : 43,
          "hobby" : null
        }
      }
    ]
  }
}

Range Query

在一定范圍內將文檔與具有詞項的字段進行匹配。Lucene 查詢的類型取決于字段類型，對于字符串字段，是 TermRangeQuery，而對于數字/日期字段，是 NumericRangeQuery。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "range" : {
            "age" : { "gte" : 10,
                      "lte" : 20,
                      "boost" : 2.0 }
        }
    }
}

curl -X GET "localhost:9200/range_query_index/_search?&pretty&" -H 'Content-Type: application/json' -d'
{
    "query": {
        "range": {
            "age": { "gte": 10,
                     "lte": 24,
                     "boost": 2.0 }
        }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 2.0,
    "hits" : [
      {
        "_index" : "range_query_index",
        "_type" : "default_type_",
        "_id" : "2",
        "_score" : 2.0,
        "_source" : {
          "name" : "james",
          "age" : 23
        }
      }
    ]
  }
}

range query 接受以下這些參數:

gte：大于等于
gt：大于
lte：小于等于
lt：小于
boost：設置查詢的增強值，默認為 1.0

日期查詢

當對 date 類型的字段進行范圍查詢時，范圍可以使用 date Math 指定:

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "range" : {
            "date" : { "gte" : "now-1d/d",
                       "lt" :  "now/d" }
        }
    }
}

日期四舍五入

當使用 date Math 將日期四舍五入到最近的日、月、小時等時，四舍五入的日期取決于范圍的兩端是包含的還是不包含的。

向上四舍五入移動到四舍五入范圍的最后一毫秒，向下四舍五入到四舍五入范圍的第一毫秒。

gt：大于四舍五入的日期:2014-11-18||/M變成2014-11-30T23:59:59.999，即不包括整個月。
gte：大于或等于四舍五入的日期:2014-11-18||/M為2014-11-01，即包括整個月。
lt：小于四舍五入的日期:2014-11-18||/M變成2014-11-01，即不包括整個月。
lte：小于或等于四舍五入的日期:2014-11-18||/M變為2014-11-30T23:59:59.999，即包括整個月。

日期格式

默認情況下，格式化的日期將使用 date 字段指定的格式進行解析，但它可以通過將 format 參數傳遞給 range query 來覆蓋:

curl -XGET <host>:<port>/<index_name>/_search { "query": { "range" : { "born" : { "gte": "01/01/2012", "lte": "2013", "format": "dd/MM/yyyy||yyyy" } } } }

注意，如果日期漏掉了年或月或日，則用 unix 時間的開始（1970年1月1日）來填充缺失的部分。這意味著，例如，當指定 dd 作為格式時，像 "gte": 10 這樣的值將被轉換為 1970-01-10T00:00:00.000Z。

時區

日期可以從另一個時區轉換為 UTC，要么通過在日期值本身指定時區（如果格式接受），要么可以指定為 time_zone 參數:

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "range" : {
            "timestamp" : { "gte": "2015-01-01 00:00:00",
                            "lte": "now",
                            "time_zone": "+01:00" }
        }
    }
}

此日期將轉換為 2014-12-31T23:00:00 UTC。

Exists Query

返回原始字段中至少有一個非空值的文檔：

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "exists" : { "field" : "user" }
    }
}

要實現 missing query，要在 must_not 子句中使用 "exists" 查詢。這個查詢會返回 "user" 字段沒有值的文檔。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "bool": {
            "must_not": {
                "exists": { "field": "user" }
            }
        }
    }
}

Prefix Query

匹配具有包含具有指定前綴的詞項的字段的文檔（未被分析）。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "prefix" : { "user" : "ki" }
    }
}

curl -X GET "localhost:9200/prefix_index/_search?&pretty&" -H 'Content-Type: application/json' -d'
{
   "query": {
     "prefix": { "user": "ki" }
   }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "prefix_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "user" : "kimo"
        }
      }
    ]
  }
}

Wildcard Query

匹配具有匹配通配符表達式（未被分析）的字段的文檔。支持的通配符是 "*"，匹配任何字符序列（包括空字符），和 "?"，匹配任何單個字符。注意，這個查詢可能很慢，因為它需要遍歷許多詞項。為了使得 wildcard query 速度加快，通配符詞項不應該以通配符 "*" 或 "?" 之一開頭。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "wildcard" : { "user" : "ki*y" }
    }
}

curl  -X GET "localhost:9200/wildcard_index/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "wildcard": { "lyricE": { "value": "s*" } }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "wildcard_index",
        "_type" : "default_type_",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "lyricC" : "你的眼里有星河閃爍",
          "lyricE" : "There are stars in your eyes"
        }
      }
    ]
  }
}

Regexp Query

regexp query 允許使用正則表達式進行查詢。

注意：regexp query 的性能顯著受到所選用的正則表達式的影響。使用如 .* 這樣過于寬泛的正則表達式會導致查詢速度緩慢。建議盡可能在正則表達式的開始部分采用較長的固定前綴，以優化查詢性能。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "regexp":{ "name.first": "s.*y" }
    }
}

curl  -X GET "localhost:9200/regexp_index/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "regexp": { "value": { "value": ".*.*..*" } }
    }
}'

{
  ...
  "hits" : {
    "total" : 1,
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "regexp_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : 1.0,
        "_source" : {
          "value" : "aaba10aba20ab"
        }
      }
    ]
  }
}

可以使用 flag 參數，為正則表達式啟用可選運算符

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "regexp":{
            "name.first": { "value": "s.*y",
                            "flags" : "INTERSECTION|COMPLEMENT|EMPTY" }
        }
    }
}

特殊標志有 ALL（默認），ANYSTRING, COMPLEMENT, EMPTY, INTERSECTION, INTERVAL 或 NONE。

正則表達式很容易意外地創建一個看起來無害的表達式，它需要大量的內部確定自動機狀態（以及相應的 RAM 和 CPU）供 Lucene 執行。Lucene 使用 max_determinized_states 設置（默認為 10000）來阻止這些，可以提高這個限制以允許執行更復雜的正則表達式。

curl -XGET <host>:<port>/<index_name>/_search
{
    "query": {
        "regexp":{
            "name.first": { "value": "s.*y",
                            "flags" : "INTERSECTION|COMPLEMENT|EMPTY",
                            "max_determinized_states": 20000 }
        }
    }
}

Compound queries

Bool Query

一個查詢，使用其他查詢的布爾值組合進行匹配查詢，它使用一個或多個布爾子句構建。

must：子句（查詢）必須出現在匹配的文檔中。

filter：子句（查詢）必須出現在匹配的文檔中。

should：子句（查詢）應該出現在匹配的文檔中。

must_not：子句（查詢）不能出現在匹配的文檔中。

bool query 采用 more-matches-is-better 方法，因此每個匹配的 must 或 should 子句的分數將被加在一起，為每個文檔提供最終的分數。

curl -XPOST<host>:<port>/<index_name>/_search
{
    "query": {
        "bool" : {
            "must" : { "term" : { "user" : "kimchy" } },
        "filter": {
            "term" : { "tag" : "tech" } },
        "must_not" : { "range" : {"age" : { "gte" : 10, "lte" : 20 } } },
        "should" : [ { "term" : { "tag" : "wow" } },
                     { "term" : { "tag" : "elasticsearch" } } ],
        "minimum_should_match" : 1,
        "boost" : 1.0
        }
    }
}

curl  -X POST "localhost:9200/bool_index/_search?pretty" -H 'Content-Type: application/json' -d'
{
    "query": {
        "bool" : {
            "must_not" : {"range" : { "price" : { "lte" : 6.99 } } },
        "should" : [ { "term" : { "avaliable" : true } } ],
        "boost" : 2.0
        }
    }
}'

{
  ...
  "hits" : {
    "total" : 2,
    "max_score" : 0.26706278,
    "hits" : [
      {
        "_index" : "bool_index",
        "_type" : "default_type_",
        "_id" : "2",
        "_score" : 0.26706278,
        "_source" : {
          "name" : "Jump Ropes",
          "description" : "Lusuroi Jump Rope, Cable Adjustable Skipping Rope for Workout Fitness Exercise Training, Speed Jumping Rope for Kids Beginners Women Adults, Tangle-Free with Ball Bearings Gym Rope",
          "productID" : "C08H1P827X",
          "price" : 13.99,
          "avaliable" : true
        }
      },
      {
        "_index" : "bool_index",
        "_type" : "default_type_",
        "_id" : "3",
        "_score" : 0.26706278,
        "_source" : {
          "name" : "Beaded Jump Rope",
          "description" : "Beaded Jump Rope Tangle-Free with Ball Bearings Rapid Adjustable Skipping Rope Non-Slip Handle Speed Suitable for Fitness Workout Adult Kids Men Women-2 Packs",
          "productID" : "B087681ZJ2",
          "price" : 7.99,
          "avaliable" : true
        }
      }
    ]
  }
}

Minimum Should Match

mininum_should_match 參數可以有以下幾種類型的值：

Integer：表示一個固定值，與可選子句的數量無關。
Negative integer：表示可選子句的總數減去這個數字應該是強制性的。
Percentage：表示該可選子句總數的百分比是必需的。從百分比計算的數字向下舍入并用作最小值。
Negative percentage：表示可能缺少可選子句總數的這個百分比。從百分比計算的數字向下舍入，然后從總數中減去以確定最小值。
Combination：一個正整數，后跟小于號。它表示如果可選子句的數量等于（或小于）整數，則它們都是必需的，但如果大于整數，則適用規范。
Multiple combinations：多個條件說明可以用空格分隔，每個條件僅對大于其前一個的數字有效。

Function Score Query

function_score 允許您修改查詢檢索到的文檔的分數。要使用 function_score，用戶必須定義一個查詢和一個或多個函數，為查詢返回的每個文檔計算一個新分數。

GET /_search
{
    "query": {
        "function_score": {
            "query": { "match_all": {} },
            "boost": "5",
            "random_score": {},
            "boost_mode":"multiply"
        }
    }
}

炒股如何开杠杆-华为手机炒股软件哪个好-【东方资本】,配资和加杠杆有什么区别,股市里面的杠杆,股票配资交易平台app