61

我有一个具有名称和姓氏属性的用户对象。我想使用一个查询来搜索这些字段，我multi_match在文档中找到了，但我不知道如何正确使用通配符。可能吗？

我尝试了一个multi_match查询，但它没有用：

{
    "query": {
        "multi_match": {
            "query": "*mar*",
            "fields": [
                "user.name",
                "user.surname"
            ]
        }
    }
}
4

6 回答 6

101

或者，您可以使用query_string带有通配符的查询。

"query": {
    "query_string": {
        "query": "*mar*",
        "fields": ["user.name", "user.surname"]
    }
}

这将比在索引时使用 nGram 过滤器要慢（请参阅我的其他答案），但如果您正在寻找一个快速而肮脏的解决方案......

另外我不确定您的映射，但如果您使用user.name而不是name映射，则需要如下所示：

"your_type_name_here": {
    "properties": {
        "user": {
            "type": "object",
            "properties": {
                "name": {
                    "type": "string"
                },
                "surname": {
                    "type": "string"
                }
            }
        }
    }
}
于 2013-06-05T08:35:07.770 回答
20

这样的查询对我有用：

{
  "query": {
    "filtered": {
      "query": {
        "match_all": {}
      },
      "filter": {
        "bool": {
          "should": [
            {"query": {"wildcard": {"user.name": {"value": "*mar*"}}}},
            {"query": {"wildcard": {"user.surname": {"value": "*mar*"}}}}
          ]
        }
      }
    }
  }
}

与您正在做的类似，除了在我的情况下，不同的字段可能有不同的掩码。

于 2015-05-26T17:05:28.893 回答
12

我现在才这样做：

GET _search {
    "query": {
        "bool": {
            "must": [
                {
                    "range": {
                        "theDate": {
                            "gte": "2014-01-01",
                            "lte": "2014-12-31"
                        }
                    }
                },
                {
                    "match" : {
                        "Country": "USA"
                    }
                }
            ],
            "should": [
                {
                    "wildcard" : { "Id_A" : "0*" }
                },
                {
                    "wildcard" : { "Id_B" : "0*" }
                }
            ],"minimum_number_should_match": 1
        }
    }
}
于 2015-05-14T20:52:58.490 回答
7

我不会使用通配符，它​​不会很好地扩展。您在查询时询问了很多搜索引擎。您可以使用 nGram 过滤器在索引时间而不是搜索时间进行处理。

请参阅有关 nGram 过滤器的讨论。

正确索引nameand后surname（更改映射，上面的链接中有示例），您可以使用多重匹配但不使用通配符并获得预期结果。

于 2013-06-05T07:44:35.543 回答
7

类似于上面的建议，但这很简单并且对我有用：

{
"query": {
    "bool": {
        "must":
        [
            {
                "wildcard" : { "processname.keyword" : "*system*" }
            },
            {
                "wildcard" : { "username" : "*admin*" }
            },
            {
                "wildcard" : { "device_name" : "*10*" }
            }
        ]
    }
}
}
于 2019-08-13T04:15:11.293 回答
0 
description: {
  type: 'keyword',
  normalizer: 'useLowercase',
},
product: {
      type: 'object',
      properties: {
        name: {
          type: 'keyword',
          normalizer: 'useLowercase',
        },
      },
    },
activity: {
      type: 'object',
      properties: {
        name: {
          type: 'keyword',
          normalizer: 'useLowercase',
        },
      },
    },

询问：

          query: {
            bool: {
              must: [
                {
                  bool: {
                    should: [
                      {
                        wildcard: {
                          description: {
                            value: `*${value ? value : ''}*`,
                            boost: 1.0,
                            rewrite: 'constant_score',
                          },
                        },
                      },
                      {
                        wildcard: {
                          'product.name': {
                            value: `*${value ? value : ''}*`,
                            boost: 1.0,
                            rewrite: 'constant_score',
                          },
                        },
                      },
                      {
                        wildcard: {
                          'activity.name': {
                            value: `*${value ? value : ''}*`,
                            boost: 1.0,
                            rewrite: 'constant_score',
                          },
                        },
                      },
                    ],
                  },
                },
                {
                  match: {
                    recordStatus: RecordStatus.Active,
                  },
                },
                {
                  bool: {
                    must_not: [
                      {
                        term: {
                          'user.id': req.currentUser?.id,
                        },
                      },
                    ],
                  },
                },
                {
                  bool: {
                    should: tags
                      ? tags.map((name: string) => {
                          return {
                            nested: {
                              path: 'tags',
                              query: {
                                match: {
                                  'tags.name': name,
                                },
                              },
                            },
                          };
                        })
                      : [],
                  },
                },
              ],
              filter: {
                bool: {
                  must_not: {
                    terms: {
                      id: existingIds ? existingIds : [],
                    },
                  },
                },
              },
            },
          },
          sort: [
            {
              updatedAt: {
                order: 'desc',
              },
            },
          ],
于 2022-02-15T23:46:41.850 回答