Elasticsearch查询部分Location字段文档无返回的原因排查

Alright, let's break down why your term queries for Uppsala and Uddevalla aren't returning results while Norrköping works—this is almost always tied to how the Swedish analyzer is processing your location field vs. how you're querying it. Here are the most likely culprits and how to debug them:

1. The Swedish analyzer is modifying your city names (stemming/normalization) #

Term queries match exactly what's stored in the inverted index, but the Swedish analyzer applies stemming, lowercase conversion, and other normalization rules to your location values during indexing. Norrköping might survive the analyzer unchanged, while Uppsala/Uddevalla get transformed into unrecognizable tokens.

To verify this, use Elasticsearch's _analyze API to see how each city is processed:

GET _analyze
{
  "analyzer": "swedish",
  "text": ["Uppsala", "Uddevalla", "Norrköping"]
}

Compare the output tokens. For example, if Uppsala gets stemmed to uppsal (hypothetically), your term query for Uppsala won't match anything—you'd need to query the stemmed token instead.

If this is the issue, you have two solid fixes:

• Use a match query instead (it applies the same analyzer to your query text, so it'll automatically match the stemmed/normalized tokens)
• Add a keyword sub-field to your location mapping (so you can do exact term queries on the original, unanalyzed value):

  PUT /your_index/_mapping
  {
    "properties": {
      "location": {
        "type": "text",
        "analyzer": "swedish",
        "fields": {
          "keyword": {
            "type": "keyword"
          }
        }
      }
    }
  }
  

  Then query the keyword field:

  GET /your_index/_search
  {
    "query": {
      "term": {
        "location.keyword": "Uppsala"
      }
    }
  }
  

2. Hidden inconsistencies in your data or query #

Even if the analyzer looks okay, check for these easy-to-miss issues:

• Case sensitivity: If your analyzer converts values to lowercase, but you're querying Uppsala (uppercase) while the indexed token is uppsala, the term query will fail. The _analyze test above will show you the case of the stored tokens.
• Whitespace or hidden characters: Maybe your imported data has Uppsala (with a trailing space) or non-visible Unicode characters. Try a match query first—if it returns results, that confirms the raw value isn't exactly what you're querying.
• Failed imports: Double-check that the Uppsala/Uddevalla documents actually made it into the index. Run a match_all query and inspect the results to confirm those cities are present:

  GET /your_index/_search
  {
    "query": { "match_all": {} },
    "_source": ["location"]
  }
  

3. Incorrect mapping for the location field #

It's possible your location field isn't actually using the Swedish analyzer you configured. Verify your index mapping with:

GET /your_index/_mapping

Look for the location field—ensure its analyzer is explicitly set to swedish. If it's using the default standard analyzer, that could explain inconsistent behavior (since standard handles Swedish less predictably than the dedicated analyzer).

Start with the _analyze test—it's the fastest way to see how your data is being transformed under the hood. Once you run these checks, you'll almost certainly find the root cause.

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