全文クエリ - クエリ文字列（Query string） - 《Elasticsearchガイドv8.15》日本語

クエリ文字列クエリ
query_stringのトップレベルパラメータ
ノート
- クエリ文字列構文
ファジネスとワイルドカードの混合を避ける
同義語とquery_stringクエリ
- Php
- Python
- Ruby
- Go
- Js
- Console
How minimum_should_match works
- Python
- Ruby
- Go
- Js
- Console
How minimum_should_match works for multiple fields
- Python
- Ruby
- Go
- Js
- Console
- Python
- Ruby
- Go
- Js
- Console
How minimum_should_match works for cross-field searches
- Python
- Ruby
- Go
- Js
- Console
Allow expensive queries

クエリ文字列クエリ

このページには、query_stringクエリタイプに関する情報が含まれています。Elasticsearchで検索クエリを実行する方法については、検索APIを参照してください。

厳密な構文を持つパーサーを使用して、提供されたクエリ文字列に基づいてドキュメントを返します。

このクエリは、ANDやNOTなどの演算子に基づいて提供されたクエリ文字列を解析し、分割するための構文を使用します。クエリは、マッチするドキュメントを返す前に、各分割されたテキストを独立して分析します。


無効な構文に対してエラーを返すため、`````query_string`````クエリを検索ボックスで使用することはお勧めしません。  
クエリ構文をサポートする必要がない場合は、[`````match`````](/read/elasticsearch-8-15/6701b8226a9afe3f.md)クエリの使用を検討してください。クエリ構文の機能が必要な場合は、[`````simple_query_string`````](/read/elasticsearch-8-15/2579748a29ddaa31.md)クエリを使用してください。これは、より厳密ではありません。
## 例リクエスト
次の検索を実行すると、`````query_string`````クエリは`````(new york
city) OR (big apple)`````を`````new york city`````と`````big apple`````の2つの部分に分割します。`````content`````フィールドのアナライザーは、マッチするドキュメントを返す前に、各部分をトークンに独立して変換します。クエリ構文は空白を演算子として使用しないため、`````new york city`````はそのままアナライザーに渡されます。
#### Python
``````python
resp = client.search(
   query={
   "query_string": {
   "query": "(new york city) OR (big apple)",
   "default_field": "content"
   }
   },
)
print(resp)
`

Ruby

response = client.search(
  body: {
   query: {
   query_string: {
   query: '(new york city) OR (big apple)',
   default_field: 'content'
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithBody(strings.NewReader(`{
      "query": {
      "query_string": {
      "query": "(new york city) OR (big apple)",
      "default_field": "content"
      }
      }
    }`)),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  query: {
   query_string: {
   query: "(new york city) OR (big apple)",
   default_field: "content",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "query": {
   "query_string": {
   "query": "(new york city) OR (big apple)",
   "default_field": "content"
   }
  }
}

query_stringのトップレベルパラメータ

query
(必須、文字列) 解析して検索に使用するクエリ文字列。クエリ文字列構文を参照してください。
default_field
(オプション、文字列) クエリ文字列にフィールドが指定されていない場合に検索するデフォルトフィールド。ワイルドカード(*)をサポートします。
デフォルトは、index.query.default_fieldインデックス設定で、デフォルト値は*です。 *値は、用語クエリに適格なすべてのフィールドを抽出し、メタデータフィールドをフィルタリングします。抽出されたすべてのフィールドは、prefixが指定されていない場合にクエリを構築するために組み合わされます。
すべての適格フィールドを横断して検索することは、ネストされたドキュメントを含みません。これらのドキュメントを検索するには、nestedクエリを使用してください。
フィールド数が多いマッピングでは、すべての適格フィールドを横断して検索することは高コストになる可能性があります。
一度にクエリできるフィールド数と用語の数には制限があります。これは、indices.query.bool.max_clause_count 検索設定によって定義されています。
allow_leading_wildcard
(オプション、ブール値) trueの場合、ワイルドカード文字*と?はクエリ文字列の最初の文字として許可されます。デフォルトはtrueです。
analyze_wildcard
(オプション、ブール値) trueの場合、クエリはクエリ文字列内のワイルドカード用語を分析しようとします。デフォルトはfalseです。
analyzer
(オプション、文字列) アナライザーを使用して、クエリ文字列内のテキストをトークンに変換します。デフォルトは、default_fieldにマッピングされたインデックス時アナライザーです。アナライザーがマッピングされていない場合、インデックスのデフォルトアナライザーが使用されます。
auto_generate_synonyms_phrase_query
(オプション、ブール値) trueの場合、マッチフレーズクエリが自動的に作成されます。デフォルトはtrueです。同義語とquery_stringクエリの例を参照してください。
boost
(オプション、浮動小数点) クエリの関連スコアを減少または増加させるために使用される浮動小数点数。デフォルトは1.0です。ブースト値は1.0のデフォルト値に対して相対的です。 0と1.0の間のブースト値は関連スコアを減少させます。 1.0より大きい値は関連スコアを増加させます。
default_operator
(オプション、文字列) 演算子が指定されていない場合にクエリ文字列内のテキストを解釈するために使用されるデフォルトのブール論理。有効な値は次のとおりです:
- OR (デフォルト)
- たとえば、capital of Hungaryのクエリ文字列はcapital OR of OR Hungaryとして解釈されます。
- AND
- たとえば、capital of Hungaryのクエリ文字列はcapital AND of AND Hungaryとして解釈されます。
enable_position_increments
(オプション、ブール値) trueの場合、query_string検索から構築されたクエリで位置のインクリメントを有効にします。デフォルトはtrueです。
fields
(オプション、文字列の配列) 検索するフィールドの配列。ワイルドカード(*)をサポートします。
このパラメータクエリを使用して、複数のフィールドを横断して検索できます。複数フィールドの検索を参照してください。
fuzziness
(オプション、文字列) ファジーマッチのために許可される最大編集距離。ファジー構文については、ファジネスを参照してください。
fuzzy_max_expansions
(オプション、整数) ファジーマッチのためにクエリが拡張される最大用語数。デフォルトは50です。
fuzzy_prefix_length
(オプション、整数) ファジーマッチのために変更されない最初の文字数。デフォルトは0です。
fuzzy_transpositions
(オプション、ブール値) trueの場合、ファジーマッチのための編集には隣接する2文字の転置が含まれます (ab → ba)。デフォルトはtrueです。
lenient
(オプション、ブール値) trueの場合、数値フィールドにテキスト値を提供するなどの形式ベースのエラーは無視されます。デフォルトはfalseです。
max_determinized_states
(オプション、整数) クエリに必要な最大オートマトン状態。デフォルトは10000です。
Elasticsearchは、正規表現を解析するために内部でApache Luceneを使用します。Luceneは、各正規表現を有限オートマトンに変換し、いくつかの決定化された状態を含みます。
このパラメータを使用して、その変換が意図せずにリソースを消費しすぎるのを防ぐことができます。複雑な正規表現を実行するには、この制限を増やす必要がある場合があります。
minimum_should_match
(オプション、文字列) ドキュメントが返されるために一致する必要がある最小の句の数。有効な値と詳細については、minimum_should_matchパラメータを参照してください。 minimum_should_matchがどのように機能するかの例を参照してください。
quote_analyzer
(オプション、文字列) クエリ文字列内の引用されたテキストをトークンに変換するために使用されるアナライザー。デフォルトは、default_fieldにマッピングされたsearch_quote_analyzerです。
引用されたテキストの場合、このパラメータはanalyzerパラメータで指定されたアナライザーをオーバーライドします。
phrase_slop
(オプション、整数) フレーズの一致トークン間で許可される最大位置数。デフォルトは0です。 0の場合、正確なフレーズの一致が必要です。転置された用語は2のスロップを持ちます。
quote_field_suffix
(オプション、文字列) クエリ文字列内の引用されたテキストに追加される接尾辞。
この接尾辞を使用して、正確な一致のために異なる分析方法を使用できます。ステミングと正確な検索の混合を参照してください。
rewrite
(オプション、文字列) クエリを再書きするために使用されるメソッド。有効な値と詳細については、rewriteパラメータを参照してください。
time_zone
(オプション、文字列) 協定世界時 (UTC) オフセットまたは IANAタイムゾーンを使用して、クエリ文字列内のdate値をUTCに変換します。
有効な値は、+01:00や-08:00などのISO 8601 UTCオフセット、およびAmerica/Los_AngelesなどのIANAタイムゾーンIDです。
time_zoneパラメータは、nowの日付数学値に影響しません。 nowは常にUTCの現在のシステム時間です。ただし、time_zoneパラメータは、nowを使用して計算された日付と日付数学の丸めを変換します。たとえば、time_zoneパラメータはnow/dの値を変換します。

ノート

クエリ文字列構文

クエリ文字列「ミニ言語」は、クエリ文字列およびqクエリ文字列パラメータで使用されます。

クエリ文字列は、一連の用語と演算子に解析されます。用語は単一の単語（quickまたはbrown）または、二重引用符で囲まれたフレーズ（"quick brown"）であり、フレーズ内のすべての単語を同じ順序で検索します。

演算子を使用すると、検索をカスタマイズできます。利用可能なオプションは以下に説明されています。

フィールド名

クエリ構文で検索するフィールドを指定できます:

```
``````bash
status:active
`
```
```
``````bash
title:(quick OR brown)
`
```
authorフィールドが正確なフレーズ"john smith"を含む場合
```
author:"John Smith"
```
first nameフィールドがAliceを含む場合（スペースをバックスラッシュでエスケープする必要があることに注意してください）
```
first\ name:Alice
```
```
``````bash
book.\*:(quick OR brown)
`
```
```
``````bash
_exists_:title
`
```

ワイルドカード

ワイルドカード検索は、?を使用して単一の文字を置き換え、*を使用してゼロまたはそれ以上の文字を置き換えることで、個々の用語に対して実行できます:

qu?ck bro*

ワイルドカードクエリは膨大なメモリを使用し、非常に悪いパフォーマンスを発揮する可能性があることに注意してください。"a* b* c*"というクエリ文字列に一致するために、どれだけの用語をクエリする必要があるか考えてみてください。

純粋なワイルドカード\*は、効率のためにexistsクエリに書き換えられます。その結果、ワイルドカード"field:*"は、次のような空の値を持つドキュメントに一致します:

{
  "field": ""
}

…フィールドが欠落しているか、次のように明示的なNULL値が設定されている場合は一致しません:

{
  "field": null
}

単語の先頭にワイルドカードを許可すること（例："*ing"）は特に重いです。なぜなら、すべてのインデックス内の用語を調べる必要があるからです。先頭のワイルドカードは、allow_leading_wildcardをfalseに設定することで無効にできます。

文字レベルで動作する分析チェーンの一部のみが適用されます。たとえば、アナライザーが小文字化とステミングの両方を実行する場合、小文字化のみが適用されます。文字が欠落している単語に対してステミングを実行するのは間違いです。


#### 正規表現
正規表現パターンは、スラッシュ（`````"/"`````）で囲むことによってクエリ文字列に埋め込むことができます:  
``````bash
name:/joh?n(ath[oa]n)/
`

