查询字符串查询

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

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

qu?ck bro*

请注意，通配符查询可能会占用大量内存并且性能非常差——试想一下，要匹配查询字符串 "a* b* c*" 需要查询多少个词条。

{
  "field": ""
}

{
  "field": null
}

只会应用在字符级别操作的分析链部分。因此，例如，如果分析器同时执行小写转换和词干提取，则只会应用小写转换：对缺少某些字母的单词执行词干提取是错误的。

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

可以通过将正则表达式模式包裹在正斜杠（"/"）中，将其嵌入到查询字符串中。

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

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

/.*n/

您可以使用 ~ 运算符运行 模糊查询。

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)

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

使用加权运算符 ^ 使一个词条比另一个词条更相关。例如，如果我们想找到所有关于狐狸的文档，但我们对快速的狐狸特别感兴趣：

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 字符串中保留的转义字符。

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

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

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 搜索不会返回 嵌套文档。要搜索嵌套文档，请使用 嵌套查询。

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

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

field1:query_term OR field2:query_term | ...

例如，以下查询

resp = client.search(
    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)

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"
    }
  }
}

匹配与以下相同的单词：

resp = client.search(
    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)

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)"
    }
  }
}

由于从单个搜索词条生成了多个查询，因此使用带有 tie_breaker 的 dis_max 查询自动完成它们的组合。例如（使用 ^5 表示法将 name 加权 5）：

resp = client.search(
    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)

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”字段。

resp = client.search(
    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)

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"
    }
  }
}

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

resp = client.search(
    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)

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)"
    }
  }
}

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

resp = client.search(
    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)

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"
    }
  }
}

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