ElasticSearch是否支持contains查询？Django项目中如何实现类似ORM的contains搜索

Hey there! Let's figure out how to get that "contains-like" search working in your Elasticsearch + Django project.

First, let's break down why your current match query only returns exact matches. Chances are your username field is mapped as a keyword type (which doesn't get split into tokens) or the text analyzer isn't set up to capture partial substrings. The default match query works by matching tokens from your search input to tokens in the indexed field—so if the username is a single token (like "john_doe") and you input "joh", there's no token match unless we adjust things.

Here are a few ways to get the "contains" behavior you want: #

1. Quick fix: Use match_phrase_prefix for prefix matching

If you want to match usernames that start with your search query (like Django's startswith but more flexible), match_phrase_prefix is a simple option. It matches phrases where the last term is a prefix of the indexed text.

Update your code like this:

q = request.GET.get('q')
users = UserDocument.search().query("match_phrase_prefix", username=q)

This will return users where username starts with your query string—great for autocomplete-like scenarios.

2. Wildcard query for any substring match

If you need to match the query string anywhere in the username (exactly like Django's contains), you can use a wildcard query. Just wrap your query with asterisks to indicate any characters before/after:

q = request.GET.get('q')
users = UserDocument.search().query("wildcard", username=f"*{q}*")

⚠️ Heads up: Wildcard queries with * at the start can be slow on large datasets because Elasticsearch can't use indexed tokens efficiently. Use this sparingly or only for small datasets.

3. Best practice: Use n-gram analysis for fast substring searches

For scalable, performant substring matching, set up an n-gram analyzer on your username field. This breaks the username into smaller character sequences (e.g., "john" becomes "jo", "oh", "hn") during indexing, so any partial match will hit those tokens.

First, update your UserDocument to define the analyzer:

from django_elasticsearch_dsl import Document, fields
from django_elasticsearch_dsl.registries import registry
from .models import User

@registry.register_document
class UserDocument(Document):
    username = fields.TextField(
        analyzer='ngram_analyzer',
        search_analyzer='standard'  # Use standard analyzer for search input
    )

    class Index:
        name = 'users'
        settings = {
            'analysis': {
                'analyzer': {
                    'ngram_analyzer': {
                        'tokenizer': 'ngram_tokenizer',
                        'filter': ['lowercase']  # Ensure case-insensitive matches
                    }
                },
                'tokenizer': {
                    'ngram_tokenizer': {
                        'type': 'ngram',
                        'min_gram': 2,  # Minimum length of character sequences
                        'max_gram': 10,  # Maximum length
                        'token_chars': ['letter', 'digit']  # Only split letters/digits
                    }
                }
            }
        }

    class Django:
        model = User
        fields = ['id', 'email']

After updating, reindex your data (so the n-grams are generated for existing users). Then your original match query will work perfectly for substring matches:

q = request.GET.get('q')
users = UserDocument.search().query("match", username=q)

This is the most efficient way to handle partial matches, especially as your user base grows.

To answer your final question: Yes, Elasticsearch absolutely supports "contains-like" searches—you just need to pick the right tool for your use case, as we covered above.

内容的提问来源于stack exchange，提问作者Adil Haydar