サポートされている正規表現構文は、正規表現構文で説明されています。


``````bash
/.*n/
`

注意して使用してください！

ファジネス

fuzzyクエリを~演算子を使用して実行できます:

quikc~ brwn~ foks~

これらのクエリでは、クエリ文字列が正規化されます。存在する場合、アナライザーから特定のフィルターのみが適用されます。適用可能なフィルターのリストについては、正規化子を参照してください。

クエリは、ダメラウ・レーヴェンシュタイン距離を使用して、最大2回の変更を持つすべての用語を見つけます。変更は、単一の文字の挿入、削除、または置換、または隣接する2文字の転置です。

デフォルトの編集距離は2ですが、1の編集距離は、すべての人間の誤字の80%をキャッチするのに十分であるはずです。次のように指定できます:

quikc~1

ファジネスとワイルドカードの混合を避ける

ファジーとワイルドカード演算子の混合はサポートされていません。混合されると、演算子の1つが適用されません。たとえば、app~1（ファジー）またはapp*（ワイルドカード）を検索できますが、app*~1の検索ではファジー演算子（~1）が適用されません。

近接検索

フレーズクエリ（例："john smith"）は、すべての用語が正確に同じ順序であることを期待しますが、近接クエリでは指定された単語がさらに離れているか、異なる順序であることを許可します。ファジークエリが単語内の文字の最大編集距離を指定できるのと同様に、近接検索ではフレーズ内の単語の最大編集距離を指定できます:

"fox quick"~5

フィールド内のテキストがクエリ文字列で指定された元の順序に近いほど、そのドキュメントはより関連性が高いと見なされます。上記の例のクエリと比較すると、フレーズ"quick fox"は"quick brown fox"よりも関連性が高いと見なされます。

範囲

日付、数値、または文字列フィールドの範囲を指定できます。包括的な範囲は角括弧[min TO max]で指定され、排他的な範囲は波括弧{min TO max}で指定されます。

2012年のすべての日:
```
date:[2012-01-01 TO 2012-12-31]
```
数字1..5
```
count:[1 TO 5]
```
```
``````bash
tag:{alpha TO omega}
`
```
10以上の数字
```
count:[10 TO *]
```
2012年以前の日付
```
date:{* TO 2012-01-01}
```

