查询字符串查询

您可以在查询语法中指定要搜索的字段

可以使用?替换单个字符，使用*替换零个或多个字符，对单个术语进行通配符搜索

qu?ck bro*

请注意，通配符查询可能会使用大量的内存，并且性能非常差，只需考虑一下要匹配查询字符串"a* b* c*"需要查询多少个术语。

{
  "field": ""
}

{
  "field": null
}

仅应用在字符级别运行的分析链部分。例如，如果分析器同时执行小写化和词干提取，则仅应用小写化：对缺少某些字母的单词执行词干提取将是错误的。

通过将analyze_wildcard设置为true，以*结尾的查询将被分析，并且将通过确保前N-1个标记的精确匹配以及最后一个标记的前缀匹配来构建不同的标记的布尔查询。

可以通过将正则表达式模式用正斜杠（"/"）括起来，将其嵌入查询字符串中

name:/joh?n(ath[oa]n)/

支持的正则表达式语法在正则表达式语法中解释。

/.*n/

您可以使用~运算符运行fuzzy查询

quikc~ brwn~ foks~

对于这些查询，查询字符串将被规范化。如果存在，则仅应用分析器中的某些过滤器。有关适用过滤器的列表，请参见规范器。

该查询使用Damerau-Levenshtein距离来查找最多有两个更改的所有术语，其中更改是指插入、删除或替换单个字符，或转置两个相邻字符。

默认的编辑距离为2，但编辑距离为1应该足以捕获80%的人类拼写错误。它可以指定为

quikc~1

虽然短语查询（例如"john smith"）期望所有术语都以完全相同的顺序出现，但邻近查询允许指定的单词相距更远或以不同的顺序出现。与模糊查询可以为单词中的字符指定最大编辑距离的方式相同，邻近搜索允许我们为短语中的单词指定最大编辑距离

"fox quick"~5

字段中的文本越接近查询字符串中指定的原始顺序，该文档的相关性就越高。与上面的示例查询相比，短语"quick fox"将被认为比"quick brown fox"更相关。

可以为日期、数字或字符串字段指定范围。包含范围用方括号[min TO max]指定，排除范围用花括号{min TO max}指定。

花括号和方括号可以组合使用

具有一个无界限侧的范围可以使用以下语法

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

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

查询字符串中范围的解析可能很复杂且容易出错。使用显式的range查询更可靠。

使用提升运算符^使一个术语比另一个术语更相关。例如，如果我们要查找有关狐狸的所有文档，但我们特别感兴趣的是快速狐狸

quick^2 fox

默认的boost值为 1，但可以是任何正浮点数。介于 0 和 1 之间的提升会降低相关性。

提升也可以应用于短语或组

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

默认情况下，所有术语都是可选的，只要有一个术语匹配即可。搜索foo bar baz将找到包含foo或bar或baz中的一个或多个的任何文档。我们已经讨论过上面的default_operator，它允许您强制所有术语都是必需的，但还有布尔运算符，它们可以在查询字符串本身中使用，以提供更多控制。

首选的运算符是+（此术语必须存在）和-（此术语不能存在）。所有其他术语都是可选的。例如，此查询

quick brown +fox -news

说明

熟悉的布尔运算符AND、OR和NOT（也写成&&、||和!）也受支持，但请注意，它们不遵守通常的优先级规则，因此在同时使用多个运算符时应使用括号。例如，前面的查询可以改写为

相反，使用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 作为请求主体时，需要两个前导反斜杠（\\）；反斜杠是 JSON 字符串中保留的转义字符。

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

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

保留字符为：+ - = && || > < ! ( ) { } [ ] ^ " ~ * ? : \ /

未能正确转义这些特殊字符可能会导致语法错误，从而阻止您的查询运行。

空格不被视为运算符。

如果查询字符串为空或仅包含空格，则查询将产生空结果集。

query_string 搜索不会返回 嵌套 文档。要搜索嵌套文档，请使用 nested 查询。

您可以使用 fields 参数在多个字段上执行 query_string 搜索。

对多个字段运行 query_string 查询的想法是将每个查询词扩展到一个 OR 子句，如下所示

field1:query_term OR field2:query_term | ...

例如，以下查询

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

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

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)

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

与以下查询匹配相同单词

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

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

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)

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

由于从各个搜索词生成多个查询，因此使用 dis_max 查询和 tie_breaker 自动组合它们。例如（name 使用 ^5 符号提升了 5 倍）

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

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

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)

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

简单的通配符也可以用于搜索文档中特定内部元素“内部”。例如，如果我们有一个带有几个字段（或带有字段的内部对象）的 city 对象，我们可以自动搜索所有“city”字段

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

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

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)

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

另一种选择是在查询字符串本身中提供通配符字段搜索（正确转义 * 符号），例如：city.\*:something

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

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

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)

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

fields 参数还可以包含基于模式的字段名称，允许自动扩展到相关字段（包括动态引入的字段）。例如

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

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

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)

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

在对多个字段运行 query_string 查询时，支持以下附加参数。