Elasticsearch how to use multi_match with wildcard

Question

I have a User object with properties Name and Surname. I want to search these fields using one query, and I found multi_match in the documentation, but I don't know how to properly use that with a wildcard. Is it possible?

I tried with a multi_match query but it didn't work:

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

score 113 · Accepted Answer · answered Jun 05 '13 at 08:35

113

Alternatively you could use a query_string query with wildcards.

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

This will be slower than using an nGram filter at index-time (see my other answer), but if you are looking for a quick and dirty solution...

Also I am not sure about your mapping, but if you are using user.name instead of name your mapping needs to look like this:

"your_type_name_here": {
    "properties": {
        "user": {
            "type": "object",
            "properties": {
                "name": {
                    "type": "string"
                },
                "surname": {
                    "type": "string"
                }
            }
        }
    }
}

answered Jun 05 '13 at 08:35

ramseykhalaf

3,371
2
17
16

1

The query_string does more than that, it exposes the lucene query syntax. I would rather look at the wildcard query. – javanna Jun 05 '13 at 20:53
Can you paste a link to details of what `query_string` does? I'm a little confused about the behaviour... – ramseykhalaf Jun 09 '13 at 07:18
1

Look at the bottom of this page for a comparison between query_string and match query: http://www.elasticsearch.org/guide/reference/query-dsl/match-query/ – javanna Jun 10 '13 at 08:42
5

The answer is not answering the question how to use multi_match and wildcard. Does someone has an idea? – Gizzmo May 14 '14 at 13:45
elastics docs about multimatch and regexp are such a headache. this worked great, thanks. – caro Sep 21 '17 at 14:49

score 20 · Answer 2 · answered May 26 '15 at 17:05

20

Such a query worked for me:

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

Similar to what you are doing, except that in my case there could be different masks for different fields.

answered May 26 '15 at 17:05

Catherine Tsokur

226
2
4

Thanks catherine Tsokur. I am also trying the same way but is there a way i can keep multiple wildcard conditions of same column. example : user.name can be of 5 different wildcard patterns. Please suggest how can i use that condition . – Sajal Saxena Jul 08 '20 at 12:57

score 12 · Answer 3 · edited May 14 '15 at 21:47

I just did this now:

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

score 8 · Answer 4 · answered Aug 13 '19 at 04:15

8

Similar to suggestion above, but this is simple and worked for me:

{
"query": {
    "bool": {
        "must":
        [
            {
                "wildcard" : { "processname.keyword" : "*system*" }
            },
            {
                "wildcard" : { "username" : "*admin*" }
            },
            {
                "wildcard" : { "device_name" : "*10*" }
            }
        ]
    }
}
}

answered Aug 13 '19 at 04:15

It will fail if one is broken. So each of these properties needs the same part of the string.. – Oliver Dixon Mar 29 '21 at 13:50

score 7 · Answer 5 · edited May 23 '17 at 10:31

7

I would not use wildcards, it will not scale well. You are asking a lot of the search engine at query time. You can use the nGram filter, to do the processing at index-time not search time.

See this discussion on the nGram filter.

After indexing the name and surname correctly (change your mapping, there are examples in the above link) you can use multi-match but without wildcards and get the expected results.

edited May 23 '17 at 10:31

Community

1
1

answered Jun 05 '13 at 07:44

ramseykhalaf

3,371
2
17
16

3

Downside: the index size is going to grow a lot. – javanna Jun 05 '13 at 20:51

score 1 · Answer 6 · answered Feb 15 '22 at 23:46

description: {
  type: 'keyword',
  normalizer: 'useLowercase',
},
product: {
      type: 'object',
      properties: {
        name: {
          type: 'keyword',
          normalizer: 'useLowercase',
        },
      },
    },
activity: {
      type: 'object',
      properties: {
        name: {
          type: 'keyword',
          normalizer: 'useLowercase',
        },
      },
    },

query:

          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',
              },
            },
          ],

Elasticsearch how to use multi_match with wildcard

6 Answers6

Linked