波括弧と角括弧は組み合わせることができます:

1から5未満の数字
```
count:[1 TO 5}
```

片側が無制限の範囲は、次の構文を使用できます:

age:>10
age:>=10
age:<10
age:<=10

簡略化された構文で上限と下限を組み合わせるには、AND演算子で2つの句を結合する必要があります:

age:(>=10 AND <20)
age:(+>=10 +<20)

クエリ文字列内の範囲の解析は複雑でエラーが発生しやすいです。明示的なrangeクエリを使用する方がはるかに信頼性があります。

ブースティング

ブースト演算子^を使用して、1つの用語を他の用語よりも関連性を高くします。たとえば、すべてのドキュメントを見つけたいが、特に速いキツネに興味がある場合:

quick^2 fox

デフォルトのboost値は1ですが、任意の正の浮動小数点数にすることができます。

ブーストはフレーズやグループにも適用できます:

"john smith"^2   (foo bar)^4

ブール演算子

デフォルトでは、すべての用語はオプションであり、1つの用語が一致する限りです。foo bar bazの検索は、fooまたはbarまたはbazのいずれかを含む任意のドキュメントを見つけます。すでにdefault_operatorについて説明しましたが、すべての用語を必須にすることもできますが、クエリ文字列自体で使用できるブール演算子もあります。

優先される演算子は+（この用語は必ず存在する必要があります）と-（この用語は存在してはならない）です。他のすべての用語はオプションです。たとえば、このクエリ:

quick brown +fox -news

は次のことを示します:

foxは存在する必要があります
newsは存在してはならない
quickとbrownはオプションであり、それらの存在は関連性を高めます

よく知られたブール演算子AND、OR、NOT（&&、||、!とも書かれます）もサポートされていますが、通常の優先順位ルールを尊重しないため、複数の演算子を一緒に使用する場合は括弧を使用する必要があります。たとえば、前のクエリは次のように書き換えることができます:

((quick AND fox) OR (brown AND fox) OR fox) AND NOT news
この形式は、元のクエリのロジックを正しく再現しますが、関連性スコアは元のものとはほとんど関係がありません。

対照的に、matchクエリを使用して書き換えた同じクエリは次のようになります:

{
   "bool": {
   "must":     { "match": "fox"         },
   "should":   { "match": "quick brown" },
   "must_not": { "match": "news"        }
   }
}

グルーピング

複数の用語や句を括弧でグループ化してサブクエリを形成できます:

(quick OR brown) AND fox

グループは特定のフィールドをターゲットにしたり、サブクエリの結果をブーストしたりするために使用できます:

status:(active OR pending) title:(full text search)^2

予約文字

クエリ自体で演算子として機能する文字を使用する必要がある場合（演算子としてではなく）、先頭にバックスラッシュを付けてエスケープする必要があります。たとえば、(1+1)=2を検索するには、クエリを\(1\+1\)\=2として記述する必要があります。リクエストボディにJSONを使用する場合、2つの前のバックスラッシュ（\\）が必要です。バックスラッシュはJSON文字列内で予約されたエスケープ文字です。

Python

resp = client.search(
   index="my-index-000001",
   query={
   "query_string": {
   "query": "kimchy\\!",
   "fields": [
   "user.id"
   ]
   }
   },
)
print(resp)

Ruby

response = client.search(
  index: 'my-index-000001',
  body: {
   query: {
   query_string: {
   query: 'kimchy\\!',
   fields: [
   'user.id'
   ]
   }
   }
  }
)
puts response

Js

const response = await client.search({
  index: "my-index-000001",
  query: {
   query_string: {
   query: "kimchy\\!",
   fields: ["user.id"],
   },
  },
});
console.log(response);

コンソール

GET /my-index-000001/_search
{
  "query" : {
   "query_string" : {
   "query" : "kimchy\\!",
   "fields"  : ["user.id"]
   }
  }
}

予約文字は次のとおりです: + - = && || > < ! ( ) { } [ ] ^ " ~ * ? : \ /

これらの特殊文字を正しくエスケープしないと、クエリが実行されない構文エラーが発生する可能性があります。


#### 空白と空のクエリ
空白は演算子とは見なされません。  
クエリ文字列が空であるか、空白のみを含む場合、クエリは空の結果セットを返します。
#### ネストされたドキュメントに対してquery_stringクエリを使用しない
`````query_string`````検索は、[ネストされた](/read/elasticsearch-8-15/5ccf197014f16687.md)ドキュメントを返しません。ネストされたドキュメントを検索するには、[`````nested`````クエリ](/read/elasticsearch-8-15/8886f20469cb015a.md)を使用してください。
#### 複数フィールドの検索
`````fields`````パラメータを使用して、複数のフィールドに対して`````query_string`````検索を実行できます。  
複数のフィールドに対して`````query_string`````クエリを実行するアイデアは、各クエリ用語を次のようなOR句に展開することです:  
``````bash
field1:query_term OR field2:query_term | ...
`

たとえば、次のクエリ

Python

resp = client.search(
   query={
   "query_string": {
   "fields": [
   "content",
   "name"
   ],
   "query": "this AND that"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   query_string: {
   fields: [
   'content',
   'name'
   ],
   query: 'this AND that'
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithBody(strings.NewReader(`{
      "query": {
      "query_string": {
      "fields": [
      "content",
      "name"
      ],
      "query": "this AND that"
      }
      }
    }`)),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  query: {
   query_string: {
   fields: ["content", "name"],
   query: "this AND that",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "query": {
   "query_string": {
   "fields": [ "content", "name" ],
   "query": "this AND that"
   }
  }
}

同じ単語に一致します

Python

resp = client.search(
   query={
   "query_string": {
   "query": "(content:this OR name:this) AND (content:that OR name:that)"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   query_string: {
   query: '(content:this OR name:this) AND (content:that OR name:that)'
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithBody(strings.NewReader(`{
      "query": {
      "query_string": {
      "query": "(content:this OR name:this) AND (content:that OR name:that)"
      }
      }
    }`)),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  query: {
   query_string: {
   query: "(content:this OR name:this) AND (content:that OR name:that)",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "query": {
   "query_string": {
   "query": "(content:this OR name:this) AND (content:that OR name:that)"
   }
  }
}

複数のクエリが個々の検索用語から生成されるため、それらを組み合わせることは自動的にdis_maxクエリとtie_breakerを使用して行われます。たとえば（nameは^5表記を使用して5倍にブーストされます）:

Python

resp = client.search(
   query={
   "query_string": {
   "fields": [
   "content",
   "name^5"
   ],
   "query": "this AND that OR thus",
   "tie_breaker": 0
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   query_string: {
   fields: [
   'content',
   'name^5'
   ],
   query: 'this AND that OR thus',
   tie_breaker: 0
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithBody(strings.NewReader(`{
      "query": {
      "query_string": {
      "fields": [
      "content",
      "name^5"
      ],
      "query": "this AND that OR thus",
      "tie_breaker": 0
      }
      }
    }`)),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  query: {
   query_string: {
   fields: ["content", "name^5"],
   query: "this AND that OR thus",
   tie_breaker: 0,
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "query": {
   "query_string" : {
   "fields" : ["content", "name^5"],
   "query" : "this AND that OR thus",
   "tie_breaker" : 0
   }
  }
}

単純なワイルドカードを使用して、ドキュメントの特定の内部要素の「内側」で検索することもできます。たとえば、cityオブジェクトに複数のフィールド（またはフィールドを持つ内部オブジェクト）がある場合、すべての「city」フィールドで自動的に検索できます:

Python

resp = client.search(
   query={
   "query_string": {
   "fields": [
   "city.*"
   ],
   "query": "this AND that OR thus"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   query_string: {
   fields: [
   'city.*'
   ],
   query: 'this AND that OR thus'
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithBody(strings.NewReader(`{
      "query": {
      "query_string": {
      "fields": [
      "city.*"
      ],
      "query": "this AND that OR thus"
      }
      }
    }`)),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  query: {
   query_string: {
   fields: ["city.*"],
   query: "this AND that OR thus",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "query": {
   "query_string" : {
   "fields" : ["city.*"],
   "query" : "this AND that OR thus"
   }
  }
}

もう1つのオプションは、クエリ文字列自体にワイルドカードフィールド検索を提供することです（*記号を適切にエスケープして）、たとえば: city.\*:something:

Python

resp = client.search(
   query={
   "query_string": {
   "query": "city.\\*:(this AND that OR thus)"
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   query_string: {
   query: 'city.\\*:(this AND that OR thus)'
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithBody(strings.NewReader(`{
      "query": {
      "query_string": {
      "query": "city.\\*:(this AND that OR thus)"
      }
      }
    }`)),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  query: {
   query_string: {
   query: "city.\\*:(this AND that OR thus)",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "query": {
   "query_string" : {
   "query" : "city.\\*:(this AND that OR thus)"
   }
  }
}


フィールドパラメータには、パターンベースのフィールド名も含めることができ、関連するフィールドに自動的に展開されます（動的に導入されたフィールドを含む）。たとえば:
#### Python
``````python
resp = client.search(
   query={
   "query_string": {
   "fields": [
   "content",
   "name.*^5"
   ],
   "query": "this AND that OR thus"
   }
   },
)
print(resp)
`

Ruby

response = client.search(
  body: {
   query: {
   query_string: {
   fields: [
   'content',
   'name.*^5'
   ],
   query: 'this AND that OR thus'
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithBody(strings.NewReader(`{
      "query": {
      "query_string": {
      "fields": [
      "content",
      "name.*^5"
      ],
      "query": "this AND that OR thus"
      }
      }
    }`)),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  query: {
   query_string: {
   fields: ["content", "name.*^5"],
   query: "this AND that OR thus",
   },
  },
});
console.log(response);

コンソール

GET /_search
{
  "query": {
   "query_string" : {
   "fields" : ["content", "name.*^5"],
   "query" : "this AND that OR thus"
   }
  }
}

複数フィールド検索の追加パラメータ


-   `````type

(オプション、文字列) クエリがドキュメントに一致し、スコアを付ける方法を決定します。有効な値は次のとおりです:
- best_fields (デフォルト)
- 任意のフィールドに一致するドキュメントを見つけ、マッチするフィールドの最高_scoreを使用します。 best_fieldsを参照してください。
- bool_prefix
- 各フィールドにmatch_bool_prefixクエリを作成し、各フィールドから_scoreを組み合わせます。 bool_prefixを参照してください。
- cross_fields
- 同じanalyzerを持つフィールドを1つの大きなフィールドのように扱います。 任意のフィールド内の各単語を探します。 cross_fieldsを参照してください。
- most_fields
- 任意のフィールドに一致するドキュメントを見つけ、各フィールドから_scoreを組み合わせます。 most_fieldsを参照してください。
- phrase
- 各フィールドにmatch_phraseクエリを実行し、最良のフィールドから_scoreを使用します。 phraseおよびphrase_prefixを参照してください。
- phrase_prefix
- 各フィールドにmatch_phrase_prefixクエリを実行し、最良のフィールドから_scoreを使用します。 phraseおよびphrase_prefixを参照してください。
  注: 追加のトップレベルmulti_matchパラメータは、type値に基づいて利用可能な場合があります。

同義語とquery_stringクエリ

query_stringクエリは、同義語グラフトークンフィルターを使用して、マルチターム同義語の展開をサポートしています。このフィルターが使用されると、パーサーは各マルチターム同義語のためにフレーズクエリを作成します。たとえば、次の同義語: ny, new yorkは次のようになります:

(ny OR ("new york"))

同義語を接続詞で一致させることも可能です:

Php

$params = [
   'body' => [
   'query' => [
   'query_string' => [
   'default_field' => 'title',
   'query' => 'ny city',
   'auto_generate_synonyms_phrase_query' => false,
   ],
   ],
   ],
];
$response = $client->search($params);

Python

resp = client.search(
   query={
   "query_string": {
   "default_field": "title",
   "query": "ny city",
   "auto_generate_synonyms_phrase_query": False
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   query_string: {
   default_field: 'title',
   query: 'ny city',
   auto_generate_synonyms_phrase_query: false
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithBody(strings.NewReader(`{
      "query": {
      "query_string": {
      "default_field": "title",
      "query": "ny city",
      "auto_generate_synonyms_phrase_query": false
      }
      }
    }`)),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  query: {
   query_string: {
   default_field: "title",
   query: "ny city",
   auto_generate_synonyms_phrase_query: false,
   },
  },
});
console.log(response);

Console

GET /_search
{
   "query": {
   "query_string" : {
   "default_field": "title",
   "query" : "ny city",
   "auto_generate_synonyms_phrase_query" : false
   }
   }
}

上記の例は、ブールクエリを作成します:

(ny OR (new AND york)) city

これは、用語 ny または接続詞 new AND york を持つドキュメントに一致します。デフォルトでは、パラメータ auto_generate_synonyms_phrase_query は true に設定されています。

How minimum_should_match works

query_string は、各演算子の周りでクエリを分割し、全体の入力に対するブールクエリを作成します。minimum_should_match を使用して、結果のクエリ内の「should」句がいくつ一致するべきかを制御できます。

Python

resp = client.search(
   query={
   "query_string": {
   "fields": [
   "title"
   ],
   "query": "this that thus",
   "minimum_should_match": 2
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   query_string: {
   fields: [
   'title'
   ],
   query: 'this that thus',
   minimum_should_match: 2
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithBody(strings.NewReader(`{
      "query": {
      "query_string": {
      "fields": [
      "title"
      ],
      "query": "this that thus",
      "minimum_should_match": 2
      }
      }
    }`)),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  query: {
   query_string: {
   fields: ["title"],
   query: "this that thus",
   minimum_should_match: 2,
   },
  },
});
console.log(response);

Console

GET /_search
{
  "query": {
   "query_string": {
   "fields": [
   "title"
   ],
   "query": "this that thus",
   "minimum_should_match": 2
   }
  }
}

上記の例は、ブールクエリを作成します:

(title:this title:that title:thus)~2

これは、単一のフィールド title において、用語 this、that または thus のうち少なくとも2つを持つドキュメントに一致します。

How minimum_should_match works for multiple fields

Python

resp = client.search(
   query={
   "query_string": {
   "fields": [
   "title",
   "content"
   ],
   "query": "this that thus",
   "minimum_should_match": 2
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   query_string: {
   fields: [
   'title',
   'content'
   ],
   query: 'this that thus',
   minimum_should_match: 2
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithBody(strings.NewReader(`{
      "query": {
      "query_string": {
      "fields": [
      "title",
      "content"
      ],
      "query": "this that thus",
      "minimum_should_match": 2
      }
      }
    }`)),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  query: {
   query_string: {
   fields: ["title", "content"],
   query: "this that thus",
   minimum_should_match: 2,
   },
  },
});
console.log(response);

Console

GET /_search
{
  "query": {
   "query_string": {
   "fields": [
   "title",
   "content"
   ],
   "query": "this that thus",
   "minimum_should_match": 2
   }
  }
}

上記の例は、ブールクエリを作成します:

((content:this content:that content:thus) | (title:this title:that title:thus))

これは、フィールド title と content の最大の選択肢を持つドキュメントに一致します。ここでは、minimum_should_match パラメータは適用できません。

Python

resp = client.search(
   query={
   "query_string": {
   "fields": [
   "title",
   "content"
   ],
   "query": "this OR that OR thus",
   "minimum_should_match": 2
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   query_string: {
   fields: [
   'title',
   'content'
   ],
   query: 'this OR that OR thus',
   minimum_should_match: 2
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithBody(strings.NewReader(`{
      "query": {
      "query_string": {
      "fields": [
      "title",
      "content"
      ],
      "query": "this OR that OR thus",
      "minimum_should_match": 2
      }
      }
    }`)),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  query: {
   query_string: {
   fields: ["title", "content"],
   query: "this OR that OR thus",
   minimum_should_match: 2,
   },
  },
});
console.log(response);

Console

GET /_search
{
  "query": {
   "query_string": {
   "fields": [
   "title",
   "content"
   ],
   "query": "this OR that OR thus",
   "minimum_should_match": 2
   }
  }
}

明示的な演算子を追加すると、各用語が別々の句として考慮されることが強制されます。

上記の例は、ブールクエリを作成します:

((content:this | title:this) (content:that | title:that) (content:thus | title:thus))~2

これは、3つの「should」句のうち少なくとも2つに一致し、それぞれが各用語のフィールドに対する最大の選択肢で構成されています。

How minimum_should_match works for cross-field searches

フィールド type における cross_fields の値は、同じアナライザーを持つフィールドが入力が分析されるときにグループ化されることを示します。

Python

resp = client.search(
   query={
   "query_string": {
   "fields": [
   "title",
   "content"
   ],
   "query": "this OR that OR thus",
   "type": "cross_fields",
   "minimum_should_match": 2
   }
   },
)
print(resp)

Ruby

response = client.search(
  body: {
   query: {
   query_string: {
   fields: [
   'title',
   'content'
   ],
   query: 'this OR that OR thus',
   type: 'cross_fields',
   minimum_should_match: 2
   }
   }
  }
)
puts response

Go

res, err := es.Search(
    es.Search.WithBody(strings.NewReader(`{
      "query": {
      "query_string": {
      "fields": [
      "title",
      "content"
      ],
      "query": "this OR that OR thus",
      "type": "cross_fields",
      "minimum_should_match": 2
      }
      }
    }`)),
    es.Search.WithPretty(),
)
fmt.Println(res, err)

Js

const response = await client.search({
  query: {
   query_string: {
   fields: ["title", "content"],
   query: "this OR that OR thus",
   type: "cross_fields",
   minimum_should_match: 2,
   },
  },
});
console.log(response);

Console

GET /_search
{
  "query": {
   "query_string": {
   "fields": [
   "title",
   "content"
   ],
   "query": "this OR that OR thus",
   "type": "cross_fields",
   "minimum_should_match": 2
   }
  }
}

上記の例は、ブールクエリを作成します:

(blended(terms:[field2:this, field1:this]) blended(terms:[field2:that, field1:that]) blended(terms:[field2:thus, field1:thus]))~2

これは、3つの各用語のブレンドされたクエリのうち少なくとも2つを持つドキュメントに一致します。

Allow expensive queries

クエリ文字列クエリは、内部的に prefix query に変換される可能性があり、これは、接頭辞クエリがこちらで説明されているように無効にされている場合、クエリが実行されず、例外がスローされることを意味します。